cipher-blowfish_old.c

来自「海思KEY驱动」· C语言 代码 · 共 529 行 · 第 1/2 页

	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 */