[CRYPTO] Use standard byte order macros wherever possible (06ace7a9) · Commits · e / devices / android_kernel_teracube_2e

arch/i386/crypto/aes.c

+23 −21

Original line number	Original line	Diff line number	Diff line
	@@ -36,6 +36,8 @@
	* Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>		* Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
	*		*
	*/		*/

			#include <asm/byteorder.h>
	#include <linux/kernel.h>		#include <linux/kernel.h>
	#include <linux/module.h>		#include <linux/module.h>
	#include <linux/init.h>		#include <linux/init.h>
	@@ -59,7 +61,6 @@ struct aes_ctx {
	};		};

	#define WPOLY 0x011b		#define WPOLY 0x011b
	#define u32_in(x) le32_to_cpup((const __le32 *)(x))
	#define bytes2word(b0, b1, b2, b3) \		#define bytes2word(b0, b1, b2, b3) \
	(((u32)(b3) << 24) \| ((u32)(b2) << 16) \| ((u32)(b1) << 8) \| (b0))		(((u32)(b3) << 24) \| ((u32)(b2) << 16) \| ((u32)(b1) << 8) \| (b0))

	@@ -393,13 +394,14 @@ aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len, u32 *flags)
	int i;		int i;
	u32 ss[8];		u32 ss[8];
	struct aes_ctx *ctx = ctx_arg;		struct aes_ctx *ctx = ctx_arg;
			const __le32 key = (const __le32 )in_key;

	/* encryption schedule */		/* encryption schedule */

	ctx->ekey[0] = ss[0] = u32_in(in_key);		ctx->ekey[0] = ss[0] = le32_to_cpu(key[0]);
	ctx->ekey[1] = ss[1] = u32_in(in_key + 4);		ctx->ekey[1] = ss[1] = le32_to_cpu(key[1]);
	ctx->ekey[2] = ss[2] = u32_in(in_key + 8);		ctx->ekey[2] = ss[2] = le32_to_cpu(key[2]);
	ctx->ekey[3] = ss[3] = u32_in(in_key + 12);		ctx->ekey[3] = ss[3] = le32_to_cpu(key[3]);

	switch(key_len) {		switch(key_len) {
	case 16:		case 16:
	@@ -410,8 +412,8 @@ aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len, u32 *flags)
	break;		break;

	case 24:		case 24:
	ctx->ekey[4] = ss[4] = u32_in(in_key + 16);		ctx->ekey[4] = ss[4] = le32_to_cpu(key[4]);
	ctx->ekey[5] = ss[5] = u32_in(in_key + 20);		ctx->ekey[5] = ss[5] = le32_to_cpu(key[5]);
	for (i = 0; i < 7; i++)		for (i = 0; i < 7; i++)
	ke6(ctx->ekey, i);		ke6(ctx->ekey, i);
	kel6(ctx->ekey, 7);		kel6(ctx->ekey, 7);
	@@ -419,10 +421,10 @@ aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len, u32 *flags)
	break;		break;

	case 32:		case 32:
	ctx->ekey[4] = ss[4] = u32_in(in_key + 16);		ctx->ekey[4] = ss[4] = le32_to_cpu(key[4]);
	ctx->ekey[5] = ss[5] = u32_in(in_key + 20);		ctx->ekey[5] = ss[5] = le32_to_cpu(key[5]);
	ctx->ekey[6] = ss[6] = u32_in(in_key + 24);		ctx->ekey[6] = ss[6] = le32_to_cpu(key[6]);
	ctx->ekey[7] = ss[7] = u32_in(in_key + 28);		ctx->ekey[7] = ss[7] = le32_to_cpu(key[7]);
	for (i = 0; i < 6; i++)		for (i = 0; i < 6; i++)
	ke8(ctx->ekey, i);		ke8(ctx->ekey, i);
	kel8(ctx->ekey, 6);		kel8(ctx->ekey, 6);
	@@ -436,10 +438,10 @@ aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len, u32 *flags)

	/* decryption schedule */		/* decryption schedule */

	ctx->dkey[0] = ss[0] = u32_in(in_key);		ctx->dkey[0] = ss[0] = le32_to_cpu(key[0]);
	ctx->dkey[1] = ss[1] = u32_in(in_key + 4);		ctx->dkey[1] = ss[1] = le32_to_cpu(key[1]);
	ctx->dkey[2] = ss[2] = u32_in(in_key + 8);		ctx->dkey[2] = ss[2] = le32_to_cpu(key[2]);
	ctx->dkey[3] = ss[3] = u32_in(in_key + 12);		ctx->dkey[3] = ss[3] = le32_to_cpu(key[3]);

	switch (key_len) {		switch (key_len) {
	case 16:		case 16:
	@@ -450,8 +452,8 @@ aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len, u32 *flags)
	break;		break;

	case 24:		case 24:
	ctx->dkey[4] = ff(ss[4] = u32_in(in_key + 16));		ctx->dkey[4] = ff(ss[4] = le32_to_cpu(key[4]));
	ctx->dkey[5] = ff(ss[5] = u32_in(in_key + 20));		ctx->dkey[5] = ff(ss[5] = le32_to_cpu(key[5]));
	kdf6(ctx->dkey, 0);		kdf6(ctx->dkey, 0);
	for (i = 1; i < 7; i++)		for (i = 1; i < 7; i++)
	kd6(ctx->dkey, i);		kd6(ctx->dkey, i);
	@@ -459,10 +461,10 @@ aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len, u32 *flags)
	break;		break;

	case 32:		case 32:
	ctx->dkey[4] = ff(ss[4] = u32_in(in_key + 16));		ctx->dkey[4] = ff(ss[4] = le32_to_cpu(key[4]));
	ctx->dkey[5] = ff(ss[5] = u32_in(in_key + 20));		ctx->dkey[5] = ff(ss[5] = le32_to_cpu(key[5]));
	ctx->dkey[6] = ff(ss[6] = u32_in(in_key + 24));		ctx->dkey[6] = ff(ss[6] = le32_to_cpu(key[6]));
	ctx->dkey[7] = ff(ss[7] = u32_in(in_key + 28));		ctx->dkey[7] = ff(ss[7] = le32_to_cpu(key[7]));
	kdf8(ctx->dkey, 0);		kdf8(ctx->dkey, 0);
	for (i = 1; i < 6; i++)		for (i = 1; i < 6; i++)
	kd8(ctx->dkey, i);		kd8(ctx->dkey, i);

