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");