cipher-blowfish_old.c

海思KEY驱动

	0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
	0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
	0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
	0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
	0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
	0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
	0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
	0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
	0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
	0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6,
};

typedef struct blow_key {
	u32 P[18];
	u32 S[1024];
} blow_key;

/* 
 * Round loop unrolling macros, S is a pointer to a S-Box array
 * organized in 4 unsigned longs at a row.
 */

#define GET32_3(x) (((x) & 0xff))
#define GET32_2(x) (((x) >> (8)) & (0xff))
#define GET32_1(x) (((x) >> (16)) & (0xff))
#define GET32_0(x) (((x) >> (24)) & (0xff))

#define bf_F(x) (((S[GET32_0(x)] + S[256 + GET32_1(x)]) ^ \
          S[512 + GET32_2(x)]) + S[768 + GET32_3(x)])

#define ROUND(a, b, n) b^=P[n];a ^= bf_F(b)

/*
 * The blowfish encipher, processes 64-bit blocks.
 * NOTE: This function MUSTN'T respect endianess 
 */

int
blowfish_old_encrypt (struct cipher_context *cx,
		  const u8 * in8, u8 * out8, int size, int atomic)
{
	blow_key *key = (blow_key *) cx->keyinfo;
	u32 *in_blk = (u32 *) in8;
	u32 *out_blk = (u32 *) out8;

	u32 *P = key->P;
	u32 *S = key->S;

	for (; size >= 8; size -= 8) {
		u32 yl = *in_blk++;
		u32 yr = *in_blk++;

		le32_to_cpus (&yl);
		le32_to_cpus (&yr);

		ROUND (yr, yl, 0);
		ROUND (yl, yr, 1);
		ROUND (yr, yl, 2);
		ROUND (yl, yr, 3);
		ROUND (yr, yl, 4);
		ROUND (yl, yr, 5);
		ROUND (yr, yl, 6);
		ROUND (yl, yr, 7);
		ROUND (yr, yl, 8);
		ROUND (yl, yr, 9);
		ROUND (yr, yl, 10);
		ROUND (yl, yr, 11);
		ROUND (yr, yl, 12);
		ROUND (yl, yr, 13);
		ROUND (yr, yl, 14);
		ROUND (yl, yr, 15);

		/* yl and yr are switched */
		yl ^= P[16];
		yr ^= P[17];

		*(out_blk++) = cpu_to_le32 (yr);
		*(out_blk++) = cpu_to_le32 (yl);
	}
	return 0;
}

int
blowfish_old_decrypt (struct cipher_context *cx,
		  const u8 * in8, u8 * out8, int size, int atomic)
{
	blow_key *key = (blow_key *) cx->keyinfo;
	u32 *in_blk = (u32 *) in8;
	u32 *out_blk = (u32 *) out8;

	u32 *P = key->P;
	u32 *S = key->S;

	for (; size >= 8; size -= 8) {
		u32 yl = *(in_blk++);
		u32 yr = *(in_blk++);

		le32_to_cpus (&yl);
		le32_to_cpus (&yr);

		ROUND (yr, yl, 17);
		ROUND (yl, yr, 16);
		ROUND (yr, yl, 15);
		ROUND (yl, yr, 14);
		ROUND (yr, yl, 13);
		ROUND (yl, yr, 12);
		ROUND (yr, yl, 11);
		ROUND (yl, yr, 10);
		ROUND (yr, yl, 9);
		ROUND (yl, yr, 8);
		ROUND (yr, yl, 7);
		ROUND (yl, yr, 6);
		ROUND (yr, yl, 5);
		ROUND (yl, yr, 4);
		ROUND (yr, yl, 3);
		ROUND (yl, yr, 2);

		/* yl and yr are switched */
		yl ^= P[1];
		yr ^= P[0];

		*(out_blk++) = cpu_to_le32 (yr);
		*(out_blk++) = cpu_to_le32 (yl);
	}
	return 0;
}

/* Sets the blowfish S and P boxes for encryption and decryption. */

