ssx31b_cipher_digest.c

海思KEY驱动

			 const u8 *iv)
{
	int err;
	unsigned char ucOpt=0x0;	/*0x000:crypto operation only and en-do*/
	int saNum;
	unsigned long OutDatLen;
	saNum=ssx31b_ctx_mapping_getsanum(cx);
	if(saNum<0) return -1;
	err=ssx31b_crypto_perform(ucOpt, iv, cx->ci->blocksize, saNum, in, size, out, &OutDatLen);
	if(err!=0) return -1;
	return 0;
}

static int aes_ecb_decrypt(struct cipher_context *cx,
                        const u8 *in, u8 *out, int size, int atomic, 
			const u8 *iv)
{
	int err;
	unsigned char ucOpt=0x01;	/*0x001:crypto operation only and de-do*/
	int saNum;
	unsigned long OutDatLen;
	saNum=ssx31b_ctx_mapping_getsanum(cx);
	if(saNum<0) return -1;
	err=ssx31b_crypto_perform(ucOpt, iv, cx->ci->blocksize, saNum, in, size, out, &OutDatLen);
	if(err!=0) return -1;
	return 0;
}

/*===CBC====*/
static int aes_cbc_encrypt(struct cipher_context *cx,
                         const u8 *in, u8 *out, int size, int atomic, 
			 const u8 *iv)
{
	//printk("aes_cbc_encrypt: size=%d !\n",size);

	return aes_ecb_encrypt(cx,  in, out,  size,  atomic,  iv);
	
}

static int aes_cbc_decrypt(struct cipher_context *cx,
                        const u8 *in, u8 *out, int size, int atomic, 
			const u8 *iv)
{
	//printk("aes_cbc_decrypt: size=%d !\n",size);
	
	return aes_ecb_decrypt( cx,  in,  out,  size,  atomic,  iv);
}


#define SSX31B_CIPHER_AES_ID                aes
#define SSX31B_CIPHER_AES_STR               "aes"
#define SSX31B_CIPHER_AES_BLOCKSIZE         128
#define SSX31B_CIPHER_AES_KEY_SIZE_MASK   CIPHER_KEYSIZE_128 | CIPHER_KEYSIZE_192 | CIPHER_KEYSIZE_256
#define SSX31B_CIPHER_AES_KEY_SCHEDULE_SIZE (3*32*sizeof(u32))

/*----scb2-------------------*/
static int scb2_ecb_set_key(struct cipher_context *cx, 
	  		const unsigned char *key, int keybytes, int atomic)
{
    //u32 *method;
    int status;
   // unsigned char lkey[24];
    //unsigned char n1, n2;
    //method=(u32 *)cx->keyinfo;

unsigned short usOpt;
unsigned char* lkey=(unsigned char*)(cx->keyinfo);	
int saNum;

    /* asign keybits based on keylength */
	if (keybytes == 16) {
		memcpy(lkey,key,keybytes);
	} else
		return -EINVAL;

    cx->key_length = keybytes;
#if 0
    /* set the correct parity bit for each byte in the key*/
    for(i=0; i<24; i++){
	    n1 = lkey[i] & 0xfe;
	    n2 = n1 ^ (n1 >> 4);
	    n2 ^= (n2 >> 2);
	    n2 ^= (n2 >> 1);
	    lkey[i] = n1 | (~n2 & 0x01);	    
    }
    
    /* check for degenerate keys */
    if(keybytes > 8 &&
       (memcmp(lkey,lkey+8,8)==0 || memcmp(lkey+8,lkey+16,8)==0))
	    return -2;

    if((status = des_part_set_key(method, lkey)) != 0) 
	    return status;
    if((status = des_part_set_key(method+32, lkey+8)) != 0) 
	    return status;
    if((status = des_part_set_key(method+64, lkey+16)) != 0) 
	    return status;
#endif
   saNum=ssx31b_ctx_mapping_getsanum(cx);
   if(saNum<0) return -1;
   usOpt=20;	/*000 0101 00: ?? scb2 ECB*/
   status=ssx31b_sa_register( usOpt, lkey, NULL, saNum);
   if(status<0) return -1;
   return 0;
}