arch/x86_64/crypto/aes.c

+11 −12

Original line number	Original line	Diff line number	Diff line
	@@ -74,8 +74,6 @@ static inline u8 byte(const u32 x, const unsigned n)
	return x >> (n << 3);		return x >> (n << 3);
	}		}

	#define u32_in(x) le32_to_cpu((const __le32 )(x))

	struct aes_ctx		struct aes_ctx
	{		{
	u32 key_length;		u32 key_length;
	@@ -234,6 +232,7 @@ static int aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len,
	u32 *flags)		u32 *flags)
	{		{
	struct aes_ctx *ctx = ctx_arg;		struct aes_ctx *ctx = ctx_arg;
			const __le32 key = (const __le32 )in_key;
	u32 i, j, t, u, v, w;		u32 i, j, t, u, v, w;

	if (key_len != 16 && key_len != 24 && key_len != 32) {		if (key_len != 16 && key_len != 24 && key_len != 32) {
	@@ -243,10 +242,10 @@ static int aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len,

	ctx->key_length = key_len;		ctx->key_length = key_len;

	D_KEY[key_len + 24] = E_KEY[0] = u32_in(in_key);		D_KEY[key_len + 24] = E_KEY[0] = le32_to_cpu(key[0]);
	D_KEY[key_len + 25] = E_KEY[1] = u32_in(in_key + 4);		D_KEY[key_len + 25] = E_KEY[1] = le32_to_cpu(key[1]);
	D_KEY[key_len + 26] = E_KEY[2] = u32_in(in_key + 8);		D_KEY[key_len + 26] = E_KEY[2] = le32_to_cpu(key[2]);
	D_KEY[key_len + 27] = E_KEY[3] = u32_in(in_key + 12);		D_KEY[key_len + 27] = E_KEY[3] = le32_to_cpu(key[3]);

	switch (key_len) {		switch (key_len) {
	case 16:		case 16:
	@@ -256,17 +255,17 @@ static int aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len,
	break;		break;

	case 24:		case 24:
	E_KEY[4] = u32_in(in_key + 16);		E_KEY[4] = le32_to_cpu(key[4]);
	t = E_KEY[5] = u32_in(in_key + 20);		t = E_KEY[5] = le32_to_cpu(key[5]);
	for (i = 0; i < 8; ++i)		for (i = 0; i < 8; ++i)
	loop6 (i);		loop6 (i);
	break;		break;

	case 32:		case 32:
	E_KEY[4] = u32_in(in_key + 16);		E_KEY[4] = le32_to_cpu(key[4]);
	E_KEY[5] = u32_in(in_key + 20);		E_KEY[5] = le32_to_cpu(key[5]);
	E_KEY[6] = u32_in(in_key + 24);		E_KEY[6] = le32_to_cpu(key[6]);
	t = E_KEY[7] = u32_in(in_key + 28);		t = E_KEY[7] = le32_to_cpu(key[7]);
	for (i = 0; i < 7; ++i)		for (i = 0; i < 7; ++i)
	loop8(i);		loop8(i);
	break;		break;

crypto/aes.c

+31 −29

Original line number	Original line	Diff line number	Diff line
	@@ -73,9 +73,6 @@ byte(const u32 x, const unsigned n)
	return x >> (n << 3);		return x >> (n << 3);
	}		}

	#define u32_in(x) le32_to_cpu((const u32 )(x))
	#define u32_out(to, from) ((u32 )(to) = cpu_to_le32(from))

	struct aes_ctx {		struct aes_ctx {
	int key_length;		int key_length;
	u32 E[60];		u32 E[60];
	@@ -256,6 +253,7 @@ static int
	aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len, u32 *flags)		aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len, u32 *flags)
	{		{
	struct aes_ctx *ctx = ctx_arg;		struct aes_ctx *ctx = ctx_arg;
			const __le32 key = (const __le32 )in_key;
	u32 i, t, u, v, w;		u32 i, t, u, v, w;

	if (key_len != 16 && key_len != 24 && key_len != 32) {		if (key_len != 16 && key_len != 24 && key_len != 32) {
	@@ -265,10 +263,10 @@ aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len, u32 *flags)

	ctx->key_length = key_len;		ctx->key_length = key_len;

	E_KEY[0] = u32_in (in_key);		E_KEY[0] = le32_to_cpu(key[0]);
	E_KEY[1] = u32_in (in_key + 4);		E_KEY[1] = le32_to_cpu(key[1]);
	E_KEY[2] = u32_in (in_key + 8);		E_KEY[2] = le32_to_cpu(key[2]);
	E_KEY[3] = u32_in (in_key + 12);		E_KEY[3] = le32_to_cpu(key[3]);

	switch (key_len) {		switch (key_len) {
	case 16:		case 16:
	@@ -278,17 +276,17 @@ aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len, u32 *flags)
	break;		break;

	case 24:		case 24:
	E_KEY[4] = u32_in (in_key + 16);		E_KEY[4] = le32_to_cpu(key[4]);
	t = E_KEY[5] = u32_in (in_key + 20);		t = E_KEY[5] = le32_to_cpu(key[5]);
	for (i = 0; i < 8; ++i)		for (i = 0; i < 8; ++i)
	loop6 (i);		loop6 (i);
	break;		break;

	case 32:		case 32:
	E_KEY[4] = u32_in (in_key + 16);		E_KEY[4] = le32_to_cpu(key[4]);
	E_KEY[5] = u32_in (in_key + 20);		E_KEY[5] = le32_to_cpu(key[5]);
	E_KEY[6] = u32_in (in_key + 24);		E_KEY[6] = le32_to_cpu(key[6]);
	t = E_KEY[7] = u32_in (in_key + 28);		t = E_KEY[7] = le32_to_cpu(key[7]);
	for (i = 0; i < 7; ++i)		for (i = 0; i < 7; ++i)
	loop8 (i);		loop8 (i);
	break;		break;
	@@ -324,13 +322,15 @@ aes_set_key(void ctx_arg, const u8 in_key, unsigned int key_len, u32 *flags)
	static void aes_encrypt(void ctx_arg, u8 out, const u8 *in)		static void aes_encrypt(void ctx_arg, u8 out, const u8 *in)
	{		{
	const struct aes_ctx *ctx = ctx_arg;		const struct aes_ctx *ctx = ctx_arg;
			const __le32 src = (const __le32 )in;
			__le32 dst = (__le32 )out;
	u32 b0[4], b1[4];		u32 b0[4], b1[4];
	const u32 *kp = E_KEY + 4;		const u32 *kp = E_KEY + 4;

	b0[0] = u32_in (in) ^ E_KEY[0];		b0[0] = le32_to_cpu(src[0]) ^ E_KEY[0];
	b0[1] = u32_in (in + 4) ^ E_KEY[1];		b0[1] = le32_to_cpu(src[1]) ^ E_KEY[1];
	b0[2] = u32_in (in + 8) ^ E_KEY[2];		b0[2] = le32_to_cpu(src[2]) ^ E_KEY[2];
	b0[3] = u32_in (in + 12) ^ E_KEY[3];		b0[3] = le32_to_cpu(src[3]) ^ E_KEY[3];

	if (ctx->key_length > 24) {		if (ctx->key_length > 24) {
	f_nround (b1, b0, kp);		f_nround (b1, b0, kp);
	@@ -353,10 +353,10 @@ static void aes_encrypt(void ctx_arg, u8 out, const u8 *in)
	f_nround (b1, b0, kp);		f_nround (b1, b0, kp);
	f_lround (b0, b1, kp);		f_lround (b0, b1, kp);

	u32_out (out, b0[0]);		dst[0] = cpu_to_le32(b0[0]);
	u32_out (out + 4, b0[1]);		dst[1] = cpu_to_le32(b0[1]);
	u32_out (out + 8, b0[2]);		dst[2] = cpu_to_le32(b0[2]);
	u32_out (out + 12, b0[3]);		dst[3] = cpu_to_le32(b0[3]);
	}		}

	/* decrypt a block of text */		/* decrypt a block of text */
	@@ -377,14 +377,16 @@ static void aes_encrypt(void ctx_arg, u8 out, const u8 *in)
	static void aes_decrypt(void ctx_arg, u8 out, const u8 *in)		static void aes_decrypt(void ctx_arg, u8 out, const u8 *in)
	{		{
	const struct aes_ctx *ctx = ctx_arg;		const struct aes_ctx *ctx = ctx_arg;
			const __le32 src = (const __le32 )in;
			__le32 dst = (__le32 )out;
	u32 b0[4], b1[4];		u32 b0[4], b1[4];
	const int key_len = ctx->key_length;		const int key_len = ctx->key_length;
	const u32 *kp = D_KEY + key_len + 20;		const u32 *kp = D_KEY + key_len + 20;

	b0[0] = u32_in (in) ^ E_KEY[key_len + 24];		b0[0] = le32_to_cpu(src[0]) ^ E_KEY[key_len + 24];
	b0[1] = u32_in (in + 4) ^ E_KEY[key_len + 25];		b0[1] = le32_to_cpu(src[1]) ^ E_KEY[key_len + 25];
	b0[2] = u32_in (in + 8) ^ E_KEY[key_len + 26];		b0[2] = le32_to_cpu(src[2]) ^ E_KEY[key_len + 26];
	b0[3] = u32_in (in + 12) ^ E_KEY[key_len + 27];		b0[3] = le32_to_cpu(src[3]) ^ E_KEY[key_len + 27];

	if (key_len > 24) {		if (key_len > 24) {
	i_nround (b1, b0, kp);		i_nround (b1, b0, kp);
	@@ -407,10 +409,10 @@ static void aes_decrypt(void ctx_arg, u8 out, const u8 *in)
	i_nround (b1, b0, kp);		i_nround (b1, b0, kp);
	i_lround (b0, b1, kp);		i_lround (b0, b1, kp);

	u32_out (out, b0[0]);		dst[0] = cpu_to_le32(b0[0]);
	u32_out (out + 4, b0[1]);		dst[1] = cpu_to_le32(b0[1]);
	u32_out (out + 8, b0[2]);		dst[2] = cpu_to_le32(b0[2]);
	u32_out (out + 12, b0[3]);		dst[3] = cpu_to_le32(b0[3]);
	}		}

crypto/anubis.c

+13 −25

Original line number	Original line	Diff line number	Diff line
	@@ -32,8 +32,10 @@
	#include <linux/init.h>		#include <linux/init.h>
	#include <linux/module.h>		#include <linux/module.h>
	#include <linux/mm.h>		#include <linux/mm.h>
			#include <asm/byteorder.h>
	#include <asm/scatterlist.h>		#include <asm/scatterlist.h>
	#include <linux/crypto.h>		#include <linux/crypto.h>
			#include <linux/types.h>

	#define ANUBIS_MIN_KEY_SIZE 16		#define ANUBIS_MIN_KEY_SIZE 16
	#define ANUBIS_MAX_KEY_SIZE 40		#define ANUBIS_MAX_KEY_SIZE 40
	@@ -461,8 +463,8 @@ static const u32 rc[] = {
	static int anubis_setkey(void ctx_arg, const u8 in_key,		static int anubis_setkey(void ctx_arg, const u8 in_key,
	unsigned int key_len, u32 *flags)		unsigned int key_len, u32 *flags)
	{		{
			const __be32 key = (const __be32 )in_key;
	int N, R, i, pos, r;		int N, R, i, r;
	u32 kappa[ANUBIS_MAX_N];		u32 kappa[ANUBIS_MAX_N];
	u32 inter[ANUBIS_MAX_N];		u32 inter[ANUBIS_MAX_N];

	@@ -483,13 +485,8 @@ static int anubis_setkey(void ctx_arg, const u8 in_key,
	ctx->R = R = 8 + N;		ctx->R = R = 8 + N;

	/* * map cipher key to initial key state (mu): */		/* * map cipher key to initial key state (mu): */
	for (i = 0, pos = 0; i < N; i++, pos += 4) {		for (i = 0; i < N; i++)
	kappa[i] =		kappa[i] = be32_to_cpu(key[i]);
	(in_key[pos ] << 24) ^
	(in_key[pos + 1] << 16) ^
	(in_key[pos + 2] << 8) ^
	(in_key[pos + 3] );
	}

	/*		/*
	* generate R + 1 round keys:		* generate R + 1 round keys:
	@@ -578,7 +575,9 @@ static int anubis_setkey(void ctx_arg, const u8 in_key,
	static void anubis_crypt(u32 roundKey[ANUBIS_MAX_ROUNDS + 1][4],		static void anubis_crypt(u32 roundKey[ANUBIS_MAX_ROUNDS + 1][4],
	u8 ciphertext, const u8 plaintext, const int R)		u8 ciphertext, const u8 plaintext, const int R)
	{		{
	int i, pos, r;		const __be32 src = (const __be32 )plaintext;
			__be32 dst = (__be32 )ciphertext;
			int i, r;
	u32 state[4];		u32 state[4];
	u32 inter[4];		u32 inter[4];

	@@ -586,14 +585,8 @@ static void anubis_crypt(u32 roundKey[ANUBIS_MAX_ROUNDS + 1][4],
	* map plaintext block to cipher state (mu)		* map plaintext block to cipher state (mu)
	* and add initial round key (sigma[K^0]):		* and add initial round key (sigma[K^0]):
	*/		*/
	for (i = 0, pos = 0; i < 4; i++, pos += 4) {		for (i = 0; i < 4; i++)
	state[i] =		state[i] = be32_to_cpu(src[i]) ^ roundKey[0][i];
	(plaintext[pos ] << 24) ^
	(plaintext[pos + 1] << 16) ^
	(plaintext[pos + 2] << 8) ^
	(plaintext[pos + 3] ) ^
	roundKey[0][i];
	}

	/*		/*
	* R - 1 full rounds:		* R - 1 full rounds:
	@@ -663,13 +656,8 @@ static void anubis_crypt(u32 roundKey[ANUBIS_MAX_ROUNDS + 1][4],
	* map cipher state to ciphertext block (mu^{-1}):		* map cipher state to ciphertext block (mu^{-1}):
	*/		*/

	for (i = 0, pos = 0; i < 4; i++, pos += 4) {		for (i = 0; i < 4; i++)
	u32 w = inter[i];		dst[i] = cpu_to_be32(inter[i]);
	ciphertext[pos ] = (u8)(w >> 24);
	ciphertext[pos + 1] = (u8)(w >> 16);
	ciphertext[pos + 2] = (u8)(w >> 8);
	ciphertext[pos + 3] = (u8)(w );
	}
	}		}

	static void anubis_encrypt(void ctx_arg, u8 dst, const u8 *src)		static void anubis_encrypt(void ctx_arg, u8 dst, const u8 *src)

crypto/blowfish.c

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -19,8 +19,10 @@
	#include <linux/init.h>		#include <linux/init.h>
	#include <linux/module.h>		#include <linux/module.h>
	#include <linux/mm.h>		#include <linux/mm.h>
			#include <asm/byteorder.h>
	#include <asm/scatterlist.h>		#include <asm/scatterlist.h>
	#include <linux/crypto.h>		#include <linux/crypto.h>
			#include <linux/types.h>

	#define BF_BLOCK_SIZE 8		#define BF_BLOCK_SIZE 8
	#define BF_MIN_KEY_SIZE 4		#define BF_MIN_KEY_SIZE 4