ssx31b_cipher_digest.c

海思KEY驱动

/*
ssx31b ciphers and digests module
2006-7-6
*/

#include <linux/string.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <asm/byteorder.h>
#include <linux/crypto.h>

#include "./ssx31bdrv_glue.h"
#if 0
#ifdef SPINLOCK
	# ifdef SPINLOCK_23
		#  include <linux/spinlock.h> /* *lock* */
	# else /* SPINLOCK_23 */
		#  include <asm/spinlock.h> /* *lock* */
	# endif /* SPINLOCK_23 */
#endif /* SPINLOCK */
#endif

#ifdef MODULE_LICENSE
MODULE_LICENSE ("GPL");
#endif
#ifdef MODULE_DESCRIPTION
MODULE_DESCRIPTION ("SSX31B Crypto / CryptoAPI");
#endif
#ifdef MODULE_AUTHOR
MODULE_AUTHOR ("Gisle Sensminde <[e-mail]>");
#endif

/*========== ssx31bdrv sa   <--->  cryptoapi context ======================*/
#define SSX31B_CTX_MAPPING_LEN	1024
void* ssx31b_ctx_mapping[SSX31B_CTX_MAPPING_LEN];

static void ssx31b_ctx_mapping_init();
static struct cipher_context *
ssx31b_ctx_mapping_getctx(unsigned short saNum);

static int ssx31b_ctx_mapping_getsanum(struct cipher_context* pctx);

static int ssx31b_ctx_mapping_set(struct cipher_context* pctx);

static int ssx31b_ctx_mapping_clear(struct cipher_context* pctx);


/*==========================================================*/
/* ciphers */
static struct cipher_context *
ssx31b_default_realloc_cipher_context(struct cipher_context *old_cx,
                           struct cipher_implementation *ci,
                           int max_key_len);

static void ssx31b_default_wipe_context(struct cipher_context *cx);

static void ssx31b_default_free_cipher_context(struct cipher_context *cx);


/* digests */
static struct digest_context *
ssx31b_default_realloc_digest_context(struct digest_context *old_cx,
			       struct digest_implementation *ci);
static void ssx31b_default_free_digest_context(struct digest_context *cx);

#ifndef NOT_ONLY_HMAC
static int ssx31b_default_open (struct digest_context *cx, int atomic);

static int ssx31b_default_update(struct digest_context *cx, const u8 *in, int size, int atomic);

static int ssx31b_default_digest(struct digest_context *cx, u8 *out, int atomic);

static int ssx31b_default_close(struct digest_context *cx, u8 *out, int atomic);
#endif

static void ssx31b_ctx_mapping_init()
{
	int i;
	for(i=0;i<SSX31B_CTX_MAPPING_LEN;i++)
		ssx31b_ctx_mapping[i]=NULL;
}

static struct cipher_context *
ssx31b_ctx_mapping_getctx(unsigned short saNum)
{
	return ssx31b_ctx_mapping[saNum];
}

static int
ssx31b_ctx_mapping_getsanum(struct cipher_context* pctx)
{
	int i;
	if(pctx==NULL) return -1;
	for(i=0;i<SSX31B_CTX_MAPPING_LEN;i++){
		if(ssx31b_ctx_mapping[i]==(void *)pctx)
			return i;
	}
	return -1;
}

static int ssx31b_ctx_mapping_set(struct cipher_context* pctx)
{
	int i;
	i=ssx31b_GetSANum();
	if(i<0) return i;
	ssx31b_ctx_mapping[i]=(void*)pctx;
	return 0;
}

static int ssx31b_ctx_mapping_clear(struct cipher_context* pctx)
{
	int i;
	if(pctx==NULL) return -1;
	i=ssx31b_ctx_mapping_getsanum(pctx);
	if(i<0) return i;
	ssx31b_ctx_mapping[i]=NULL;	
	ssx31b_ReleaseSANum(i);
	return 0;

}


/*----des-------------------*/
static int des_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 */
    switch(keybytes) {
	    case 8:
		    memcpy(lkey,key,8);
		    break;
	    default:
		    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=0;	/*000 0000 00: ?? des ECB*/
   status=ssx31b_sa_register( usOpt, lkey, NULL, saNum);
   if(status<0) return -1;
   return 0;
}



static int des_cbc_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 */
    switch(keybytes) {
	    case 8:
		    memcpy(lkey,key,8);
		    break;
	    default:
		    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=1;	/*000 0000 01: ?? des CBC*/
   status=ssx31b_sa_register( usOpt, (unsigned long *)lkey, NULL, saNum);
   if(status<0) return -1;
   return 0;
}


static int des_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 des_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 des_cbc_encrypt(struct cipher_context *cx,
                         const u8 *in, u8 *out, int size, int atomic, 
			 const u8 *iv)
{
	return des_ecb_encrypt(cx,  in, out,  size,  atomic,  iv);
	
}

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


#define SSX31B_CIPHER_DES_ID                des
#define SSX31B_CIPHER_DES_STR               "des"
#define SSX31B_CIPHER_DES_BLOCKSIZE         64
#define SSX31B_CIPHER_DES_KEY_SIZE_MASK   CIPHER_KEYSIZE_64
#define SSX31B_CIPHER_DES_KEY_SCHEDULE_SIZE (32*sizeof(u32))