static int scb2_cbc_set_key(struct cipher_context *cx, 
	  		const unsigned char *key, int keybytes, int atomic)
{
    int status;

unsigned short usOpt;
unsigned char* lkey=(unsigned char*)(cx->keyinfo);	
int saNum;

    /* asign keybits based on keylength */
	if (keybytes == 16) {
		memcpy(lkey,key,keybytes);
	} else
		return -EINVAL;

    cx->key_length = keybytes;
   saNum=ssx31b_ctx_mapping_getsanum(cx);
   if(saNum<0) return -1;
   usOpt=21;	/*000 0101 01: ?? scb2 CBC*/
   status=ssx31b_sa_register( usOpt, (unsigned long *)lkey, NULL, saNum);
   if(status<0) return -1;
   return 0;
}


static int scb2_ecb_encrypt(struct cipher_context *cx,
                         const u8 *in, u8 *out, int size, int atomic, 
			 const u8 *iv)
{
	int err;
	unsigned char ucOpt=0x0;	/*0x000:crypto operation only and en-do*/
	int saNum;
	unsigned long OutDatLen;
	saNum=ssx31b_ctx_mapping_getsanum(cx);
	if(saNum<0) return -1;
	err=ssx31b_crypto_perform(ucOpt, iv, cx->ci->blocksize, saNum, in, size, out, &OutDatLen);
	if(err!=0) return -1;
	return 0;
}

static int scb2_ecb_decrypt(struct cipher_context *cx,
                        const u8 *in, u8 *out, int size, int atomic, 
			const u8 *iv)
{
	int err;
	unsigned char ucOpt=0x01;	/*0x001:crypto operation only and de-do*/
	int saNum;
	unsigned long OutDatLen;
	saNum=ssx31b_ctx_mapping_getsanum(cx);
	if(saNum<0) return -1;
	err=ssx31b_crypto_perform(ucOpt, iv, cx->ci->blocksize, saNum, in, size, out, &OutDatLen);
	if(err!=0) return -1;
	return 0;
}

/*===CBC====*/
static int scb2_cbc_encrypt(struct cipher_context *cx,
                         const u8 *in, u8 *out, int size, int atomic, 
			 const u8 *iv)
{
	return scb2_ecb_encrypt(cx,  in, out,  size,  atomic,  iv);
	
}

static int scb2_cbc_decrypt(struct cipher_context *cx,
                        const u8 *in, u8 *out, int size, int atomic, 
			const u8 *iv)
{	
	return scb2_ecb_decrypt( cx,  in,  out,  size,  atomic,  iv);
}


#define SSX31B_CIPHER_SCB2_ID                scb2
#define SSX31B_CIPHER_SCB2_STR               "scb2"
#define SSX31B_CIPHER_SCB2_BLOCKSIZE         128
#define SSX31B_CIPHER_SCB2_KEY_SIZE_MASK   CIPHER_KEYSIZE_128
#define SSX31B_CIPHER_SCB2_KEY_SCHEDULE_SIZE (3*32*sizeof(u32))


static struct cipher_context *
ssx31b_default_realloc_cipher_context(struct cipher_context *old_cx,
                           struct cipher_implementation *ci,
                           int max_key_len)
{
	struct cipher_context *cx;
	int i;
	/* Default ciphers need the same amount of memory for any key
           size */
//printk("ssx31b_crypto: realloc_cipher_context!\n");

	if (old_cx) {
		return old_cx;
	}
	cx = kmalloc(sizeof(struct cipher_context) +
		     ci->key_schedule_size, GFP_KERNEL);
	if (!cx) {
		return NULL;
	}
	memset(cx,0,sizeof(struct cipher_context) +
						ci->key_schedule_size);
	for (i=0;i<ci->ivsize;i++)
		cx->iv[i]=(i+1)&0xff;			/*default IV*/
	
	cx->ci = ci;
	cx->keyinfo = (void *)((char *)cx)+sizeof(struct cipher_context);
	(void) max_key_len; /* Make gcc happy */

	if(ssx31b_ctx_mapping_set(cx)<0){
		kfree(cx);
		return NULL;
	}
	return cx;
}

