[linux-2.6-block.git] / crypto / hmac.c

/*
 * Cryptographic API.
 *
 * HMAC: Keyed-Hashing for Message Authentication (RFC2104).
 *
 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
 *
 * The HMAC implementation is derived from USAGI.
 * Copyright (c) 2002 Kazunori Miyazawa <miyazawa@linux-ipv6.org> / USAGI
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option) 
 * any later version.
 *
 */
#include <linux/crypto.h>
#include <linux/mm.h>
#include <linux/highmem.h>
#include <linux/slab.h>
#include <asm/scatterlist.h>
#include "internal.h"

static void hash_key(struct crypto_tfm *tfm, u8 *key, unsigned int keylen)
{
	struct scatterlist tmp;
	
	tmp.page = virt_to_page(key);
	tmp.offset = offset_in_page(key);
	tmp.length = keylen;
	crypto_digest_digest(tfm, &tmp, 1, key);
		
}

int crypto_alloc_hmac_block(struct crypto_tfm *tfm)
{
	int ret = 0;

	BUG_ON(!crypto_tfm_alg_blocksize(tfm));
	
	tfm->crt_digest.dit_hmac_block = kmalloc(crypto_tfm_alg_blocksize(tfm),
	                                         GFP_KERNEL);
	if (tfm->crt_digest.dit_hmac_block == NULL)
		ret = -ENOMEM;

	return ret;
		
}

void crypto_free_hmac_block(struct crypto_tfm *tfm)
{
	if (tfm->crt_digest.dit_hmac_block)
		kfree(tfm->crt_digest.dit_hmac_block);
}

void crypto_hmac_init(struct crypto_tfm *tfm, u8 *key, unsigned int *keylen)
{
	unsigned int i;
	struct scatterlist tmp;
	char *ipad = tfm->crt_digest.dit_hmac_block;
	
	if (*keylen > crypto_tfm_alg_blocksize(tfm)) {
		hash_key(tfm, key, *keylen);
		*keylen = crypto_tfm_alg_digestsize(tfm);
	}

	memset(ipad, 0, crypto_tfm_alg_blocksize(tfm));
	memcpy(ipad, key, *keylen);

	for (i = 0; i < crypto_tfm_alg_blocksize(tfm); i++)
		ipad[i] ^= 0x36;

	tmp.page = virt_to_page(ipad);
	tmp.offset = offset_in_page(ipad);
	tmp.length = crypto_tfm_alg_blocksize(tfm);
	
	crypto_digest_init(tfm);
	crypto_digest_update(tfm, &tmp, 1);
}

void crypto_hmac_update(struct crypto_tfm *tfm,
                        struct scatterlist *sg, unsigned int nsg)
{
	crypto_digest_update(tfm, sg, nsg);
}

void crypto_hmac_final(struct crypto_tfm *tfm, u8 *key,
                       unsigned int *keylen, u8 *out)
{
	unsigned int i;
	struct scatterlist tmp;
	char *opad = tfm->crt_digest.dit_hmac_block;
	
	if (*keylen > crypto_tfm_alg_blocksize(tfm)) {
		hash_key(tfm, key, *keylen);
		*keylen = crypto_tfm_alg_digestsize(tfm);
	}

	crypto_digest_final(tfm, out);

	memset(opad, 0, crypto_tfm_alg_blocksize(tfm));
	memcpy(opad, key, *keylen);
		
	for (i = 0; i < crypto_tfm_alg_blocksize(tfm); i++)
		opad[i] ^= 0x5c;

	tmp.page = virt_to_page(opad);
	tmp.offset = offset_in_page(opad);
	tmp.length = crypto_tfm_alg_blocksize(tfm);

	crypto_digest_init(tfm);
	crypto_digest_update(tfm, &tmp, 1);
	
	tmp.page = virt_to_page(out);
	tmp.offset = offset_in_page(out);
	tmp.length = crypto_tfm_alg_digestsize(tfm);
	
	crypto_digest_update(tfm, &tmp, 1);
	crypto_digest_final(tfm, out);
}

void crypto_hmac(struct crypto_tfm *tfm, u8 *key, unsigned int *keylen,
                 struct scatterlist *sg, unsigned int nsg, u8 *out)
{
	crypto_hmac_init(tfm, key, keylen);
	crypto_hmac_update(tfm, sg, nsg);
	crypto_hmac_final(tfm, key, keylen, out);
}

