drm: Begin an API for in-kernel clients
[linux-2.6-microblaze.git] / crypto / shash.c
1 /*
2  * Synchronous Cryptographic Hash operations.
3  *
4  * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by the Free
8  * Software Foundation; either version 2 of the License, or (at your option)
9  * any later version.
10  *
11  */
12
13 #include <crypto/scatterwalk.h>
14 #include <crypto/internal/hash.h>
15 #include <linux/err.h>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/slab.h>
19 #include <linux/seq_file.h>
20 #include <linux/cryptouser.h>
21 #include <net/netlink.h>
22 #include <linux/compiler.h>
23
24 #include "internal.h"
25
26 static const struct crypto_type crypto_shash_type;
27
28 int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
29                     unsigned int keylen)
30 {
31         return -ENOSYS;
32 }
33 EXPORT_SYMBOL_GPL(shash_no_setkey);
34
35 static int shash_setkey_unaligned(struct crypto_shash *tfm, const u8 *key,
36                                   unsigned int keylen)
37 {
38         struct shash_alg *shash = crypto_shash_alg(tfm);
39         unsigned long alignmask = crypto_shash_alignmask(tfm);
40         unsigned long absize;
41         u8 *buffer, *alignbuffer;
42         int err;
43
44         absize = keylen + (alignmask & ~(crypto_tfm_ctx_alignment() - 1));
45         buffer = kmalloc(absize, GFP_ATOMIC);
46         if (!buffer)
47                 return -ENOMEM;
48
49         alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
50         memcpy(alignbuffer, key, keylen);
51         err = shash->setkey(tfm, alignbuffer, keylen);
52         kzfree(buffer);
53         return err;
54 }
55
56 int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
57                         unsigned int keylen)
58 {
59         struct shash_alg *shash = crypto_shash_alg(tfm);
60         unsigned long alignmask = crypto_shash_alignmask(tfm);
61         int err;
62
63         if ((unsigned long)key & alignmask)
64                 err = shash_setkey_unaligned(tfm, key, keylen);
65         else
66                 err = shash->setkey(tfm, key, keylen);
67
68         if (err)
69                 return err;
70
71         crypto_shash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
72         return 0;
73 }
74 EXPORT_SYMBOL_GPL(crypto_shash_setkey);
75
76 static inline unsigned int shash_align_buffer_size(unsigned len,
77                                                    unsigned long mask)
78 {
79         typedef u8 __aligned_largest u8_aligned;
80         return len + (mask & ~(__alignof__(u8_aligned) - 1));
81 }
82
83 static int shash_update_unaligned(struct shash_desc *desc, const u8 *data,
84                                   unsigned int len)
85 {
86         struct crypto_shash *tfm = desc->tfm;
87         struct shash_alg *shash = crypto_shash_alg(tfm);
88         unsigned long alignmask = crypto_shash_alignmask(tfm);
89         unsigned int unaligned_len = alignmask + 1 -
90                                      ((unsigned long)data & alignmask);
91         u8 ubuf[shash_align_buffer_size(unaligned_len, alignmask)]
92                 __aligned_largest;
93         u8 *buf = PTR_ALIGN(&ubuf[0], alignmask + 1);
94         int err;
95
96         if (unaligned_len > len)
97                 unaligned_len = len;
98
99         memcpy(buf, data, unaligned_len);
100         err = shash->update(desc, buf, unaligned_len);
101         memset(buf, 0, unaligned_len);
102
103         return err ?:
104                shash->update(desc, data + unaligned_len, len - unaligned_len);
105 }
106
107 int crypto_shash_update(struct shash_desc *desc, const u8 *data,
108                         unsigned int len)
109 {
110         struct crypto_shash *tfm = desc->tfm;
111         struct shash_alg *shash = crypto_shash_alg(tfm);
112         unsigned long alignmask = crypto_shash_alignmask(tfm);
113
114         if ((unsigned long)data & alignmask)
115                 return shash_update_unaligned(desc, data, len);
116
117         return shash->update(desc, data, len);
118 }
119 EXPORT_SYMBOL_GPL(crypto_shash_update);
120
121 static int shash_final_unaligned(struct shash_desc *desc, u8 *out)
122 {
123         struct crypto_shash *tfm = desc->tfm;
124         unsigned long alignmask = crypto_shash_alignmask(tfm);
125         struct shash_alg *shash = crypto_shash_alg(tfm);
126         unsigned int ds = crypto_shash_digestsize(tfm);
127         u8 ubuf[shash_align_buffer_size(ds, alignmask)]
128                 __aligned_largest;
129         u8 *buf = PTR_ALIGN(&ubuf[0], alignmask + 1);
130         int err;
131
132         err = shash->final(desc, buf);
133         if (err)
134                 goto out;
135
136         memcpy(out, buf, ds);
137
138 out:
139         memset(buf, 0, ds);
140         return err;
141 }
142
143 int crypto_shash_final(struct shash_desc *desc, u8 *out)
144 {
145         struct crypto_shash *tfm = desc->tfm;
146         struct shash_alg *shash = crypto_shash_alg(tfm);
147         unsigned long alignmask = crypto_shash_alignmask(tfm);
148
149         if ((unsigned long)out & alignmask)
150                 return shash_final_unaligned(desc, out);
151
152         return shash->final(desc, out);
153 }
154 EXPORT_SYMBOL_GPL(crypto_shash_final);
155
156 static int shash_finup_unaligned(struct shash_desc *desc, const u8 *data,
157                                  unsigned int len, u8 *out)
158 {
159         return crypto_shash_update(desc, data, len) ?:
160                crypto_shash_final(desc, out);
161 }
162
163 int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
164                        unsigned int len, u8 *out)
165 {
166         struct crypto_shash *tfm = desc->tfm;
167         struct shash_alg *shash = crypto_shash_alg(tfm);
168         unsigned long alignmask = crypto_shash_alignmask(tfm);
169
170         if (((unsigned long)data | (unsigned long)out) & alignmask)
171                 return shash_finup_unaligned(desc, data, len, out);
172
173         return shash->finup(desc, data, len, out);
174 }
175 EXPORT_SYMBOL_GPL(crypto_shash_finup);
176
177 static int shash_digest_unaligned(struct shash_desc *desc, const u8 *data,
178                                   unsigned int len, u8 *out)
179 {
180         return crypto_shash_init(desc) ?:
181                crypto_shash_finup(desc, data, len, out);
182 }
183
184 int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
185                         unsigned int len, u8 *out)
186 {
187         struct crypto_shash *tfm = desc->tfm;
188         struct shash_alg *shash = crypto_shash_alg(tfm);
189         unsigned long alignmask = crypto_shash_alignmask(tfm);
190
191         if (crypto_shash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
192                 return -ENOKEY;
193
194         if (((unsigned long)data | (unsigned long)out) & alignmask)
195                 return shash_digest_unaligned(desc, data, len, out);
196
197         return shash->digest(desc, data, len, out);
198 }
199 EXPORT_SYMBOL_GPL(crypto_shash_digest);
200
201 static int shash_default_export(struct shash_desc *desc, void *out)
202 {
203         memcpy(out, shash_desc_ctx(desc), crypto_shash_descsize(desc->tfm));
204         return 0;
205 }
206
207 static int shash_default_import(struct shash_desc *desc, const void *in)
208 {
209         memcpy(shash_desc_ctx(desc), in, crypto_shash_descsize(desc->tfm));
210         return 0;
211 }
212
213 static int shash_async_setkey(struct crypto_ahash *tfm, const u8 *key,
214                               unsigned int keylen)
215 {
216         struct crypto_shash **ctx = crypto_ahash_ctx(tfm);
217
218         return crypto_shash_setkey(*ctx, key, keylen);
219 }
220
221 static int shash_async_init(struct ahash_request *req)
222 {
223         struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
224         struct shash_desc *desc = ahash_request_ctx(req);
225
226         desc->tfm = *ctx;
227         desc->flags = req->base.flags;
228
229         return crypto_shash_init(desc);
230 }
231
232 int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc)
233 {
234         struct crypto_hash_walk walk;
235         int nbytes;
236
237         for (nbytes = crypto_hash_walk_first(req, &walk); nbytes > 0;
238              nbytes = crypto_hash_walk_done(&walk, nbytes))
239                 nbytes = crypto_shash_update(desc, walk.data, nbytes);
240
241         return nbytes;
242 }
243 EXPORT_SYMBOL_GPL(shash_ahash_update);
244
245 static int shash_async_update(struct ahash_request *req)
246 {
247         return shash_ahash_update(req, ahash_request_ctx(req));
248 }
249
250 static int shash_async_final(struct ahash_request *req)
251 {
252         return crypto_shash_final(ahash_request_ctx(req), req->result);
253 }
254
255 int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc)
256 {
257         struct crypto_hash_walk walk;
258         int nbytes;
259
260         nbytes = crypto_hash_walk_first(req, &walk);
261         if (!nbytes)
262                 return crypto_shash_final(desc, req->result);
263
264         do {
265                 nbytes = crypto_hash_walk_last(&walk) ?
266                          crypto_shash_finup(desc, walk.data, nbytes,
267                                             req->result) :
268                          crypto_shash_update(desc, walk.data, nbytes);
269                 nbytes = crypto_hash_walk_done(&walk, nbytes);
270         } while (nbytes > 0);
271
272         return nbytes;
273 }
274 EXPORT_SYMBOL_GPL(shash_ahash_finup);
275
276 static int shash_async_finup(struct ahash_request *req)
277 {
278         struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
279         struct shash_desc *desc = ahash_request_ctx(req);
280
281         desc->tfm = *ctx;
282         desc->flags = req->base.flags;
283
284         return shash_ahash_finup(req, desc);
285 }
286
287 int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc)
288 {
289         unsigned int nbytes = req->nbytes;
290         struct scatterlist *sg;
291         unsigned int offset;
292         int err;
293
294         if (nbytes &&
295             (sg = req->src, offset = sg->offset,
296              nbytes < min(sg->length, ((unsigned int)(PAGE_SIZE)) - offset))) {
297                 void *data;
298
299                 data = kmap_atomic(sg_page(sg));
300                 err = crypto_shash_digest(desc, data + offset, nbytes,
301                                           req->result);
302                 kunmap_atomic(data);
303                 crypto_yield(desc->flags);
304         } else
305                 err = crypto_shash_init(desc) ?:
306                       shash_ahash_finup(req, desc);
307
308         return err;
309 }
310 EXPORT_SYMBOL_GPL(shash_ahash_digest);
311
312 static int shash_async_digest(struct ahash_request *req)
313 {
314         struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
315         struct shash_desc *desc = ahash_request_ctx(req);
316
317         desc->tfm = *ctx;
318         desc->flags = req->base.flags;
319
320         return shash_ahash_digest(req, desc);
321 }
322
323 static int shash_async_export(struct ahash_request *req, void *out)
324 {
325         return crypto_shash_export(ahash_request_ctx(req), out);
326 }
327
328 static int shash_async_import(struct ahash_request *req, const void *in)
329 {
330         struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
331         struct shash_desc *desc = ahash_request_ctx(req);
332
333         desc->tfm = *ctx;
334         desc->flags = req->base.flags;
335
336         return crypto_shash_import(desc, in);
337 }
338
339 static void crypto_exit_shash_ops_async(struct crypto_tfm *tfm)
340 {
341         struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
342
343         crypto_free_shash(*ctx);
344 }
345
346 int crypto_init_shash_ops_async(struct crypto_tfm *tfm)
347 {
348         struct crypto_alg *calg = tfm->__crt_alg;
349         struct shash_alg *alg = __crypto_shash_alg(calg);
350         struct crypto_ahash *crt = __crypto_ahash_cast(tfm);
351         struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
352         struct crypto_shash *shash;
353
354         if (!crypto_mod_get(calg))
355                 return -EAGAIN;
356
357         shash = crypto_create_tfm(calg, &crypto_shash_type);
358         if (IS_ERR(shash)) {
359                 crypto_mod_put(calg);
360                 return PTR_ERR(shash);
361         }
362
363         *ctx = shash;
364         tfm->exit = crypto_exit_shash_ops_async;
365
366         crt->init = shash_async_init;
367         crt->update = shash_async_update;
368         crt->final = shash_async_final;
369         crt->finup = shash_async_finup;
370         crt->digest = shash_async_digest;
371         crt->setkey = shash_async_setkey;
372
373         crypto_ahash_set_flags(crt, crypto_shash_get_flags(shash) &
374                                     CRYPTO_TFM_NEED_KEY);
375
376         if (alg->export)
377                 crt->export = shash_async_export;
378         if (alg->import)
379                 crt->import = shash_async_import;
380
381         crt->reqsize = sizeof(struct shash_desc) + crypto_shash_descsize(shash);
382
383         return 0;
384 }
385
386 static int crypto_shash_init_tfm(struct crypto_tfm *tfm)
387 {
388         struct crypto_shash *hash = __crypto_shash_cast(tfm);
389         struct shash_alg *alg = crypto_shash_alg(hash);
390
391         hash->descsize = alg->descsize;
392
393         if (crypto_shash_alg_has_setkey(alg) &&
394             !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
395                 crypto_shash_set_flags(hash, CRYPTO_TFM_NEED_KEY);
396
397         return 0;
398 }
399
400 #ifdef CONFIG_NET
401 static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg)
402 {
403         struct crypto_report_hash rhash;
404         struct shash_alg *salg = __crypto_shash_alg(alg);
405
406         strncpy(rhash.type, "shash", sizeof(rhash.type));
407
408         rhash.blocksize = alg->cra_blocksize;
409         rhash.digestsize = salg->digestsize;
410
411         if (nla_put(skb, CRYPTOCFGA_REPORT_HASH,
412                     sizeof(struct crypto_report_hash), &rhash))
413                 goto nla_put_failure;
414         return 0;
415
416 nla_put_failure:
417         return -EMSGSIZE;
418 }
419 #else
420 static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg)
421 {
422         return -ENOSYS;
423 }
424 #endif
425
426 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
427         __maybe_unused;
428 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
429 {
430         struct shash_alg *salg = __crypto_shash_alg(alg);
431
432         seq_printf(m, "type         : shash\n");
433         seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
434         seq_printf(m, "digestsize   : %u\n", salg->digestsize);
435 }
436
437 static const struct crypto_type crypto_shash_type = {
438         .extsize = crypto_alg_extsize,
439         .init_tfm = crypto_shash_init_tfm,
440 #ifdef CONFIG_PROC_FS
441         .show = crypto_shash_show,
442 #endif
443         .report = crypto_shash_report,
444         .maskclear = ~CRYPTO_ALG_TYPE_MASK,
445         .maskset = CRYPTO_ALG_TYPE_MASK,
446         .type = CRYPTO_ALG_TYPE_SHASH,
447         .tfmsize = offsetof(struct crypto_shash, base),
448 };
449
450 struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
451                                         u32 mask)
452 {
453         return crypto_alloc_tfm(alg_name, &crypto_shash_type, type, mask);
454 }
455 EXPORT_SYMBOL_GPL(crypto_alloc_shash);
456
457 static int shash_prepare_alg(struct shash_alg *alg)
458 {
459         struct crypto_alg *base = &alg->base;
460
461         if (alg->digestsize > PAGE_SIZE / 8 ||
462             alg->descsize > PAGE_SIZE / 8 ||
463             alg->statesize > PAGE_SIZE / 8)
464                 return -EINVAL;
465
466         base->cra_type = &crypto_shash_type;
467         base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
468         base->cra_flags |= CRYPTO_ALG_TYPE_SHASH;
469
470         if (!alg->finup)
471                 alg->finup = shash_finup_unaligned;
472         if (!alg->digest)
473                 alg->digest = shash_digest_unaligned;
474         if (!alg->export) {
475                 alg->export = shash_default_export;
476                 alg->import = shash_default_import;
477                 alg->statesize = alg->descsize;
478         }
479         if (!alg->setkey)
480                 alg->setkey = shash_no_setkey;
481
482         return 0;
483 }
484
485 int crypto_register_shash(struct shash_alg *alg)
486 {
487         struct crypto_alg *base = &alg->base;
488         int err;
489
490         err = shash_prepare_alg(alg);
491         if (err)
492                 return err;
493
494         return crypto_register_alg(base);
495 }
496 EXPORT_SYMBOL_GPL(crypto_register_shash);
497
498 int crypto_unregister_shash(struct shash_alg *alg)
499 {
500         return crypto_unregister_alg(&alg->base);
501 }
502 EXPORT_SYMBOL_GPL(crypto_unregister_shash);
503
504 int crypto_register_shashes(struct shash_alg *algs, int count)
505 {
506         int i, ret;
507
508         for (i = 0; i < count; i++) {
509                 ret = crypto_register_shash(&algs[i]);
510                 if (ret)
511                         goto err;
512         }
513
514         return 0;
515
516 err:
517         for (--i; i >= 0; --i)
518                 crypto_unregister_shash(&algs[i]);
519
520         return ret;
521 }
522 EXPORT_SYMBOL_GPL(crypto_register_shashes);
523
524 int crypto_unregister_shashes(struct shash_alg *algs, int count)
525 {
526         int i, ret;
527
528         for (i = count - 1; i >= 0; --i) {
529                 ret = crypto_unregister_shash(&algs[i]);
530                 if (ret)
531                         pr_err("Failed to unregister %s %s: %d\n",
532                                algs[i].base.cra_driver_name,
533                                algs[i].base.cra_name, ret);
534         }
535
536         return 0;
537 }
538 EXPORT_SYMBOL_GPL(crypto_unregister_shashes);
539
540 int shash_register_instance(struct crypto_template *tmpl,
541                             struct shash_instance *inst)
542 {
543         int err;
544
545         err = shash_prepare_alg(&inst->alg);
546         if (err)
547                 return err;
548
549         return crypto_register_instance(tmpl, shash_crypto_instance(inst));
550 }
551 EXPORT_SYMBOL_GPL(shash_register_instance);
552
553 void shash_free_instance(struct crypto_instance *inst)
554 {
555         crypto_drop_spawn(crypto_instance_ctx(inst));
556         kfree(shash_instance(inst));
557 }
558 EXPORT_SYMBOL_GPL(shash_free_instance);
559
560 int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,
561                             struct shash_alg *alg,
562                             struct crypto_instance *inst)
563 {
564         return crypto_init_spawn2(&spawn->base, &alg->base, inst,
565                                   &crypto_shash_type);
566 }
567 EXPORT_SYMBOL_GPL(crypto_init_shash_spawn);
568
569 struct shash_alg *shash_attr_alg(struct rtattr *rta, u32 type, u32 mask)
570 {
571         struct crypto_alg *alg;
572
573         alg = crypto_attr_alg2(rta, &crypto_shash_type, type, mask);
574         return IS_ERR(alg) ? ERR_CAST(alg) :
575                container_of(alg, struct shash_alg, base);
576 }
577 EXPORT_SYMBOL_GPL(shash_attr_alg);
578
579 MODULE_LICENSE("GPL");
580 MODULE_DESCRIPTION("Synchronous cryptographic hash type");