static void ssx31b_default_wipe_context(struct cipher_context *cx)
{
	struct cipher_implementation *ci = cx->ci;
	u32 *keyinfo = cx->keyinfo;
	memset(cx->keyinfo, 0, ci->key_schedule_size);
	memset(cx, 0, sizeof(struct cipher_context));
	cx->ci = ci;
	cx->keyinfo = keyinfo;
	
}

static void ssx31b_default_free_cipher_context(struct cipher_context *cx)
{
	if(cx==NULL) return;
	ssx31b_ctx_mapping_clear(cx);
	kfree(cx);
	return;
}



/*======================================================*/
/*				digest													*/
/*======================================================*/

/*MD5*/

typedef struct {
	u64 byte_count;
	u32 hash[4];		/* hash buf */
	u32 in[16];		/* 64-byte inbuffer */
} md5_ctx_t;

typedef struct {
	u64 count;
	u32 state[5];
	u8 buffer[64];
} sha1_ctx_t;


#ifdef NOT_ONLY_HMAC

/* The four core functions - F1 is optimized somewhat */

/* #define F1(x, y, z) (x & y | ~x & z) */
#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define F2(x, y, z) F1(z, x, y)
#define F3(x, y, z) (x ^ y ^ z)
#define F4(x, y, z) (y ^ (x | ~z))

/* This is the central step in the MD5 algorithm. */
#define MD5STEP(f,w,x,y,z,in,s) \
	 (w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)

/*
 * The core of the MD5 algorithm, this alters an existing MD5 hash to
 * reflect the addition of 16 longwords of new data.  MD5Update blocks
 * the data and converts bytes into longwords for this routine.
 */
