4 * HMAC: Keyed-Hashing for Message Authentication (RFC2104).
6 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
7 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
9 * The HMAC implementation is derived from USAGI.
10 * Copyright (c) 2002 Kazunori Miyazawa <miyazawa@linux-ipv6.org> / USAGI
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the Free
14 * Software Foundation; either version 2 of the License, or (at your option)
19 #include <crypto/internal/hash.h>
20 #include <crypto/scatterwalk.h>
21 #include <linux/err.h>
22 #include <linux/init.h>
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/scatterlist.h>
26 #include <linux/slab.h>
27 #include <linux/string.h>
30 struct shash_desc
*desc
;
33 static inline void *align_ptr(void *p
, unsigned int align
)
35 return (void *)ALIGN((unsigned long)p
, align
);
38 static inline struct hmac_ctx
*hmac_ctx(struct crypto_shash
*tfm
)
40 return align_ptr(crypto_shash_ctx_aligned(tfm
) +
41 crypto_shash_blocksize(tfm
) * 2 +
42 crypto_shash_digestsize(tfm
),
43 crypto_tfm_ctx_alignment());
46 static int hmac_setkey(struct crypto_shash
*parent
,
47 const u8
*inkey
, unsigned int keylen
)
49 int bs
= crypto_shash_blocksize(parent
);
50 int ds
= crypto_shash_digestsize(parent
);
51 char *ipad
= crypto_shash_ctx_aligned(parent
);
52 char *opad
= ipad
+ bs
;
53 char *digest
= opad
+ bs
;
54 struct hmac_ctx
*ctx
= align_ptr(digest
+ ds
,
55 crypto_tfm_ctx_alignment());
61 ctx
->desc
->flags
= crypto_shash_get_flags(parent
) &
62 CRYPTO_TFM_REQ_MAY_SLEEP
;
64 err
= crypto_shash_digest(ctx
->desc
, inkey
, keylen
, digest
);
72 memcpy(ipad
, inkey
, keylen
);
73 memset(ipad
+ keylen
, 0, bs
- keylen
);
74 memcpy(opad
, ipad
, bs
);
76 for (i
= 0; i
< bs
; i
++) {
84 static int hmac_init(struct shash_desc
*pdesc
)
86 struct crypto_shash
*parent
= pdesc
->tfm
;
87 int bs
= crypto_shash_blocksize(parent
);
88 int ds
= crypto_shash_digestsize(parent
);
89 char *ipad
= crypto_shash_ctx_aligned(parent
);
90 struct hmac_ctx
*ctx
= align_ptr(ipad
+ bs
* 2 + ds
,
91 crypto_tfm_ctx_alignment());
92 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
94 desc
->tfm
= ctx
->desc
->tfm
;
95 desc
->flags
= pdesc
->flags
& CRYPTO_TFM_REQ_MAY_SLEEP
;
97 return crypto_shash_init(desc
) ?:
98 crypto_shash_update(desc
, ipad
, bs
);
101 static int hmac_update(struct shash_desc
*pdesc
,
102 const u8
*data
, unsigned int nbytes
)
104 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
106 desc
->flags
= pdesc
->flags
& CRYPTO_TFM_REQ_MAY_SLEEP
;
108 return crypto_shash_update(desc
, data
, nbytes
);
111 static int hmac_final(struct shash_desc
*pdesc
, u8
*out
)
113 struct crypto_shash
*parent
= pdesc
->tfm
;
114 int bs
= crypto_shash_blocksize(parent
);
115 int ds
= crypto_shash_digestsize(parent
);
116 char *opad
= crypto_shash_ctx_aligned(parent
) + bs
;
117 char *digest
= opad
+ bs
;
118 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
120 desc
->flags
= pdesc
->flags
& CRYPTO_TFM_REQ_MAY_SLEEP
;
122 return crypto_shash_final(desc
, digest
) ?:
123 crypto_shash_digest(desc
, opad
, bs
+ ds
, out
);
126 static int hmac_finup(struct shash_desc
*pdesc
, const u8
*data
,
127 unsigned int nbytes
, u8
*out
)
130 struct crypto_shash
*parent
= pdesc
->tfm
;
131 int bs
= crypto_shash_blocksize(parent
);
132 int ds
= crypto_shash_digestsize(parent
);
133 char *opad
= crypto_shash_ctx_aligned(parent
) + bs
;
134 char *digest
= opad
+ bs
;
135 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
137 desc
->flags
= pdesc
->flags
& CRYPTO_TFM_REQ_MAY_SLEEP
;
139 return crypto_shash_finup(desc
, data
, nbytes
, digest
) ?:
140 crypto_shash_digest(desc
, opad
, bs
+ ds
, out
);
143 static int hmac_init_tfm(struct crypto_tfm
*tfm
)
145 struct crypto_shash
*parent
= __crypto_shash_cast(tfm
);
146 struct crypto_shash
*hash
;
147 struct crypto_instance
*inst
= (void *)tfm
->__crt_alg
;
148 struct crypto_shash_spawn
*spawn
= crypto_instance_ctx(inst
);
149 struct hmac_ctx
*ctx
= hmac_ctx(parent
);
151 hash
= crypto_spawn_shash(spawn
);
153 return PTR_ERR(hash
);
155 parent
->descsize
= sizeof(struct shash_desc
) +
156 crypto_shash_descsize(hash
);
158 ctx
->desc
= kmalloc(parent
->descsize
, GFP_KERNEL
);
160 crypto_free_shash(hash
);
164 ctx
->desc
->tfm
= hash
;
168 static void hmac_exit_tfm(struct crypto_tfm
*tfm
)
170 struct hmac_ctx
*ctx
= hmac_ctx(__crypto_shash_cast(tfm
));
171 crypto_free_shash(ctx
->desc
->tfm
);
175 static int hmac_create(struct crypto_template
*tmpl
, struct rtattr
**tb
)
177 struct shash_instance
*inst
;
178 struct crypto_alg
*alg
;
179 struct shash_alg
*salg
;
183 err
= crypto_check_attr_type(tb
, CRYPTO_ALG_TYPE_SHASH
);
187 salg
= shash_attr_alg(tb
[1], 0, 0);
189 return PTR_ERR(salg
);
192 ds
= salg
->digestsize
;
194 if (ds
> alg
->cra_blocksize
)
197 inst
= shash_alloc_instance("hmac", alg
);
202 err
= crypto_init_shash_spawn(shash_instance_ctx(inst
), salg
,
203 shash_crypto_instance(inst
));
207 inst
->alg
.base
.cra_priority
= alg
->cra_priority
;
208 inst
->alg
.base
.cra_blocksize
= alg
->cra_blocksize
;
209 inst
->alg
.base
.cra_alignmask
= alg
->cra_alignmask
;
211 inst
->alg
.digestsize
= ds
;
213 inst
->alg
.base
.cra_ctxsize
= sizeof(struct hmac_ctx
) +
214 ALIGN(alg
->cra_blocksize
* 2 + ds
,
215 crypto_tfm_ctx_alignment());
217 inst
->alg
.base
.cra_init
= hmac_init_tfm
;
218 inst
->alg
.base
.cra_exit
= hmac_exit_tfm
;
220 inst
->alg
.init
= hmac_init
;
221 inst
->alg
.update
= hmac_update
;
222 inst
->alg
.final
= hmac_final
;
223 inst
->alg
.finup
= hmac_finup
;
224 inst
->alg
.setkey
= hmac_setkey
;
226 err
= shash_register_instance(tmpl
, inst
);
229 shash_free_instance(shash_crypto_instance(inst
));
237 static struct crypto_template hmac_tmpl
= {
239 .create
= hmac_create
,
240 .free
= shash_free_instance
,
241 .module
= THIS_MODULE
,
244 static int __init
hmac_module_init(void)
246 return crypto_register_template(&hmac_tmpl
);
249 static void __exit
hmac_module_exit(void)
251 crypto_unregister_template(&hmac_tmpl
);
254 module_init(hmac_module_init
);
255 module_exit(hmac_module_exit
);
257 MODULE_LICENSE("GPL");
258 MODULE_DESCRIPTION("HMAC hash algorithm");