[ALSA] cmipci: fix version 37 detection
[linux-2.6.git] / crypto / hmac.c
1 /*
2  * Cryptographic API.
3  *
4  * HMAC: Keyed-Hashing for Message Authentication (RFC2104).
5  *
6  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
7  * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
8  *
9  * The HMAC implementation is derived from USAGI.
10  * Copyright (c) 2002 Kazunori Miyazawa <miyazawa@linux-ipv6.org> / USAGI
11  *
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.
16  *
17  */
18
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>
27
28 struct hmac_ctx {
29         struct crypto_hash *child;
30 };
31
32 static inline void *align_ptr(void *p, unsigned int align)
33 {
34         return (void *)ALIGN((unsigned long)p, align);
35 }
36
37 static inline struct hmac_ctx *hmac_ctx(struct crypto_hash *tfm)
38 {
39         return align_ptr(crypto_hash_ctx_aligned(tfm) +
40                          crypto_hash_blocksize(tfm) * 2 +
41                          crypto_hash_digestsize(tfm), sizeof(void *));
42 }
43
44 static int hmac_setkey(struct crypto_hash *parent,
45                        const u8 *inkey, unsigned int keylen)
46 {
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;
55
56         if (keylen > bs) {
57                 struct hash_desc desc;
58                 struct scatterlist tmp;
59                 int err;
60
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);
65
66                 err = crypto_hash_digest(&desc, &tmp, keylen, digest);
67                 if (err)
68                         return err;
69
70                 inkey = digest;
71                 keylen = ds;
72         }
73
74         memcpy(ipad, inkey, keylen);
75         memset(ipad + keylen, 0, bs - keylen);
76         memcpy(opad, ipad, bs);
77
78         for (i = 0; i < bs; i++) {
79                 ipad[i] ^= 0x36;
80                 opad[i] ^= 0x5c;
81         }
82
83         return 0;
84 }
85
86 static int hmac_init(struct hash_desc *pdesc)
87 {
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;
96
97         desc.tfm = ctx->child;
98         desc.flags = pdesc->flags & CRYPTO_TFM_REQ_MAY_SLEEP;
99         sg_set_buf(&tmp, ipad, bs);
100
101         err = crypto_hash_init(&desc);
102         if (unlikely(err))
103                 return err;
104
105         return crypto_hash_update(&desc, &tmp, bs);
106 }
107
108 static int hmac_update(struct hash_desc *pdesc,
109                        struct scatterlist *sg, unsigned int nbytes)
110 {
111         struct hmac_ctx *ctx = hmac_ctx(pdesc->tfm);
112         struct hash_desc desc;
113
114         desc.tfm = ctx->child;
115         desc.flags = pdesc->flags & CRYPTO_TFM_REQ_MAY_SLEEP;
116
117         return crypto_hash_update(&desc, sg, nbytes);
118 }
119
120 static int hmac_final(struct hash_desc *pdesc, u8 *out)
121 {
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;
131
132         desc.tfm = ctx->child;
133         desc.flags = pdesc->flags & CRYPTO_TFM_REQ_MAY_SLEEP;
134         sg_set_buf(&tmp, opad, bs + ds);
135
136         err = crypto_hash_final(&desc, digest);
137         if (unlikely(err))
138                 return err;
139
140         return crypto_hash_digest(&desc, &tmp, bs + ds, out);
141 }
142
143 static int hmac_digest(struct hash_desc *pdesc, struct scatterlist *sg,
144                        unsigned int nbytes, u8 *out)
145 {
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;
157
158         desc.tfm = ctx->child;
159         desc.flags = pdesc->flags & CRYPTO_TFM_REQ_MAY_SLEEP;
160
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);
165
166         err = crypto_hash_digest(&desc, sg1, nbytes + bs, digest);
167         if (unlikely(err))
168                 return err;
169
170         return crypto_hash_digest(&desc, sg2, bs + ds, out);
171 }
172
173 static int hmac_init_tfm(struct crypto_tfm *tfm)
174 {
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));
179
180         hash = crypto_spawn_hash(spawn);
181         if (IS_ERR(hash))
182                 return PTR_ERR(hash);
183
184         ctx->child = hash;
185         return 0;
186 }
187
188 static void hmac_exit_tfm(struct crypto_tfm *tfm)
189 {
190         struct hmac_ctx *ctx = hmac_ctx(__crypto_hash_cast(tfm));
191         crypto_free_hash(ctx->child);
192 }
193
194 static void hmac_free(struct crypto_instance *inst)
195 {
196         crypto_drop_spawn(crypto_instance_ctx(inst));
197         kfree(inst);
198 }
199
200 static struct crypto_instance *hmac_alloc(struct rtattr **tb)
201 {
202         struct crypto_instance *inst;
203         struct crypto_alg *alg;
204         int err;
205
206         err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_HASH);
207         if (err)
208                 return ERR_PTR(err);
209
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));
214
215         inst = crypto_alloc_instance("hmac", alg);
216         if (IS_ERR(inst))
217                 goto out_put_alg;
218
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;
224
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;
229
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 *));
234
235         inst->alg.cra_init = hmac_init_tfm;
236         inst->alg.cra_exit = hmac_exit_tfm;
237
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;
243
244 out_put_alg:
245         crypto_mod_put(alg);
246         return inst;
247 }
248
249 static struct crypto_template hmac_tmpl = {
250         .name = "hmac",
251         .alloc = hmac_alloc,
252         .free = hmac_free,
253         .module = THIS_MODULE,
254 };
255
256 static int __init hmac_module_init(void)
257 {
258         return crypto_register_template(&hmac_tmpl);
259 }
260
261 static void __exit hmac_module_exit(void)
262 {
263         crypto_unregister_template(&hmac_tmpl);
264 }
265
266 module_init(hmac_module_init);
267 module_exit(hmac_module_exit);
268
269 MODULE_LICENSE("GPL");
270 MODULE_DESCRIPTION("HMAC hash algorithm");