EXPORT_SYMBOL_GPL(crypto_hmac_init);
EXPORT_SYMBOL_GPL(crypto_hmac_update);
EXPORT_SYMBOL_GPL(crypto_hmac_final);
EXPORT_SYMBOL_GPL(crypto_hmac);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Cryptographic API.
	3	*
	4	* HMAC: Keyed-Hashing for Message Authentication (RFC2104).
	5	*
	6	* Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
	7	*
	8	* The HMAC implementation is derived from USAGI.
	9	* Copyright (c) 2002 Kazunori Miyazawa <miyazawa@linux-ipv6.org> / USAGI
	10	*
	11	* This program is free software; you can redistribute it and/or modify it
	12	* under the terms of the GNU General Public License as published by the Free
	13	* Software Foundation; either version 2 of the License, or (at your option)
	14	* any later version.
	15	*
	16	*/
	17	#include <linux/crypto.h>
	18	#include <linux/mm.h>
	19	#include <linux/highmem.h>
	20	#include <linux/slab.h>
	21	#include <asm/scatterlist.h>
	22	#include "internal.h"
	23
	24	static void hash_key(struct crypto_tfm tfm, u8 key, unsigned int keylen)
	25	{
	26	struct scatterlist tmp;
	27
	28	tmp.page = virt_to_page(key);
	29	tmp.offset = offset_in_page(key);
	30	tmp.length = keylen;
	31	crypto_digest_digest(tfm, &tmp, 1, key);
	32
	33	}
	34
	35	int crypto_alloc_hmac_block(struct crypto_tfm *tfm)
	36	{
	37	int ret = 0;
	38
	39	BUG_ON(!crypto_tfm_alg_blocksize(tfm));
	40
	41	tfm->crt_digest.dit_hmac_block = kmalloc(crypto_tfm_alg_blocksize(tfm),
	42	GFP_KERNEL);
	43	if (tfm->crt_digest.dit_hmac_block == NULL)
	44	ret = -ENOMEM;
	45
	46	return ret;
	47
	48	}
	49
	50	void crypto_free_hmac_block(struct crypto_tfm *tfm)
	51	{
	52	if (tfm->crt_digest.dit_hmac_block)
	53	kfree(tfm->crt_digest.dit_hmac_block);
	54	}
	55
	56	void crypto_hmac_init(struct crypto_tfm tfm, u8 key, unsigned int *keylen)
	57	{
	58	unsigned int i;
	59	struct scatterlist tmp;
	60	char *ipad = tfm->crt_digest.dit_hmac_block;
	61
	62	if (*keylen > crypto_tfm_alg_blocksize(tfm)) {
	63	hash_key(tfm, key, *keylen);
	64	*keylen = crypto_tfm_alg_digestsize(tfm);
65	}
66
67	memset(ipad, 0, crypto_tfm_alg_blocksize(tfm));
68	memcpy(ipad, key, *keylen);
69
70	for (i = 0; i < crypto_tfm_alg_blocksize(tfm); i++)
71	ipad[i] ^= 0x36;
72
73	tmp.page = virt_to_page(ipad);
74	tmp.offset = offset_in_page(ipad);
75	tmp.length = crypto_tfm_alg_blocksize(tfm);
76
77	crypto_digest_init(tfm);
78	crypto_digest_update(tfm, &tmp, 1);
79	}
80
81	void crypto_hmac_update(struct crypto_tfm *tfm,
82	struct scatterlist *sg, unsigned int nsg)
83	{
84	crypto_digest_update(tfm, sg, nsg);
85	}
86
87	void crypto_hmac_final(struct crypto_tfm tfm, u8 key,
88	unsigned int keylen, u8 out)
89	{
90	unsigned int i;
91	struct scatterlist tmp;
92	char *opad = tfm->crt_digest.dit_hmac_block;
93
94	if (*keylen > crypto_tfm_alg_blocksize(tfm)) {
95	hash_key(tfm, key, *keylen);
96	*keylen = crypto_tfm_alg_digestsize(tfm);
97	}
98
99	crypto_digest_final(tfm, out);
100
101	memset(opad, 0, crypto_tfm_alg_blocksize(tfm));
102	memcpy(opad, key, *keylen);
103
104	for (i = 0; i < crypto_tfm_alg_blocksize(tfm); i++)
105	opad[i] ^= 0x5c;
106
107	tmp.page = virt_to_page(opad);
108	tmp.offset = offset_in_page(opad);
109	tmp.length = crypto_tfm_alg_blocksize(tfm);
110
111	crypto_digest_init(tfm);
112	crypto_digest_update(tfm, &tmp, 1);
113
114	tmp.page = virt_to_page(out);
115	tmp.offset = offset_in_page(out);
116	tmp.length = crypto_tfm_alg_digestsize(tfm);
117
118	crypto_digest_update(tfm, &tmp, 1);
119	crypto_digest_final(tfm, out);
120	}
121
122	void crypto_hmac(struct crypto_tfm tfm, u8 key, unsigned int *keylen,
123	struct scatterlist sg, unsigned int nsg, u8 out)
124	{
125	crypto_hmac_init(tfm, key, keylen);
126	crypto_hmac_update(tfm, sg, nsg);
127	crypto_hmac_final(tfm, key, keylen, out);
128	}
129
130	EXPORT_SYMBOL_GPL(crypto_hmac_init);
131	EXPORT_SYMBOL_GPL(crypto_hmac_update);
132	EXPORT_SYMBOL_GPL(crypto_hmac_final);
133	EXPORT_SYMBOL_GPL(crypto_hmac);
134