cipher-mars.c

海思KEY驱动

	return 0;
};
#else /* defined(CIPHER_MARS_ROUND_1) */
static int
mars_set_key (struct cipher_context *cx, const unsigned char *key, int key_len,
	      int atomic)
{
	u32 i, j, m, t1, t2, *kp;
	const u32 *in_key = (const u32 *) key;
	u32 *l_key = cx->keyinfo;
	u32 t_key[15];		/* key mixing array */

	if (key_len != 16 && key_len != 24 && key_len != 32)
		return -EINVAL;	/* unsupported key length */

	m = key_len / 4;

	for (i = 0; i < m; ++i)
		t_key[i] = le32_to_cpu (in_key[i]);

	t_key[i++] = m;

	for (; i < 15; ++i)
		t_key[i] = 0;

	kp = l_key;

#define tk1(j) t1 = t_key[j] ^= rotl(t1 ^ t_key[(j + 8) % 15], 3) ^ (i + 4 * j)
#define tk2(j) t2 = t_key[j] ^= rotl(t2 ^ t_key[(j + 8) % 15], 3) ^ (i + 4 * j)
#define tk3(j) t_key[j] = t1 = rotl(t_key[j] + s_box[t1 & 511], 9)

	for (i = 0; i < 4; ++i) {
		t1 = t_key[13];
		t2 = t_key[14];

		tk1 (0);
		tk2 (1);
		tk1 (2);
		tk2 (3);
		tk1 (4);
		tk2 (5);
		tk1 (6);
		tk2 (7);
		tk1 (8);
		tk2 (9);
		tk1 (10);
		tk2 (11);
		tk1 (12);
		tk2 (13);
		tk1 (14);

		tk3 (0);
		tk3 (1);
		tk3 (2);
		tk3 (3);
		tk3 (4);
		tk3 (5);
		tk3 (6);
		tk3 (7);
		tk3 (8);
		tk3 (9);
		tk3 (10);
		tk3 (11);
		tk3 (12);
		tk3 (13);
		tk3 (14);

		tk3 (0);
		tk3 (1);
		tk3 (2);
		tk3 (3);
		tk3 (4);
		tk3 (5);
		tk3 (6);
		tk3 (7);
		tk3 (8);
		tk3 (9);
		tk3 (10);
		tk3 (11);
		tk3 (12);
		tk3 (13);
		tk3 (14);

		tk3 (0);
		tk3 (1);
		tk3 (2);
		tk3 (3);
		tk3 (4);
		tk3 (5);
		tk3 (6);
		tk3 (7);
		tk3 (8);
		tk3 (9);
		tk3 (10);
		tk3 (11);
		tk3 (12);
		tk3 (13);
		tk3 (14);

		tk3 (0);
		tk3 (1);
		tk3 (2);
		tk3 (3);
		tk3 (4);
		tk3 (5);
		tk3 (6);
		tk3 (7);
		tk3 (8);
		tk3 (9);
		tk3 (10);
		tk3 (11);
		tk3 (12);
		tk3 (13);
		tk3 (14);

		*kp++ = t_key[0];
		*kp++ = t_key[4];
		*kp++ = t_key[8];
		*kp++ = t_key[12];
		*kp++ = t_key[1];
		*kp++ = t_key[5];
		*kp++ = t_key[9];
		*kp++ = t_key[13];
		*kp++ = t_key[2];
		*kp++ = t_key[6];
	}

	for (i = 5; i < 37; i += 2) {
		j = l_key[i] | 3;
		m = (~j ^ (j >> 1)) & 0x7fffffff;
		m &= (m >> 1) & (m >> 2);
		m &= (m >> 3) & (m >> 6);

		if (m) {
			m <<= 1;
			m |= (m << 1);
			m |= (m << 2);
			m |= (m << 4);
			m &= 0xfffffffc;
			j ^= (rotl (b_tab[l_key[i] & 3], l_key[i - 1]) & m);
		}

		l_key[i] = j;
	}

	return 0;
}
#endif /* defined(CIPHER_MARS_ROUND_1) */

