2 * Synchronous Cryptographic Hash operations.
4 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
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)
13 #include <crypto/internal/hash.h>
14 #include <linux/err.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/seq_file.h>
20 static inline struct crypto_shash *__crypto_shash_cast(struct crypto_tfm *tfm)
22 return container_of(tfm, struct crypto_shash, base);
25 static int shash_setkey_unaligned(struct crypto_shash *tfm, const u8 *key,
28 struct shash_alg *shash = crypto_shash_alg(tfm);
29 unsigned long alignmask = crypto_shash_alignmask(tfm);
31 u8 *buffer, *alignbuffer;
34 absize = keylen + (alignmask & ~(CRYPTO_MINALIGN - 1));
35 buffer = kmalloc(absize, GFP_KERNEL);
39 alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
40 memcpy(alignbuffer, key, keylen);
41 err = shash->setkey(tfm, alignbuffer, keylen);
42 memset(alignbuffer, 0, keylen);
47 int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
50 struct shash_alg *shash = crypto_shash_alg(tfm);
51 unsigned long alignmask = crypto_shash_alignmask(tfm);
53 if ((unsigned long)key & alignmask)
54 return shash_setkey_unaligned(tfm, key, keylen);
56 return shash->setkey(tfm, key, keylen);
58 EXPORT_SYMBOL_GPL(crypto_shash_setkey);
60 static inline unsigned int shash_align_buffer_size(unsigned len,
63 return len + (mask & ~(__alignof__(u8 __attribute__ ((aligned))) - 1));
66 static int shash_update_unaligned(struct shash_desc *desc, const u8 *data,
69 struct crypto_shash *tfm = desc->tfm;
70 struct shash_alg *shash = crypto_shash_alg(tfm);
71 unsigned long alignmask = crypto_shash_alignmask(tfm);
72 unsigned int unaligned_len = alignmask + 1 -
73 ((unsigned long)data & alignmask);
74 u8 buf[shash_align_buffer_size(unaligned_len, alignmask)]
75 __attribute__ ((aligned));
77 memcpy(buf, data, unaligned_len);
79 return shash->update(desc, buf, unaligned_len) ?:
80 shash->update(desc, data + unaligned_len, len - unaligned_len);
83 int crypto_shash_update(struct shash_desc *desc, const u8 *data,
86 struct crypto_shash *tfm = desc->tfm;
87 struct shash_alg *shash = crypto_shash_alg(tfm);
88 unsigned long alignmask = crypto_shash_alignmask(tfm);
90 if ((unsigned long)data & alignmask)
91 return shash_update_unaligned(desc, data, len);
93 return shash->update(desc, data, len);
95 EXPORT_SYMBOL_GPL(crypto_shash_update);
97 static int shash_final_unaligned(struct shash_desc *desc, u8 *out)
99 struct crypto_shash *tfm = desc->tfm;
100 unsigned long alignmask = crypto_shash_alignmask(tfm);
101 struct shash_alg *shash = crypto_shash_alg(tfm);
102 unsigned int ds = crypto_shash_digestsize(tfm);
103 u8 buf[shash_align_buffer_size(ds, alignmask)]
104 __attribute__ ((aligned));
107 err = shash->final(desc, buf);
108 memcpy(out, buf, ds);
112 int crypto_shash_final(struct shash_desc *desc, u8 *out)
114 struct crypto_shash *tfm = desc->tfm;
115 struct shash_alg *shash = crypto_shash_alg(tfm);
116 unsigned long alignmask = crypto_shash_alignmask(tfm);
118 if ((unsigned long)out & alignmask)
119 return shash_final_unaligned(desc, out);
121 return shash->final(desc, out);
123 EXPORT_SYMBOL_GPL(crypto_shash_final);
125 static int shash_finup_unaligned(struct shash_desc *desc, const u8 *data,
126 unsigned int len, u8 *out)
128 return crypto_shash_update(desc, data, len) ?:
129 crypto_shash_final(desc, out);
132 int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
133 unsigned int len, u8 *out)
135 struct crypto_shash *tfm = desc->tfm;
136 struct shash_alg *shash = crypto_shash_alg(tfm);
137 unsigned long alignmask = crypto_shash_alignmask(tfm);
139 if (((unsigned long)data | (unsigned long)out) & alignmask ||
141 return shash_finup_unaligned(desc, data, len, out);
143 return shash->finup(desc, data, len, out);
145 EXPORT_SYMBOL_GPL(crypto_shash_finup);
147 static int shash_digest_unaligned(struct shash_desc *desc, const u8 *data,
148 unsigned int len, u8 *out)
150 return crypto_shash_init(desc) ?:
151 crypto_shash_update(desc, data, len) ?:
152 crypto_shash_final(desc, out);
155 int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
156 unsigned int len, u8 *out)
158 struct crypto_shash *tfm = desc->tfm;
159 struct shash_alg *shash = crypto_shash_alg(tfm);
160 unsigned long alignmask = crypto_shash_alignmask(tfm);
162 if (((unsigned long)data | (unsigned long)out) & alignmask ||
164 return shash_digest_unaligned(desc, data, len, out);
166 return shash->digest(desc, data, len, out);
168 EXPORT_SYMBOL_GPL(crypto_shash_digest);
170 static int crypto_shash_init_tfm(struct crypto_tfm *tfm,
171 const struct crypto_type *frontend)
173 if (frontend->type != CRYPTO_ALG_TYPE_SHASH)
178 static unsigned int crypto_shash_extsize(struct crypto_alg *alg,
179 const struct crypto_type *frontend)
181 return alg->cra_ctxsize;
184 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
185 __attribute__ ((unused));
186 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
188 struct shash_alg *salg = __crypto_shash_alg(alg);
190 seq_printf(m, "type : shash\n");
191 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
192 seq_printf(m, "digestsize : %u\n", salg->digestsize);
193 seq_printf(m, "descsize : %u\n", salg->descsize);
196 static const struct crypto_type crypto_shash_type = {
197 .extsize = crypto_shash_extsize,
198 .init_tfm = crypto_shash_init_tfm,
199 #ifdef CONFIG_PROC_FS
200 .show = crypto_shash_show,
202 .maskclear = ~CRYPTO_ALG_TYPE_MASK,
203 .maskset = CRYPTO_ALG_TYPE_MASK,
204 .type = CRYPTO_ALG_TYPE_SHASH,
205 .tfmsize = offsetof(struct crypto_shash, base),
208 struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
211 return __crypto_shash_cast(
212 crypto_alloc_tfm(alg_name, &crypto_shash_type, type, mask));
214 EXPORT_SYMBOL_GPL(crypto_alloc_shash);
216 int crypto_register_shash(struct shash_alg *alg)
218 struct crypto_alg *base = &alg->base;
220 if (alg->digestsize > PAGE_SIZE / 8 ||
221 alg->descsize > PAGE_SIZE / 8)
224 base->cra_type = &crypto_shash_type;
225 base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
226 base->cra_flags |= CRYPTO_ALG_TYPE_SHASH;
228 return crypto_register_alg(base);
230 EXPORT_SYMBOL_GPL(crypto_register_shash);
232 int crypto_unregister_shash(struct shash_alg *alg)
234 return crypto_unregister_alg(&alg->base);
236 EXPORT_SYMBOL_GPL(crypto_unregister_shash);
238 MODULE_LICENSE("GPL");
239 MODULE_DESCRIPTION("Synchronous cryptographic hash type");