/*----3des-------------------*/
static int des_ede3_ecb_set_key(struct cipher_context *cx, 
	  		const unsigned char *key, int keybytes, int atomic)
{
    int status;
/*    u32 *method;
   unsigned char lkey[24];
   method=(u32 *)cx->keyinfo;
*/
   //unsigned char n1, n2;
  // int i;
unsigned short usOpt;
unsigned char* lkey=(unsigned char*)(cx->keyinfo);	
int saNum;

    /* asign keybits based on keylength */
    switch(keybytes) {
	    case 24:
		    memcpy(lkey,key,24);
		    break;
	    case 16:
		    memcpy(lkey,key,16);
		    memcpy(lkey+16,key,8);
		    break;
	    case 8:
		    memcpy(lkey,key,8);
		    memcpy(lkey+8,key,8);
		    memcpy(lkey+16,key,8);
		    break;
	    default:
		    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=4;	/*000 0001 00: ?? 3des ECB*/
   status=ssx31b_sa_register( usOpt, lkey, NULL, saNum);
   if(status<0) return -1;
   return 0;
}


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

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

    /* asign keybits based on keylength */
    switch(keybytes) {
	    case 24:
		    memcpy(lkey,key,24);
		    break;
	    case 16:
		    memcpy(lkey,key,16);
		    memcpy(lkey+16,key,8);
		    break;
	    case 8:
		    memcpy(lkey,key,8);
		    memcpy(lkey+8,key,8);
		    memcpy(lkey+16,key,8);
		    break;
	    default:
		    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=5;	/*000 0001 01: ?? 3des CBC*/
   status=ssx31b_sa_register( usOpt, (unsigned long *)lkey, NULL, saNum);
   if(status<0) return -1;
   return 0;
}


static int des_ede3_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 des_ede3_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 des_ede3_cbc_encrypt(struct cipher_context *cx,
                         const u8 *in, u8 *out, int size, int atomic, 
			 const u8 *iv)
{
	return des_ede3_ecb_encrypt(cx,  in, out,  size,  atomic,  iv);
	
}

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


#define SSX31B_CIPHER_3DES_ID                des_ede3
#define SSX31B_CIPHER_3DES_STR               "3des"
#define SSX31B_CIPHER_3DES_BLOCKSIZE         64
#define SSX31B_CIPHER_3DES_KEY_SIZE_MASK     CIPHER_KEYSIZE_64 | CIPHER_KEYSIZE_128 | CIPHER_KEYSIZE_192
#define SSX31B_CIPHER_3DES_KEY_SCHEDULE_SIZE (3*32*sizeof(u32))

/*----aes-------------------*/
static int aes_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)||(keybytes == 24)||(keybytes == 32)) {
		memcpy(lkey,key,keybytes);
	} else
		return -EINVAL;

	cx->key_length = keybytes;

   saNum=ssx31b_ctx_mapping_getsanum(cx);
   if(saNum<0) return -1;
/*
		       1~0 bit:	Crypto Mode 
		       		00:ECB
		       		01: CBC
		       		other: reserved
		       5~2 bit:	Ctypto Algrithm
		       		0000:des
		       		0001:3des
		       		0010:aes128
		       		0011:aes192
		       		0100:aes256
		       		0101:scb2
		       		other:reserved
		       8~6 bit:	Hmac Algrithm
		       		000:md5
		       		001:sha1
		       		other:reserved
*/
    switch (keybytes){
		case 16:
			usOpt = 8; 	/*000 0010 00: aes128 ECB*/
			break;
		case 24:
			usOpt = 12; 	/*000 0011 00: aes192 ECB*/
			break;
		case 32:
			usOpt = 16; 	/*000 0100 00: aes256 ECB*/
			break;
		default:
			return -EINVAL;
    }

  // usOpt=8;	/*000 0010 00: ?? aes128 ECB*/
   status=ssx31b_sa_register( usOpt, lkey, NULL, saNum);
   if(status<0) return -1;
   return 0;
}

static int aes_cbc_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)||(keybytes == 24)||(keybytes == 32)) {
		memcpy(lkey,key,keybytes);
	} else
		return -EINVAL;

	cx->key_length = keybytes;

   saNum=ssx31b_ctx_mapping_getsanum(cx);
   if(saNum<0) return -1;

    switch (keybytes){
		case 16:
			usOpt = 9; 	/*000 0010 01: aes128 CBC*/
			break;
		case 24:
			usOpt = 13; 	/*000 0011 01: aes192 CBC*/
			break;
		case 32:
			usOpt = 17; 	/*000 0100 01: aes256 CBC*/
			break;
		default:
			return -EINVAL;
    }

  // usOpt=9;	/*000 0010 01: ?? aes128 CBC*/
   status=ssx31b_sa_register( usOpt, lkey, NULL, saNum);
   if(status<0) return -1;
   return 0;
}


static int aes_ecb_encrypt(struct cipher_context *cx,
                         const u8 *in, u8 *out, int size, int atomic,