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/string.h>
29 struct crypto_shash
*hash
;
32 static inline void *align_ptr(void *p
, unsigned int align
)
34 return (void *)ALIGN((unsigned long)p
, align
);
37 static inline struct hmac_ctx
*hmac_ctx(struct crypto_shash
*tfm
)
39 return align_ptr(crypto_shash_ctx_aligned(tfm
) +
40 crypto_shash_statesize(tfm
) * 2,
41 crypto_tfm_ctx_alignment());
44 static int hmac_setkey(struct crypto_shash
*parent
,
45 const u8
*inkey
, unsigned int keylen
)
47 int bs
= crypto_shash_blocksize(parent
);
48 int ds
= crypto_shash_digestsize(parent
);
49 int ss
= crypto_shash_statesize(parent
);
50 char *ipad
= crypto_shash_ctx_aligned(parent
);
51 char *opad
= ipad
+ ss
;
52 struct hmac_ctx
*ctx
= align_ptr(opad
+ ss
,
53 crypto_tfm_ctx_alignment());
54 struct crypto_shash
*hash
= ctx
->hash
;
55 SHASH_DESC_ON_STACK(shash
, hash
);
59 shash
->flags
= crypto_shash_get_flags(parent
)
60 & CRYPTO_TFM_REQ_MAY_SLEEP
;
65 err
= crypto_shash_digest(shash
, inkey
, keylen
, ipad
);
71 memcpy(ipad
, inkey
, keylen
);
73 memset(ipad
+ keylen
, 0, bs
- keylen
);
74 memcpy(opad
, ipad
, bs
);
76 for (i
= 0; i
< bs
; i
++) {
81 return crypto_shash_init(shash
) ?:
82 crypto_shash_update(shash
, ipad
, bs
) ?:
83 crypto_shash_export(shash
, ipad
) ?:
84 crypto_shash_init(shash
) ?:
85 crypto_shash_update(shash
, opad
, bs
) ?:
86 crypto_shash_export(shash
, opad
);
89 static int hmac_export(struct shash_desc
*pdesc
, void *out
)
91 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
93 desc
->flags
= pdesc
->flags
& CRYPTO_TFM_REQ_MAY_SLEEP
;
95 return crypto_shash_export(desc
, out
);
98 static int hmac_import(struct shash_desc
*pdesc
, const void *in
)
100 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
101 struct hmac_ctx
*ctx
= hmac_ctx(pdesc
->tfm
);
103 desc
->tfm
= ctx
->hash
;
104 desc
->flags
= pdesc
->flags
& CRYPTO_TFM_REQ_MAY_SLEEP
;
106 return crypto_shash_import(desc
, in
);
109 static int hmac_init(struct shash_desc
*pdesc
)
111 return hmac_import(pdesc
, crypto_shash_ctx_aligned(pdesc
->tfm
));
114 static int hmac_update(struct shash_desc
*pdesc
,
115 const u8
*data
, unsigned int nbytes
)
117 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
119 desc
->flags
= pdesc
->flags
& CRYPTO_TFM_REQ_MAY_SLEEP
;
121 return crypto_shash_update(desc
, data
, nbytes
);
124 static int hmac_final(struct shash_desc
*pdesc
, u8
*out
)
126 struct crypto_shash
*parent
= pdesc
->tfm
;
127 int ds
= crypto_shash_digestsize(parent
);
128 int ss
= crypto_shash_statesize(parent
);
129 char *opad
= crypto_shash_ctx_aligned(parent
) + ss
;
130 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
132 desc
->flags
= pdesc
->flags
& CRYPTO_TFM_REQ_MAY_SLEEP
;
134 return crypto_shash_final(desc
, out
) ?:
135 crypto_shash_import(desc
, opad
) ?:
136 crypto_shash_finup(desc
, out
, ds
, out
);
139 static int hmac_finup(struct shash_desc
*pdesc
, const u8
*data
,
140 unsigned int nbytes
, u8
*out
)
143 struct crypto_shash
*parent
= pdesc
->tfm
;
144 int ds
= crypto_shash_digestsize(parent
);
145 int ss
= crypto_shash_statesize(parent
);
146 char *opad
= crypto_shash_ctx_aligned(parent
) + ss
;
147 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
149 desc
->flags
= pdesc
->flags
& CRYPTO_TFM_REQ_MAY_SLEEP
;
151 return crypto_shash_finup(desc
, data
, nbytes
, out
) ?:
152 crypto_shash_import(desc
, opad
) ?:
153 crypto_shash_finup(desc
, out
, ds
, out
);
156 static int hmac_init_tfm(struct crypto_tfm
*tfm
)
158 struct crypto_shash
*parent
= __crypto_shash_cast(tfm
);
159 struct crypto_shash
*hash
;
160 struct crypto_instance
*inst
= (void *)tfm
->__crt_alg
;
161 struct crypto_shash_spawn
*spawn
= crypto_instance_ctx(inst
);
162 struct hmac_ctx
*ctx
= hmac_ctx(parent
);
164 hash
= crypto_spawn_shash(spawn
);
166 return PTR_ERR(hash
);
168 parent
->descsize
= sizeof(struct shash_desc
) +
169 crypto_shash_descsize(hash
);
175 static void hmac_exit_tfm(struct crypto_tfm
*tfm
)
177 struct hmac_ctx
*ctx
= hmac_ctx(__crypto_shash_cast(tfm
));
178 crypto_free_shash(ctx
->hash
);
181 static int hmac_create(struct crypto_template
*tmpl
, struct rtattr
**tb
)
183 struct shash_instance
*inst
;
184 struct crypto_alg
*alg
;
185 struct shash_alg
*salg
;
190 err
= crypto_check_attr_type(tb
, CRYPTO_ALG_TYPE_SHASH
);
194 salg
= shash_attr_alg(tb
[1], 0, 0);
196 return PTR_ERR(salg
);
199 ds
= salg
->digestsize
;
200 ss
= salg
->statesize
;
202 if (ds
> alg
->cra_blocksize
||
203 ss
< alg
->cra_blocksize
)
206 inst
= shash_alloc_instance("hmac", alg
);
211 err
= crypto_init_shash_spawn(shash_instance_ctx(inst
), salg
,
212 shash_crypto_instance(inst
));
216 inst
->alg
.base
.cra_priority
= alg
->cra_priority
;
217 inst
->alg
.base
.cra_blocksize
= alg
->cra_blocksize
;
218 inst
->alg
.base
.cra_alignmask
= alg
->cra_alignmask
;
220 ss
= ALIGN(ss
, alg
->cra_alignmask
+ 1);
221 inst
->alg
.digestsize
= ds
;
222 inst
->alg
.statesize
= ss
;
224 inst
->alg
.base
.cra_ctxsize
= sizeof(struct hmac_ctx
) +
225 ALIGN(ss
* 2, crypto_tfm_ctx_alignment());
227 inst
->alg
.base
.cra_init
= hmac_init_tfm
;
228 inst
->alg
.base
.cra_exit
= hmac_exit_tfm
;
230 inst
->alg
.init
= hmac_init
;
231 inst
->alg
.update
= hmac_update
;
232 inst
->alg
.final
= hmac_final
;
233 inst
->alg
.finup
= hmac_finup
;
234 inst
->alg
.export
= hmac_export
;
235 inst
->alg
.import
= hmac_import
;
236 inst
->alg
.setkey
= hmac_setkey
;
238 err
= shash_register_instance(tmpl
, inst
);
241 shash_free_instance(shash_crypto_instance(inst
));
249 static struct crypto_template hmac_tmpl
= {
251 .create
= hmac_create
,
252 .free
= shash_free_instance
,
253 .module
= THIS_MODULE
,
256 static int __init
hmac_module_init(void)
258 return crypto_register_template(&hmac_tmpl
);
261 static void __exit
hmac_module_exit(void)
263 crypto_unregister_template(&hmac_tmpl
);
266 module_init(hmac_module_init
);
267 module_exit(hmac_module_exit
);
269 MODULE_LICENSE("GPL");
270 MODULE_DESCRIPTION("HMAC hash algorithm");
271 MODULE_ALIAS_CRYPTO("hmac");