static int
mars_encrypt (struct cipher_context *cx, const u8 *in, u8 *out, int size,
	      int atomic)
{
	u32 a, b, c, d, l, m, r;
	const u32 *l_key = cx->keyinfo;
	const u32 *in_blk = (const u32 *) in;
	u32 *out_blk = (u32 *) out;

	a = le32_to_cpu (in_blk[0]) + l_key[0];
	b = le32_to_cpu (in_blk[1]) + l_key[1];
	c = le32_to_cpu (in_blk[2]) + l_key[2];
	d = le32_to_cpu (in_blk[3]) + l_key[3];

	f_mix (a, b, c, d);
	a += d;
	f_mix (b, c, d, a);
	b += c;
	f_mix (c, d, a, b);
	f_mix (d, a, b, c);
	f_mix (a, b, c, d);
	a += d;
	f_mix (b, c, d, a);
	b += c;
	f_mix (c, d, a, b);
	f_mix (d, a, b, c);

	f_ktr (a, b, c, d, 4);
	f_ktr (b, c, d, a, 6);
	f_ktr (c, d, a, b, 8);
	f_ktr (d, a, b, c, 10);
	f_ktr (a, b, c, d, 12);
	f_ktr (b, c, d, a, 14);
	f_ktr (c, d, a, b, 16);
	f_ktr (d, a, b, c, 18);
	f_ktr (a, d, c, b, 20);
	f_ktr (b, a, d, c, 22);
	f_ktr (c, b, a, d, 24);
	f_ktr (d, c, b, a, 26);
	f_ktr (a, d, c, b, 28);
	f_ktr (b, a, d, c, 30);
	f_ktr (c, b, a, d, 32);
	f_ktr (d, c, b, a, 34);

	b_mix (a, b, c, d);
	b_mix (b, c, d, a);
	c -= b;
	b_mix (c, d, a, b);
	d -= a;
	b_mix (d, a, b, c);
	b_mix (a, b, c, d);
	b_mix (b, c, d, a);
	c -= b;
	b_mix (c, d, a, b);
	d -= a;
	b_mix (d, a, b, c);

	out_blk[0] = cpu_to_le32 (a - l_key[36]);
	out_blk[1] = cpu_to_le32 (b - l_key[37]);
	out_blk[2] = cpu_to_le32 (c - l_key[38]);
	out_blk[3] = cpu_to_le32 (d - l_key[39]);

	return 0;
}

static int
mars_decrypt (struct cipher_context *cx, const u8 *in, u8 *out, int size,
	      int atomic)
{
	u32 a, b, c, d, l, m, r;
	const u32 *l_key = cx->keyinfo;
	const u32 *in_blk = (const u32 *) in;
	u32 *out_blk = (u32 *) out;

	d = le32_to_cpu (in_blk[0]) + l_key[36];
	c = le32_to_cpu (in_blk[1]) + l_key[37];
	b = le32_to_cpu (in_blk[2]) + l_key[38];
	a = le32_to_cpu (in_blk[3]) + l_key[39];

	f_mix (a, b, c, d);
	a += d;
	f_mix (b, c, d, a);
	b += c;
	f_mix (c, d, a, b);
	f_mix (d, a, b, c);
	f_mix (a, b, c, d);
	a += d;
	f_mix (b, c, d, a);
	b += c;
	f_mix (c, d, a, b);
	f_mix (d, a, b, c);

	r_ktr (a, b, c, d, 34);
	r_ktr (b, c, d, a, 32);
	r_ktr (c, d, a, b, 30);
	r_ktr (d, a, b, c, 28);
	r_ktr (a, b, c, d, 26);
	r_ktr (b, c, d, a, 24);
	r_ktr (c, d, a, b, 22);
	r_ktr (d, a, b, c, 20);
	r_ktr (a, d, c, b, 18);
	r_ktr (b, a, d, c, 16);
	r_ktr (c, b, a, d, 14);
	r_ktr (d, c, b, a, 12);
	r_ktr (a, d, c, b, 10);
	r_ktr (b, a, d, c, 8);
	r_ktr (c, b, a, d, 6);
	r_ktr (d, c, b, a, 4);

	b_mix (a, b, c, d);
	b_mix (b, c, d, a);
	c -= b;
	b_mix (c, d, a, b);
	d -= a;
	b_mix (d, a, b, c);
	b_mix (a, b, c, d);
	b_mix (b, c, d, a);
	c -= b;
	b_mix (c, d, a, b);
	d -= a;
	b_mix (d, a, b, c);

	out_blk[0] = cpu_to_le32 (d - l_key[0]);
	out_blk[1] = cpu_to_le32 (c - l_key[1]);
	out_blk[2] = cpu_to_le32 (b - l_key[2]);
	out_blk[3] = cpu_to_le32 (a - l_key[3]);

	return 0;
}

#define CIPHER_ID                mars
#define CIPHER_BLOCKSIZE         128
#define CIPHER_KEY_SIZE_MASK     CIPHER_KEYSIZE_128 | CIPHER_KEYSIZE_192 | CIPHER_KEYSIZE_256
#define CIPHER_KEY_SCHEDULE_SIZE (40*sizeof(u32))

#include "gen-cipher.h"

EXPORT_NO_SYMBOLS;

/* eof */