int
blowfish_old_set_key (struct cipher_context *cx,
		  const unsigned char *key, int key_len, int atomic)
{
	blow_key *key2 = (blow_key *) cx->keyinfo;
	short i;
	short j;
	short count;
	u32 data[2];
	u32 temp;
	u32 *P = key2->P;
	u32 *S = key2->S;

	/* Check key length. */

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

	/* Copy the initialization s-boxes */

	for (i = 0, count = 0; i < 256; i++)
		for (j = 0; j < 4; j++, count++)
			S[count] = bf_sbox[count];

	/* Set the p-boxes */

	for (i = 0; i < 16 + 2; i++)
		P[i] = bf_pbox[i];

	/* Actual subkey generation */

	for (j = 0, i = 0; i < 16 + 2; i++) {
		temp = (((u32) key[j] << 24) |
			((u32) key[(j + 1) % key_len] << 16) |
			((u32) key[(j + 2) % key_len] << 8) |
			((u32) key[(j + 3) % key_len]));

		P[i] = P[i] ^ temp;
		j = (j + 4) % key_len;
	}

	data[0] = 0x00000000;
	data[1] = 0x00000000;

	for (i = 0; i < 16 + 2; i += 2) {
		blowfish_old_encrypt (cx, (u8 *) data, (u8 *) data, 8, atomic);

		P[i] = le32_to_cpu (data[0]);
		P[i + 1] = le32_to_cpu (data[1]);
	}

	for (i = 0; i < 4; i++) {
		for (j = 0, count = i * 256; j < 256; j += 2, count += 2) {
			blowfish_old_encrypt (cx, (u8 *) data, (u8 *) data, 8,
					  atomic);

			S[count] = le32_to_cpu (data[0]);
			S[count + 1] = le32_to_cpu (data[1]);
		}
	}
	return 0;
}

static void
blowfish_old_lock (void)
{
	MOD_INC_USE_COUNT;
}

static void
blowfish_old_unlock (void)
{
	MOD_DEC_USE_COUNT;
}

#define CIPHER_BITS_64
#define CIPHER_NAME(x) blowfish_old##x
#include "gen-cbc.h"
#include "gen-ecb.h"

#define BLOWFISH_OLD_KEY_SCHEDULE_SIZE ((18+1024)*sizeof(u32))

static struct cipher_implementation blowfish_old_ecb = {
	{{NULL, NULL}, CIPHER_MODE_ECB, "blowfish_old-ecb"},
      blocksize:8,
      ivsize:0,
      key_schedule_size:sizeof (blow_key),
      key_size_mask:CIPHER_KEYSIZE_128 | CIPHER_KEYSIZE_160 |
	    CIPHER_KEYSIZE_192 | CIPHER_KEYSIZE_256,
	INIT_CIPHER_BLKOPS (blowfish_old_ecb),
	INIT_CIPHER_OPS (blowfish_old)
};

static struct cipher_implementation blowfish_old_cbc = {
	{{NULL, NULL}, CIPHER_MODE_CBC, "blowfish_old-cbc"},
      blocksize:8,
      ivsize:8,
      key_schedule_size:sizeof (blow_key),
      key_size_mask:CIPHER_KEYSIZE_128 | CIPHER_KEYSIZE_160 |
	    CIPHER_KEYSIZE_192 | CIPHER_KEYSIZE_256,
	INIT_CIPHER_BLKOPS (blowfish_old_cbc),
	INIT_CIPHER_OPS (blowfish_old)
};

static int __init
init_blowfish_old (void)
{
	if (register_cipher (&blowfish_old_ecb))
		printk (KERN_WARNING
			"Couldn't register blowfish_old-ecb encryption\n");
	if (register_cipher (&blowfish_old_cbc))
		printk (KERN_WARNING
			"Couldn't register blowfish_old-cbc encryption\n");

	return 0;
}

static void __exit
cleanup_blowfish_old (void)
{
	if (unregister_cipher (&blowfish_old_ecb))
		printk (KERN_WARNING
			"Couldn't unregister blowfish_old-ecb encryption\n");
	if (unregister_cipher (&blowfish_old_cbc))
		printk (KERN_WARNING
			"Couldn't unregister blowfish_old-cbc encryption\n");
}

module_init (init_blowfish_old);
module_exit (cleanup_blowfish_old);

EXPORT_NO_SYMBOLS;

/* eof */