1 // SPDX-License-Identifier: GPL-2.0-or-later
5 * HMAC: Keyed-Hashing for Message Authentication (RFC2104).
7 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
8 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
10 * The HMAC implementation is derived from USAGI.
11 * Copyright (c) 2002 Kazunori Miyazawa <miyazawa@linux-ipv6.org> / USAGI
14 #include <crypto/hmac.h>
15 #include <crypto/internal/hash.h>
16 #include <crypto/scatterwalk.h>
17 #include <linux/err.h>
18 #include <linux/fips.h>
19 #include <linux/init.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/scatterlist.h>
23 #include <linux/string.h>
26 struct crypto_shash
*hash
;
29 static inline void *align_ptr(void *p
, unsigned int align
)
31 return (void *)ALIGN((unsigned long)p
, align
);
34 static inline struct hmac_ctx
*hmac_ctx(struct crypto_shash
*tfm
)
36 return align_ptr(crypto_shash_ctx_aligned(tfm
) +
37 crypto_shash_statesize(tfm
) * 2,
38 crypto_tfm_ctx_alignment());
41 static int hmac_setkey(struct crypto_shash
*parent
,
42 const u8
*inkey
, unsigned int keylen
)
44 int bs
= crypto_shash_blocksize(parent
);
45 int ds
= crypto_shash_digestsize(parent
);
46 int ss
= crypto_shash_statesize(parent
);
47 char *ipad
= crypto_shash_ctx_aligned(parent
);
48 char *opad
= ipad
+ ss
;
49 struct hmac_ctx
*ctx
= align_ptr(opad
+ ss
,
50 crypto_tfm_ctx_alignment());
51 struct crypto_shash
*hash
= ctx
->hash
;
52 SHASH_DESC_ON_STACK(shash
, hash
);
55 if (fips_enabled
&& (keylen
< 112 / 8))
63 err
= crypto_shash_digest(shash
, inkey
, keylen
, ipad
);
69 memcpy(ipad
, inkey
, keylen
);
71 memset(ipad
+ keylen
, 0, bs
- keylen
);
72 memcpy(opad
, ipad
, bs
);
74 for (i
= 0; i
< bs
; i
++) {
75 ipad
[i
] ^= HMAC_IPAD_VALUE
;
76 opad
[i
] ^= HMAC_OPAD_VALUE
;
79 return crypto_shash_init(shash
) ?:
80 crypto_shash_update(shash
, ipad
, bs
) ?:
81 crypto_shash_export(shash
, ipad
) ?:
82 crypto_shash_init(shash
) ?:
83 crypto_shash_update(shash
, opad
, bs
) ?:
84 crypto_shash_export(shash
, opad
);
87 static int hmac_export(struct shash_desc
*pdesc
, void *out
)
89 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
91 return crypto_shash_export(desc
, out
);
94 static int hmac_import(struct shash_desc
*pdesc
, const void *in
)
96 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
97 struct hmac_ctx
*ctx
= hmac_ctx(pdesc
->tfm
);
99 desc
->tfm
= ctx
->hash
;
101 return crypto_shash_import(desc
, in
);
104 static int hmac_init(struct shash_desc
*pdesc
)
106 return hmac_import(pdesc
, crypto_shash_ctx_aligned(pdesc
->tfm
));
109 static int hmac_update(struct shash_desc
*pdesc
,
110 const u8
*data
, unsigned int nbytes
)
112 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
114 return crypto_shash_update(desc
, data
, nbytes
);
117 static int hmac_final(struct shash_desc
*pdesc
, u8
*out
)
119 struct crypto_shash
*parent
= pdesc
->tfm
;
120 int ds
= crypto_shash_digestsize(parent
);
121 int ss
= crypto_shash_statesize(parent
);
122 char *opad
= crypto_shash_ctx_aligned(parent
) + ss
;
123 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
125 return crypto_shash_final(desc
, out
) ?:
126 crypto_shash_import(desc
, opad
) ?:
127 crypto_shash_finup(desc
, out
, ds
, out
);
130 static int hmac_finup(struct shash_desc
*pdesc
, const u8
*data
,
131 unsigned int nbytes
, u8
*out
)
134 struct crypto_shash
*parent
= pdesc
->tfm
;
135 int ds
= crypto_shash_digestsize(parent
);
136 int ss
= crypto_shash_statesize(parent
);
137 char *opad
= crypto_shash_ctx_aligned(parent
) + ss
;
138 struct shash_desc
*desc
= shash_desc_ctx(pdesc
);
140 return crypto_shash_finup(desc
, data
, nbytes
, out
) ?:
141 crypto_shash_import(desc
, opad
) ?:
142 crypto_shash_finup(desc
, out
, ds
, out
);
145 static int hmac_init_tfm(struct crypto_shash
*parent
)
147 struct crypto_shash
*hash
;
148 struct shash_instance
*inst
= shash_alg_instance(parent
);
149 struct crypto_shash_spawn
*spawn
= shash_instance_ctx(inst
);
150 struct hmac_ctx
*ctx
= hmac_ctx(parent
);
152 hash
= crypto_spawn_shash(spawn
);
154 return PTR_ERR(hash
);
156 parent
->descsize
= sizeof(struct shash_desc
) +
157 crypto_shash_descsize(hash
);
163 static int hmac_clone_tfm(struct crypto_shash
*dst
, struct crypto_shash
*src
)
165 struct hmac_ctx
*sctx
= hmac_ctx(src
);
166 struct hmac_ctx
*dctx
= hmac_ctx(dst
);
167 struct crypto_shash
*hash
;
169 hash
= crypto_clone_shash(sctx
->hash
);
171 return PTR_ERR(hash
);
177 static void hmac_exit_tfm(struct crypto_shash
*parent
)
179 struct hmac_ctx
*ctx
= hmac_ctx(parent
);
181 crypto_free_shash(ctx
->hash
);
184 static int hmac_create(struct crypto_template
*tmpl
, struct rtattr
**tb
)
186 struct shash_instance
*inst
;
187 struct crypto_shash_spawn
*spawn
;
188 struct crypto_alg
*alg
;
189 struct shash_alg
*salg
;
195 err
= crypto_check_attr_type(tb
, CRYPTO_ALG_TYPE_SHASH
, &mask
);
199 inst
= kzalloc(sizeof(*inst
) + sizeof(*spawn
), GFP_KERNEL
);
202 spawn
= shash_instance_ctx(inst
);
204 err
= crypto_grab_shash(spawn
, shash_crypto_instance(inst
),
205 crypto_attr_alg_name(tb
[1]), 0, mask
);
208 salg
= crypto_spawn_shash_alg(spawn
);
211 /* The underlying hash algorithm must not require a key */
213 if (crypto_shash_alg_needs_key(salg
))
216 ds
= salg
->digestsize
;
217 ss
= salg
->statesize
;
218 if (ds
> alg
->cra_blocksize
||
219 ss
< alg
->cra_blocksize
)
222 err
= crypto_inst_setname(shash_crypto_instance(inst
), tmpl
->name
, alg
);
226 inst
->alg
.base
.cra_priority
= alg
->cra_priority
;
227 inst
->alg
.base
.cra_blocksize
= alg
->cra_blocksize
;
228 inst
->alg
.base
.cra_alignmask
= alg
->cra_alignmask
;
230 ss
= ALIGN(ss
, alg
->cra_alignmask
+ 1);
231 inst
->alg
.digestsize
= ds
;
232 inst
->alg
.statesize
= ss
;
234 inst
->alg
.base
.cra_ctxsize
= sizeof(struct hmac_ctx
) +
235 ALIGN(ss
* 2, crypto_tfm_ctx_alignment());
237 inst
->alg
.init
= hmac_init
;
238 inst
->alg
.update
= hmac_update
;
239 inst
->alg
.final
= hmac_final
;
240 inst
->alg
.finup
= hmac_finup
;
241 inst
->alg
.export
= hmac_export
;
242 inst
->alg
.import
= hmac_import
;
243 inst
->alg
.setkey
= hmac_setkey
;
244 inst
->alg
.init_tfm
= hmac_init_tfm
;
245 inst
->alg
.clone_tfm
= hmac_clone_tfm
;
246 inst
->alg
.exit_tfm
= hmac_exit_tfm
;
248 inst
->free
= shash_free_singlespawn_instance
;
250 err
= shash_register_instance(tmpl
, inst
);
253 shash_free_singlespawn_instance(inst
);
258 static struct crypto_template hmac_tmpl
= {
260 .create
= hmac_create
,
261 .module
= THIS_MODULE
,
264 static int __init
hmac_module_init(void)
266 return crypto_register_template(&hmac_tmpl
);
269 static void __exit
hmac_module_exit(void)
271 crypto_unregister_template(&hmac_tmpl
);
274 subsys_initcall(hmac_module_init
);
275 module_exit(hmac_module_exit
);
277 MODULE_LICENSE("GPL");
278 MODULE_DESCRIPTION("HMAC hash algorithm");
279 MODULE_ALIAS_CRYPTO("hmac");