cryptoapi.c

海思KEY驱动

		di->close = default_close;
		di->close_atomic = default_close_atomic;

		di->hmac = default_hmac;
		di->hmac_atomic = default_hmac_atomic;
		di->trans.t_atomicapi = 1;
	}

	if (!di->open || !di->update || !di->digest || !di->close)
		return -EINVAL;

	return register_transform((struct transform_implementation *)di,
				  TRANSFORM_DIGEST);
}

int 
unregister_cipher(struct cipher_implementation *ci)
{
	return unregister_transform((struct transform_implementation *)ci);
}

int 
unregister_digest(struct digest_implementation *ci)
{
	return unregister_transform((struct transform_implementation *)ci);
}

struct cipher_context *
default_realloc_cipher_context(struct cipher_context *old_cx,
			       struct cipher_implementation *ci,
			       int max_key_len)
{
	struct cipher_context *cx;
	/* Default ciphers need the same amount of memory for any key
           size */
	if (old_cx) {
		return old_cx;
	}
	cx = kmalloc(sizeof(struct cipher_context) +
		     ci->key_schedule_size, GFP_KERNEL);
	if (!cx) {
		return NULL;
	}
	cx->ci = ci;
	cx->keyinfo = (void *)((char *)cx)+sizeof(struct cipher_context);
	(void) max_key_len; /* Make gcc happy */
	return cx;
}

struct digest_context *
default_realloc_digest_context(struct digest_context *old_cx,
			       struct digest_implementation *di)
{
	struct digest_context *cx;

	if (old_cx)
		di->free_context (old_cx);

	cx = kmalloc(sizeof (struct digest_context) +
		      di->working_size, GFP_KERNEL);
	if (!cx)
		return NULL;

	cx->di = di;

	/* let digest_info point behind the context */
	cx->digest_info = (void *)((char *)cx) + sizeof(struct digest_context);

	return cx;
}

void
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;
}

void
default_free_cipher_context(struct cipher_context *cx)
{
	kfree(cx);
}

void
default_free_digest_context(struct digest_context *cx)
{
	kfree(cx);
}

void 
default_lock (void)
{
}

void
default_unlock (void)
{
}

static int 
default_encrypt(struct cipher_context *cx, const u8 *in, u8 *out, int size)
{
	return cx->ci->_encrypt(cx, in, out, size, 0, cx->iv);
}

static int 
default_encrypt_atomic(struct cipher_context *cx, const u8 *in, u8 *out, 
		       int size)
{
	return cx->ci->_encrypt(cx, in, out, size, 1, cx->iv);
}

static int 
default_encrypt_iv(struct cipher_context *cx, const u8 *in, u8 *out, int size,
		const u8 *iv)
{
	return cx->ci->_encrypt(cx, in, out, size, 0, iv);
}

static int 
default_encrypt_atomic_iv(struct cipher_context *cx, const u8 *in, u8 *out, 
		          int size, const u8 *iv)
{
	return cx->ci->_encrypt(cx, in, out, size, 1, iv);
}

static int 
default_decrypt(struct cipher_context *cx, const u8 *in, u8 *out, int size)
{
	return cx->ci->_decrypt(cx, in, out, size, 0, cx->iv);
}

static int 
default_decrypt_atomic(struct cipher_context *cx, const u8 *in, u8 *out, 
		       int size)
{
	return cx->ci->_decrypt(cx, in, out, size, 1, cx->iv);
}

static int 
default_decrypt_iv(struct cipher_context *cx, const u8 *in, u8 *out, int size,
		const u8 *iv)
{
	return cx->ci->_decrypt(cx, in, out, size, 0, iv);
}

static int 
default_decrypt_atomic_iv(struct cipher_context *cx, const u8 *in, u8 *out, 
		       int size, const u8 *iv)
{
	return cx->ci->_decrypt(cx, in, out, size, 1, iv);
}


static int
default_set_key(struct cipher_context *cx, const u8 *key, int key_len)
{
	return cx->ci->_set_key(cx, key, key_len, 0);
}

static int
default_set_key_atomic(struct cipher_context *cx, const u8 *key, 
		       int key_len)
{
	return cx->ci->_set_key(cx, key, key_len, 1);
}

static int
default_open (struct digest_context *cx)
{
  return cx->di->_open (cx, 0);
}

static int
default_open_atomic (struct digest_context *cx)
{
	return cx->di->_open (cx, 1);
}

static int
default_update(struct digest_context *cx, const u8 *in, int size)
{
	return cx->di->_update (cx, in, size, 0);
}

static int
default_update_atomic(struct digest_context *cx, const u8 *in, int size)
{
	return cx->di->_update (cx, in, size, 1);
}

static int
default_digest(struct digest_context *cx, u8 *out)
{
	return cx->di->_digest (cx, out, 0);
}

