md: correctly update sysfs when a raid1 is reshaped
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / crypto / hmac.c
blob8802fb6dd5a6c857e4d78880944d5f9c3cc6c9d4
1 /*
2 * Cryptographic API.
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)
15 * any later version.
19 #include <crypto/algapi.h>
20 #include <linux/err.h>
21 #include <linux/init.h>
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/scatterlist.h>
25 #include <linux/slab.h>
26 #include <linux/string.h>
28 struct hmac_ctx {
29 struct crypto_hash *child;
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_hash *tfm)
39 return align_ptr(crypto_hash_ctx_aligned(tfm) +
40 crypto_hash_blocksize(tfm) * 2 +
41 crypto_hash_digestsize(tfm), sizeof(void *));
44 static int hmac_setkey(struct crypto_hash *parent,
45 const u8 *inkey, unsigned int keylen)
47 int bs = crypto_hash_blocksize(parent);
48 int ds = crypto_hash_digestsize(parent);
49 char *ipad = crypto_hash_ctx_aligned(parent);
50 char *opad = ipad + bs;
51 char *digest = opad + bs;
52 struct hmac_ctx *ctx = align_ptr(digest + ds, sizeof(void *));
53 struct crypto_hash *tfm = ctx->child;
54 unsigned int i;
56 if (keylen > bs) {
57 struct hash_desc desc;
58 struct scatterlist tmp;
59 int err;
61 desc.tfm = tfm;
62 desc.flags = crypto_hash_get_flags(parent);
63 desc.flags &= CRYPTO_TFM_REQ_MAY_SLEEP;
64 sg_set_buf(&tmp, inkey, keylen);
66 err = crypto_hash_digest(&desc, &tmp, keylen, digest);
67 if (err)
68 return err;
70 inkey = digest;
71 keylen = ds;
74 memcpy(ipad, inkey, keylen);
75 memset(ipad + keylen, 0, bs - keylen);
76 memcpy(opad, ipad, bs);
78 for (i = 0; i < bs; i++) {
79 ipad[i] ^= 0x36;
80 opad[i] ^= 0x5c;
83 return 0;
86 static int hmac_init(struct hash_desc *pdesc)
88 struct crypto_hash *parent = pdesc->tfm;
89 int bs = crypto_hash_blocksize(parent);
90 int ds = crypto_hash_digestsize(parent);
91 char *ipad = crypto_hash_ctx_aligned(parent);
92 struct hmac_ctx *ctx = align_ptr(ipad + bs * 2 + ds, sizeof(void *));
93 struct hash_desc desc;
94 struct scatterlist tmp;
95 int err;
97 desc.tfm = ctx->child;
98 desc.flags = pdesc->flags & CRYPTO_TFM_REQ_MAY_SLEEP;
99 sg_set_buf(&tmp, ipad, bs);
101 err = crypto_hash_init(&desc);
102 if (unlikely(err))
103 return err;
105 return crypto_hash_update(&desc, &tmp, bs);
108 static int hmac_update(struct hash_desc *pdesc,
109 struct scatterlist *sg, unsigned int nbytes)
111 struct hmac_ctx *ctx = hmac_ctx(pdesc->tfm);
112 struct hash_desc desc;
114 desc.tfm = ctx->child;
115 desc.flags = pdesc->flags & CRYPTO_TFM_REQ_MAY_SLEEP;
117 return crypto_hash_update(&desc, sg, nbytes);
120 static int hmac_final(struct hash_desc *pdesc, u8 *out)
122 struct crypto_hash *parent = pdesc->tfm;
123 int bs = crypto_hash_blocksize(parent);
124 int ds = crypto_hash_digestsize(parent);
125 char *opad = crypto_hash_ctx_aligned(parent) + bs;
126 char *digest = opad + bs;
127 struct hmac_ctx *ctx = align_ptr(digest + ds, sizeof(void *));
128 struct hash_desc desc;
129 struct scatterlist tmp;
130 int err;
132 desc.tfm = ctx->child;
133 desc.flags = pdesc->flags & CRYPTO_TFM_REQ_MAY_SLEEP;
134 sg_set_buf(&tmp, opad, bs + ds);
136 err = crypto_hash_final(&desc, digest);
137 if (unlikely(err))
138 return err;
140 return crypto_hash_digest(&desc, &tmp, bs + ds, out);
143 static int hmac_digest(struct hash_desc *pdesc, struct scatterlist *sg,
144 unsigned int nbytes, u8 *out)
146 struct crypto_hash *parent = pdesc->tfm;
147 int bs = crypto_hash_blocksize(parent);
148 int ds = crypto_hash_digestsize(parent);
149 char *ipad = crypto_hash_ctx_aligned(parent);
150 char *opad = ipad + bs;
151 char *digest = opad + bs;
152 struct hmac_ctx *ctx = align_ptr(digest + ds, sizeof(void *));
153 struct hash_desc desc;
154 struct scatterlist sg1[2];
155 struct scatterlist sg2[1];
156 int err;
158 desc.tfm = ctx->child;
159 desc.flags = pdesc->flags & CRYPTO_TFM_REQ_MAY_SLEEP;
161 sg_set_buf(sg1, ipad, bs);
162 sg1[1].page = (void *)sg;
163 sg1[1].length = 0;
164 sg_set_buf(sg2, opad, bs + ds);
166 err = crypto_hash_digest(&desc, sg1, nbytes + bs, digest);
167 if (unlikely(err))
168 return err;
170 return crypto_hash_digest(&desc, sg2, bs + ds, out);
173 static int hmac_init_tfm(struct crypto_tfm *tfm)
175 struct crypto_hash *hash;
176 struct crypto_instance *inst = (void *)tfm->__crt_alg;
177 struct crypto_spawn *spawn = crypto_instance_ctx(inst);
178 struct hmac_ctx *ctx = hmac_ctx(__crypto_hash_cast(tfm));
180 hash = crypto_spawn_hash(spawn);
181 if (IS_ERR(hash))
182 return PTR_ERR(hash);
184 ctx->child = hash;
185 return 0;
188 static void hmac_exit_tfm(struct crypto_tfm *tfm)
190 struct hmac_ctx *ctx = hmac_ctx(__crypto_hash_cast(tfm));
191 crypto_free_hash(ctx->child);
194 static void hmac_free(struct crypto_instance *inst)
196 crypto_drop_spawn(crypto_instance_ctx(inst));
197 kfree(inst);
200 static struct crypto_instance *hmac_alloc(struct rtattr **tb)
202 struct crypto_instance *inst;
203 struct crypto_alg *alg;
204 int err;
206 err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_HASH);
207 if (err)
208 return ERR_PTR(err);
210 alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_HASH,
211 CRYPTO_ALG_TYPE_HASH_MASK);
212 if (IS_ERR(alg))
213 return ERR_PTR(PTR_ERR(alg));
215 inst = crypto_alloc_instance("hmac", alg);
216 if (IS_ERR(inst))
217 goto out_put_alg;
219 inst->alg.cra_flags = CRYPTO_ALG_TYPE_HASH;
220 inst->alg.cra_priority = alg->cra_priority;
221 inst->alg.cra_blocksize = alg->cra_blocksize;
222 inst->alg.cra_alignmask = alg->cra_alignmask;
223 inst->alg.cra_type = &crypto_hash_type;
225 inst->alg.cra_hash.digestsize =
226 (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==
227 CRYPTO_ALG_TYPE_HASH ? alg->cra_hash.digestsize :
228 alg->cra_digest.dia_digestsize;
230 inst->alg.cra_ctxsize = sizeof(struct hmac_ctx) +
231 ALIGN(inst->alg.cra_blocksize * 2 +
232 inst->alg.cra_hash.digestsize,
233 sizeof(void *));
235 inst->alg.cra_init = hmac_init_tfm;
236 inst->alg.cra_exit = hmac_exit_tfm;
238 inst->alg.cra_hash.init = hmac_init;
239 inst->alg.cra_hash.update = hmac_update;
240 inst->alg.cra_hash.final = hmac_final;
241 inst->alg.cra_hash.digest = hmac_digest;
242 inst->alg.cra_hash.setkey = hmac_setkey;
244 out_put_alg:
245 crypto_mod_put(alg);
246 return inst;
249 static struct crypto_template hmac_tmpl = {
250 .name = "hmac",
251 .alloc = hmac_alloc,
252 .free = hmac_free,
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");