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/hmac.h>
20 #include <crypto/internal/hash.h>
21 #include <crypto/scatterwalk.h>
22 #include <linux/err.h>
23 #include <linux/init.h>
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/scatterlist.h>
27 #include <linux/string.h>
30 struct crypto_shash
*hash
;
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_statesize(tfm
) * 2,
42 crypto_tfm_ctx_alignment());
45 static int hmac_setkey(struct crypto_shash
*parent
,
46 const u8
*inkey
, unsigned int keylen
)
48 int bs
= crypto_shash_blocksize(parent
);
49 int ds
= crypto_shash_digestsize(parent
);
50 int ss
= crypto_shash_statesize(parent
);
51 char *ipad
= crypto_shash_ctx_aligned(parent
);
52 char *opad
= ipad
+ ss
;
53 struct hmac_ctx
*ctx
= align_ptr(opad
+ ss
,
54 crypto_tfm_ctx_alignment());
55 struct crypto_shash
*hash
= ctx
->hash
;
56 SHASH_DESC_ON_STACK(shash
, hash
);
64 err
= crypto_shash_digest(shash
, inkey
, keylen
, ipad
);
70 memcpy(ipad
, inkey
, keylen
);
72 memset(ipad
+ keylen
, 0, bs
- keylen
);
73 memcpy(opad
, ipad
, bs
);
75 for (i
= 0; i
< bs
; i
++) {
76 ipad
[i
] ^= HMAC_IPAD_VALUE
;
77 opad
[i
] ^= HMAC_OPAD_VALUE
;
80 return crypto_shash_init(shash
) ?:
81 crypto_shash_update(shash
, ipad
, bs
) ?:
82 crypto_shash_export(shash
, ipad
) ?:
83 crypto_shash_init(shash
) ?:
84 crypto_shash_update(shash
, opad
, bs
) ?:
85 crypto_shash_export(shash
, opad
);
88 static int hmac_export(struct shash_desc
*pdesc
, void *out
)
90 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
92 return crypto_shash_export(desc
, out
);
95 static int hmac_import(struct shash_desc
*pdesc
, const void *in
)
97 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
98 struct hmac_ctx
*ctx
= hmac_ctx(pdesc
->tfm
);
100 desc
->tfm
= ctx
->hash
;
102 return crypto_shash_import(desc
, in
);
105 static int hmac_init(struct shash_desc
*pdesc
)
107 return hmac_import(pdesc
, crypto_shash_ctx_aligned(pdesc
->tfm
));
110 static int hmac_update(struct shash_desc
*pdesc
,
111 const u8
*data
, unsigned int nbytes
)
113 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
115 return crypto_shash_update(desc
, data
, nbytes
);
118 static int hmac_final(struct shash_desc
*pdesc
, u8
*out
)
120 struct crypto_shash
*parent
= pdesc
->tfm
;
121 int ds
= crypto_shash_digestsize(parent
);
122 int ss
= crypto_shash_statesize(parent
);
123 char *opad
= crypto_shash_ctx_aligned(parent
) + ss
;
124 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
126 return crypto_shash_final(desc
, out
) ?:
127 crypto_shash_import(desc
, opad
) ?:
128 crypto_shash_finup(desc
, out
, ds
, out
);
131 static int hmac_finup(struct shash_desc
*pdesc
, const u8
*data
,
132 unsigned int nbytes
, u8
*out
)
135 struct crypto_shash
*parent
= pdesc
->tfm
;
136 int ds
= crypto_shash_digestsize(parent
);
137 int ss
= crypto_shash_statesize(parent
);
138 char *opad
= crypto_shash_ctx_aligned(parent
) + ss
;
139 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
141 return crypto_shash_finup(desc
, data
, nbytes
, out
) ?:
142 crypto_shash_import(desc
, opad
) ?:
143 crypto_shash_finup(desc
, out
, ds
, out
);
146 static int hmac_init_tfm(struct crypto_tfm
*tfm
)
148 struct crypto_shash
*parent
= __crypto_shash_cast(tfm
);
149 struct crypto_shash
*hash
;
150 struct crypto_instance
*inst
= (void *)tfm
->__crt_alg
;
151 struct crypto_shash_spawn
*spawn
= crypto_instance_ctx(inst
);
152 struct hmac_ctx
*ctx
= hmac_ctx(parent
);
154 hash
= crypto_spawn_shash(spawn
);
156 return PTR_ERR(hash
);
158 parent
->descsize
= sizeof(struct shash_desc
) +
159 crypto_shash_descsize(hash
);
165 static void hmac_exit_tfm(struct crypto_tfm
*tfm
)
167 struct hmac_ctx
*ctx
= hmac_ctx(__crypto_shash_cast(tfm
));
168 crypto_free_shash(ctx
->hash
);
171 static int hmac_create(struct crypto_template
*tmpl
, struct rtattr
**tb
)
173 struct shash_instance
*inst
;
174 struct crypto_alg
*alg
;
175 struct shash_alg
*salg
;
180 err
= crypto_check_attr_type(tb
, CRYPTO_ALG_TYPE_SHASH
);
184 salg
= shash_attr_alg(tb
[1], 0, 0);
186 return PTR_ERR(salg
);
189 /* The underlying hash algorithm must be unkeyed */
191 if (crypto_shash_alg_has_setkey(salg
))
194 ds
= salg
->digestsize
;
195 ss
= salg
->statesize
;
196 if (ds
> alg
->cra_blocksize
||
197 ss
< alg
->cra_blocksize
)
200 inst
= shash_alloc_instance("hmac", alg
);
205 err
= crypto_init_shash_spawn(shash_instance_ctx(inst
), salg
,
206 shash_crypto_instance(inst
));
210 inst
->alg
.base
.cra_priority
= alg
->cra_priority
;
211 inst
->alg
.base
.cra_blocksize
= alg
->cra_blocksize
;
212 inst
->alg
.base
.cra_alignmask
= alg
->cra_alignmask
;
214 ss
= ALIGN(ss
, alg
->cra_alignmask
+ 1);
215 inst
->alg
.digestsize
= ds
;
216 inst
->alg
.statesize
= ss
;
218 inst
->alg
.base
.cra_ctxsize
= sizeof(struct hmac_ctx
) +
219 ALIGN(ss
* 2, crypto_tfm_ctx_alignment());
221 inst
->alg
.base
.cra_init
= hmac_init_tfm
;
222 inst
->alg
.base
.cra_exit
= hmac_exit_tfm
;
224 inst
->alg
.init
= hmac_init
;
225 inst
->alg
.update
= hmac_update
;
226 inst
->alg
.final
= hmac_final
;
227 inst
->alg
.finup
= hmac_finup
;
228 inst
->alg
.export
= hmac_export
;
229 inst
->alg
.import
= hmac_import
;
230 inst
->alg
.setkey
= hmac_setkey
;
232 err
= shash_register_instance(tmpl
, inst
);
235 shash_free_instance(shash_crypto_instance(inst
));
243 static struct crypto_template hmac_tmpl
= {
245 .create
= hmac_create
,
246 .free
= shash_free_instance
,
247 .module
= THIS_MODULE
,
250 static int __init
hmac_module_init(void)
252 return crypto_register_template(&hmac_tmpl
);
255 static void __exit
hmac_module_exit(void)
257 crypto_unregister_template(&hmac_tmpl
);
260 subsys_initcall(hmac_module_init
);
261 module_exit(hmac_module_exit
);
263 MODULE_LICENSE("GPL");
264 MODULE_DESCRIPTION("HMAC hash algorithm");
265 MODULE_ALIAS_CRYPTO("hmac");