static int
default_digest_atomic(struct digest_context *cx, u8 *out)
{
	return cx->di->_digest (cx, out, 1);
}

static int
default_close(struct digest_context *cx, u8 *out)
{
	return cx->di->_close (cx, out, 0);
}

static int
default_close_atomic(struct digest_context *cx, u8 *out)
{
	return cx->di->_close (cx, out, 1);
}

static int
default_hmac (struct digest_context *cx, const u8 *key, int key_len,
	     const u8 *in, int size, u8 *hmac)
{
	if (!(cx && key && in && hmac)) {
		printk (KERN_ERR "%s: some parameter is null\n", __PRETTY_FUNCTION__);
		return -EINVAL;
	}

	return cx->di->_hmac (cx, key, key_len, in, size, hmac, 0);
}

static int
default_hmac_atomic (struct digest_context *cx, const u8 *key, int key_len,
		    const u8 *in, int size, u8 *hmac)
{
	if (!(cx && key && in && hmac)) {
		printk (KERN_ERR "%s: some parameter is null\n", __PRETTY_FUNCTION__);
		return -EINVAL;
	}

	return cx->di->_hmac (cx, key, key_len, in, size, hmac, 1);
}

#ifdef CONFIG_PROC_FS
static int cipher_read_proc(char *page, char **start, off_t off,
			    int count, int *eof, void *data)
{
	struct cipher_implementation *ci;
	int len = 0;
	
	ci = (struct cipher_implementation *)data;

	len = sprintf(page,
		      "cipher_name:       %s\n"
		      "cipher_flags:      %d\n"
		      "blocksize:         %d\n"
		      "keysize_mask:      0x%08x\n"
		      "ivsize:            %d\n"
		      "key_schedule_size: %d\n",
		      ci->trans.t_name, ci->trans.t_flags, 
		      ci->blocksize, ci->key_size_mask,
		      ci->ivsize, ci->key_schedule_size);
	*eof=1;

	return len;
}

static int digest_read_proc(char *page, char **start, off_t off,
			int count, int *eof, void *data)
{
	struct digest_implementation *ci;
	int len = 0;
	
	ci = (struct digest_implementation *)data;

	len = sprintf(page, "digest_name:       %s\n"
		      "digest_flags:      %d\n"
		      "blocksize:         %d\n"
		      "working_size:      %d\n",
		      ci->trans.t_name, ci->trans.t_flags, 
		      ci->blocksize, ci->working_size);
	*eof=1;

	return len;
}

static void crypto_create_proc(void)
{
	int i;

	proc_crypto = proc_mkdir("crypto", NULL);
	for (i = 0; i < (sizeof(transforms) / sizeof(struct transform_group));
	     i++) {
		transforms[i].tg_proc_parent_dir = 
			proc_mkdir(transforms[i].tg_name, proc_crypto);
	}
}

static void crypto_delete_proc(void)
{
	int i;

	for (i = 0; i < (sizeof(transforms) / sizeof(struct transform_group));
	     i++) {
		struct proc_dir_entry *p = transforms[i].tg_proc_parent_dir;
		remove_proc_entry(transforms[i].tg_name, p);
	}

	remove_proc_entry("crypto", NULL);
}
#endif /* CONFIG_PROC_FS */

static int __init
init_cryptoapi(void)
{
#ifdef CONFIG_PROC_FS
	crypto_create_proc();
#endif /* CONFIG_PROC_FS */

	printk(KERN_INFO "cryptoapi: loaded\n");

	return 0;
}

static void __exit
cleanup_cryptoapi(void) 
{
#ifdef CONFIG_PROC_FS
	crypto_delete_proc();
#endif /* CONFIG_PROC_FS */

	printk(KERN_INFO "cryptoapi: unloaded\n");
}

module_init(init_cryptoapi);
module_exit(cleanup_cryptoapi);

EXPORT_SYMBOL(find_transform_by_name);
EXPORT_SYMBOL(register_transform);
EXPORT_SYMBOL(unregister_transform);
EXPORT_SYMBOL(register_cipher);
EXPORT_SYMBOL(unregister_cipher);
EXPORT_SYMBOL(register_digest);
EXPORT_SYMBOL(unregister_digest);

/* 
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * Emacs will notice this stuff at the end of the file and automatically
 * adjust the settings for this buffer only.  This must remain at the end
 * of the file.
 * ---------------------------------------------------------------------------     
 * Local variables:
 * c-indent-level: 8
 * c-brace-imaginary-offset: 0
 * c-brace-offset: -8
 * c-argdecl-indent: 8
 * c-label-offset: -8
 * c-continued-statement-offset: 8
 * c-continued-brace-offset: 0
 * End:
 */