cipher-gost.c

海思KEY驱动

	/* This is faster */
	x = k87[x>>24 & 255] << 24 | k65[x>>16 & 255] << 16 |
	    k43[x>> 8 & 255] <<  8 | k21[x & 255];
#endif /* !FAST_SUBSTITUTION */

	/* Rotate left 11 bits */
	return generic_rotl32 (x, 11);
}

/*
 * The GOST standard defines the input in terms of bits 1..64, with
 * bit 1 being the lsb of in[0] and bit 64 being the msb of in[1].
 *
 * The keys are defined similarly, with bit 256 being the msb of key[7].
 */
static void
GostEncrypt(const u32 in[2], u32 out[2], const u32 key[8])
{
	register u32 n1, n2; /* As named in the GOST */

	n1 = in[0];
	n2 = in[1];

	/* Instead of swapping halves, swap names each round */
	n2 ^= f(n1+key[0]);
	n1 ^= f(n2+key[1]);
	n2 ^= f(n1+key[2]);
	n1 ^= f(n2+key[3]);
	n2 ^= f(n1+key[4]);
	n1 ^= f(n2+key[5]);
	n2 ^= f(n1+key[6]);
	n1 ^= f(n2+key[7]);

	n2 ^= f(n1+key[0]);
	n1 ^= f(n2+key[1]);
	n2 ^= f(n1+key[2]);
	n1 ^= f(n2+key[3]);
	n2 ^= f(n1+key[4]);
	n1 ^= f(n2+key[5]);
	n2 ^= f(n1+key[6]);
	n1 ^= f(n2+key[7]);

	n2 ^= f(n1+key[0]);
	n1 ^= f(n2+key[1]);
	n2 ^= f(n1+key[2]);
	n1 ^= f(n2+key[3]);
	n2 ^= f(n1+key[4]);
	n1 ^= f(n2+key[5]);
	n2 ^= f(n1+key[6]);
	n1 ^= f(n2+key[7]);

	n2 ^= f(n1+key[7]);
	n1 ^= f(n2+key[6]);
	n2 ^= f(n1+key[5]);
	n1 ^= f(n2+key[4]);
	n2 ^= f(n1+key[3]);
	n1 ^= f(n2+key[2]);
	n2 ^= f(n1+key[1]);
	n1 ^= f(n2+key[0]);

	/* There is no swap after the last round */
	out[0] = n2;
	out[1] = n1;
}
	

/*
 * The key schedule is somewhat different for decryption.
 * (The key table is used once forward and three times backward.)
 * You could define an expanded key, or just write the code twice,
 * as done here.
 */
static void
GostDecrypt(const u32 in[2], u32 out[2], const u32 key[8])
{
	register u32 n1, n2; /* As named in the GOST */

	n1 = in[0];
	n2 = in[1];

	n2 ^= f(n1+key[0]);
	n1 ^= f(n2+key[1]);
	n2 ^= f(n1+key[2]);
	n1 ^= f(n2+key[3]);
	n2 ^= f(n1+key[4]);
	n1 ^= f(n2+key[5]);
	n2 ^= f(n1+key[6]);
	n1 ^= f(n2+key[7]);

	n2 ^= f(n1+key[7]);
	n1 ^= f(n2+key[6]);
	n2 ^= f(n1+key[5]);
	n1 ^= f(n2+key[4]);
	n2 ^= f(n1+key[3]);
	n1 ^= f(n2+key[2]);
	n2 ^= f(n1+key[1]);
	n1 ^= f(n2+key[0]);

	n2 ^= f(n1+key[7]);
	n1 ^= f(n2+key[6]);
	n2 ^= f(n1+key[5]);
	n1 ^= f(n2+key[4]);
	n2 ^= f(n1+key[3]);
	n1 ^= f(n2+key[2]);
	n2 ^= f(n1+key[1]);
	n1 ^= f(n2+key[0]);

	n2 ^= f(n1+key[7]);
	n1 ^= f(n2+key[6]);
	n2 ^= f(n1+key[5]);
	n1 ^= f(n2+key[4]);
	n2 ^= f(n1+key[3]);
	n1 ^= f(n2+key[2]);
	n2 ^= f(n1+key[1]);
	n1 ^= f(n2+key[0]);

	out[0] = n2;
	out[1] = n1;
}

static int gost_set_key(struct cipher_context *cx,
			const u8 *key, int key_len, int atomic)
{
	gost_key_t *const ctx = (gost_key_t *) cx->keyinfo;

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

	cx->key_length = key_len;

	memcpy (ctx->key, key, key_len);

	le32_to_cpus (&ctx->key[0]);
	le32_to_cpus (&ctx->key[1]);
	le32_to_cpus (&ctx->key[2]);
	le32_to_cpus (&ctx->key[3]);
	le32_to_cpus (&ctx->key[4]);
	le32_to_cpus (&ctx->key[5]);
	le32_to_cpus (&ctx->key[6]);
	le32_to_cpus (&ctx->key[7]);

	return 0;
}

static int gost_encrypt(struct cipher_context *cx,
			const u8 *in, u8 *out, int size, int atomic)
{
	const gost_key_t *const ctx = (gost_key_t *) cx->keyinfo;

	u32 input_buffer[2];
	u32 output_buffer[2];

	int sz;

	if (size % 8)
		return -EINVAL;

	for (sz = size; sz >= 8; sz -= 8) {
		memcpy(input_buffer, in, sizeof input_buffer); 
		in += sizeof input_buffer;

		cpu_to_le32s (&input_buffer[0]);
		cpu_to_le32s (&input_buffer[1]);
		GostEncrypt(input_buffer, output_buffer, ctx->key);
		cpu_to_le32s (&output_buffer[0]);
		cpu_to_le32s (&output_buffer[1]);

		memcpy(out, output_buffer, sizeof output_buffer); 
		out += sizeof output_buffer;
	}
	return 0;
}

static int gost_decrypt(struct cipher_context *cx,
			const u8 *in, u8 *out, int size, int atomic)
{
	const gost_key_t *const ctx = (gost_key_t *) cx->keyinfo;

	u32 input_buffer[2];
	u32 output_buffer[2];

	int sz;

	if (size % 8)
		return -EINVAL;

	for (sz = size; sz >= 8; sz -= 8) {
		memcpy(input_buffer, in, sizeof input_buffer); 
		in += sizeof input_buffer;

		cpu_to_le32s (&input_buffer[0]);
		cpu_to_le32s (&input_buffer[1]);
		GostDecrypt(input_buffer, output_buffer, ctx->key);
		cpu_to_le32s (&output_buffer[0]);
		cpu_to_le32s (&output_buffer[1]);

		memcpy(out, output_buffer, sizeof output_buffer); 
		out += sizeof output_buffer;
	}
	return 0;
}

#define CIPHER_ID                gost
#define CIPHER_BLOCKSIZE         64
#define CIPHER_KEY_SIZE_MASK     CIPHER_KEYSIZE_256
#define CIPHER_KEY_SCHEDULE_SIZE sizeof (gost_key_t)

#include "gen-cipher.h"

EXPORT_NO_SYMBOLS;