static inline void
md5_transform (u32 hash[4], u32 const in[16])
{
	register u32 a, b, c, d;

	a = hash[0];
	b = hash[1];
	c = hash[2];
	d = hash[3];

	MD5STEP (F1, a, b, c, d, in[0] + 0xd76aa478, 7);
	MD5STEP (F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
	MD5STEP (F1, c, d, a, b, in[2] + 0x242070db, 17);
	MD5STEP (F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
	MD5STEP (F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
	MD5STEP (F1, d, a, b, c, in[5] + 0x4787c62a, 12);
	MD5STEP (F1, c, d, a, b, in[6] + 0xa8304613, 17);
	MD5STEP (F1, b, c, d, a, in[7] + 0xfd469501, 22);
	MD5STEP (F1, a, b, c, d, in[8] + 0x698098d8, 7);
	MD5STEP (F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
	MD5STEP (F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
	MD5STEP (F1, b, c, d, a, in[11] + 0x895cd7be, 22);
	MD5STEP (F1, a, b, c, d, in[12] + 0x6b901122, 7);
	MD5STEP (F1, d, a, b, c, in[13] + 0xfd987193, 12);
	MD5STEP (F1, c, d, a, b, in[14] + 0xa679438e, 17);
	MD5STEP (F1, b, c, d, a, in[15] + 0x49b40821, 22);

	MD5STEP (F2, a, b, c, d, in[1] + 0xf61e2562, 5);
	MD5STEP (F2, d, a, b, c, in[6] + 0xc040b340, 9);
	MD5STEP (F2, c, d, a, b, in[11] + 0x265e5a51, 14);
	MD5STEP (F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
	MD5STEP (F2, a, b, c, d, in[5] + 0xd62f105d, 5);
	MD5STEP (F2, d, a, b, c, in[10] + 0x02441453, 9);
	MD5STEP (F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
	MD5STEP (F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
	MD5STEP (F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
	MD5STEP (F2, d, a, b, c, in[14] + 0xc33707d6, 9);
	MD5STEP (F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
	MD5STEP (F2, b, c, d, a, in[8] + 0x455a14ed, 20);
	MD5STEP (F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
	MD5STEP (F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
	MD5STEP (F2, c, d, a, b, in[7] + 0x676f02d9, 14);
	MD5STEP (F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);

	MD5STEP (F3, a, b, c, d, in[5] + 0xfffa3942, 4);
	MD5STEP (F3, d, a, b, c, in[8] + 0x8771f681, 11);
	MD5STEP (F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
	MD5STEP (F3, b, c, d, a, in[14] + 0xfde5380c, 23);
	MD5STEP (F3, a, b, c, d, in[1] + 0xa4beea44, 4);
	MD5STEP (F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
	MD5STEP (F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
	MD5STEP (F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
	MD5STEP (F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
	MD5STEP (F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
	MD5STEP (F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
	MD5STEP (F3, b, c, d, a, in[6] + 0x04881d05, 23);
	MD5STEP (F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
	MD5STEP (F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
	MD5STEP (F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
	MD5STEP (F3, b, c, d, a, in[2] + 0xc4ac5665, 23);

	MD5STEP (F4, a, b, c, d, in[0] + 0xf4292244, 6);
	MD5STEP (F4, d, a, b, c, in[7] + 0x432aff97, 10);
	MD5STEP (F4, c, d, a, b, in[14] + 0xab9423a7, 15);
	MD5STEP (F4, b, c, d, a, in[5] + 0xfc93a039, 21);
	MD5STEP (F4, a, b, c, d, in[12] + 0x655b59c3, 6);
	MD5STEP (F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
	MD5STEP (F4, c, d, a, b, in[10] + 0xffeff47d, 15);
	MD5STEP (F4, b, c, d, a, in[1] + 0x85845dd1, 21);
	MD5STEP (F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
	MD5STEP (F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
	MD5STEP (F4, c, d, a, b, in[6] + 0xa3014314, 15);
	MD5STEP (F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
	MD5STEP (F4, a, b, c, d, in[4] + 0xf7537e82, 6);
	MD5STEP (F4, d, a, b, c, in[11] + 0xbd3af235, 10);
	MD5STEP (F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
	MD5STEP (F4, b, c, d, a, in[9] + 0xeb86d391, 21);

	hash[0] += a;
	hash[1] += b;
	hash[2] += c;
	hash[3] += d;
}

static inline void
le32_to_cpu_array (u32 *buf, unsigned words)
{
	while (words--) {
		__le32_to_cpus (buf);
		buf++;
	}
}

static inline void
cpu_to_le32_array (u32 *buf, unsigned words)
{
	while (words--) {
		__cpu_to_le32s (buf);
		buf++;
	}
}

static inline void
md5_transform_helper (md5_ctx_t * ctx)
{
	le32_to_cpu_array (ctx->in, sizeof (ctx->in) / sizeof (u32));
	md5_transform (ctx->hash, ctx->in);
}

/*
 * Final wrapup - pad to 64-byte boundary with the bit pattern 
 * 1 0* (64-bit count of bits processed, MSB-first)
 */
static inline void
md5_final (md5_ctx_t * ctx, u8 out[16])
{
	/* Number of bytes in ctx->in */
	const int offset = ctx->byte_count & 0x3f;

	/* p points after last content byte in ctx->in */
	u8 *p = (u8 *) ctx->in + offset;

	/* Bytes of padding needed to make 56 bytes (-8..55) */
	int padding = 56 - (offset + 1);

	/* Set the first byte of padding to 0x80.  There is always room. */
	*p++ = 0x80;

	if (padding < 0) {	/* Padding forces an extra block */
		memset (p, 0x00, padding + sizeof (u64));

		md5_transform_helper (ctx);

		p = (u8 *) ctx->in;
		padding = 56;
	}

	/* pad remaining bytes w/ 0x00 */
	memset (p, 0x00, padding);

	/* Append length in bits and transform */
	ctx->in[14] = ctx->byte_count << 3;	/* low order word first */
	ctx->in[15] = ctx->byte_count >> 29;

	/* keep the appended bit-count words in host order! */
	le32_to_cpu_array (ctx->in,
			   (sizeof (ctx->in) - sizeof (u64)) / sizeof (u32));
	md5_transform (ctx->hash, ctx->in);

	/* convert digest buf from host to LE byteorder */
	cpu_to_le32_array (ctx->hash, sizeof (ctx->hash) / sizeof (u32));

	/* copy to output buffer */
	memcpy (out, ctx->hash, sizeof (ctx->hash));

	/* wipe context */
	memset (ctx, 0, sizeof (ctx));
}

/*****************************************************************************/
/* public entry points */

/*
 * Initialize MD5 context.  Set bit count to 0 and buffer to mysterious
 * initialization constants.
 */

static int
md5_open (struct digest_context *cx, int atomic)
{
	md5_ctx_t *ctx = (md5_ctx_t *) cx->digest_info;

	ctx->hash[0] = 0x67452301;
	ctx->hash[1] = 0xefcdab89;
	ctx->hash[2] = 0x98badcfe;
	ctx->hash[3] = 0x10325476;

	ctx->byte_count = 0;

	return 0;
}

/*
 * Update context to reflect the concatenation of another buffer full
 * of bytes.
 */

static int
md5_update (struct digest_context *cx, const u8 *in, int size, int atomic)
{
	md5_ctx_t *ctx = (md5_ctx_t *) cx->digest_info;

	/* Space available in ctx->in (at least 1) */
	const u32 avail = sizeof (ctx->in) - (ctx->byte_count & 0x3f);

	/* Update byte count */
	ctx->byte_count += size;

	/* if in fits in ctx->in just copy and return */
	if (avail > size) {
		memcpy ((u8 *) ctx->in + (sizeof (ctx->in) - avail), in, size);
		return 0;
	}

	/* First chunk is an odd size */
	memcpy ((u8 *) ctx->in + (sizeof (ctx->in) - avail), in, avail);

	md5_transform_helper (ctx);

	in += avail;
	size -= avail;

	/* Process data in sizeof(ctx->in) chunks */
	while (size >= sizeof (ctx->in)) {
		memcpy (ctx->in, in, sizeof (ctx->in));

		md5_transform_helper (ctx);

		in += sizeof (ctx->in);
		size -= sizeof (ctx->in);
	}

	/* assert (size < sizeof(ctx->in)); */

	/* Handle any remaining bytes of data. */
	memcpy (ctx->in, in, size);

	return 0;
}

static int
md5_close (struct digest_context *cx, u8 *out, int atomic)
{
	md5_ctx_t *ctx = (md5_ctx_t *) cx->digest_info;

	md5_final (ctx, out);

	return 0;
}

static int
md5_digest (struct digest_context *cx, u8 *out, int atomic)
{
	md5_ctx_t *ctx = (md5_ctx_t *) cx->digest_info;
	md5_ctx_t *ctx_copy;

	/* work on copy */
	ctx_copy = kmalloc (sizeof (md5_ctx_t), GFP_KERNEL);
	memcpy (ctx_copy, ctx, sizeof (md5_ctx_t));

	md5_final (ctx_copy, out);

	kfree (ctx_copy);

	return 0;
}

/*-------sha1------------*/
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))

/* blk0() and blk() perform the initial expand. */
/* I got the idea of expanding during the round function from SSLeay */
# define blk0(i) block32[i]

#define blk(i) (block32[i&15] = rol(block32[(i+13)&15]^block32[(i+8)&15] \
    ^block32[(i+2)&15]^block32[i&15],1))

/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5); \
                        w=rol(w,30);
#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5); \
                        w=rol(w,30);
#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5); \
                        w=rol(w,30);
#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);


/* Hash a single 512-bit block. This is the core of the algorithm. */
static void
SHA1Transform(u32 state[5], const u8 buffer[64])
{
	register u32 a, b, c, d, e;

	u32 block32[16];

	/* convert/copy data to workspace */
	for (a = 0; a < sizeof(block32)/sizeof(u32); a++)
	  block32[a] = be32_to_cpu (((const u32 *)buffer)[a]);

	/* Copy context->state[] to working vars */
	a = state[0];
	b = state[1];
	c = state[2];
	d = state[3];
	e = state[4];

	/* 4 rounds of 20 operations each. Loop unrolled. */
	R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
	R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);