]>
Commit | Line | Data |
---|---|---|
2b0b3689 MT |
1 | Merge master.kernel.org:/pub/scm/linux/kernel/git/herbert/crypto-2.6 |
2 | ||
3 | * master.kernel.org:/pub/scm/linux/kernel/git/herbert/crypto-2.6: | |
4 | [CRYPTO] aes: Fixed array boundary violation | |
5 | [CRYPTO] tcrypt: Fix key alignment | |
6 | [CRYPTO] all: Add missing cra_alignmask | |
7 | [CRYPTO] all: Use kzalloc where possible | |
8 | [CRYPTO] api: Align tfm context as wide as possible | |
9 | [CRYPTO] twofish: Use rol32/ror32 where appropriate | |
10 | ||
11 | Index: linux-2.6.16.50/arch/x86_64/crypto/aes.c | |
12 | =================================================================== | |
13 | --- linux-2.6.16.50.orig/arch/x86_64/crypto/aes.c 2006-07-14 18:09:26.335435750 +1200 | |
14 | +++ linux-2.6.16.50/arch/x86_64/crypto/aes.c 2006-07-14 18:10:31.083482250 +1200 | |
15 | @@ -77,12 +77,11 @@ | |
16 | struct aes_ctx | |
17 | { | |
18 | u32 key_length; | |
19 | - u32 E[60]; | |
20 | - u32 D[60]; | |
21 | + u32 buf[120]; | |
22 | }; | |
23 | ||
24 | -#define E_KEY ctx->E | |
25 | -#define D_KEY ctx->D | |
26 | +#define E_KEY (&ctx->buf[0]) | |
27 | +#define D_KEY (&ctx->buf[60]) | |
28 | ||
29 | static u8 pow_tab[256] __initdata; | |
30 | static u8 log_tab[256] __initdata; | |
31 | @@ -228,10 +227,10 @@ | |
32 | t ^= E_KEY[8 * i + 7]; E_KEY[8 * i + 15] = t; \ | |
33 | } | |
34 | ||
35 | -static int aes_set_key(void *ctx_arg, const u8 *in_key, unsigned int key_len, | |
36 | - u32 *flags) | |
37 | +static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key, | |
38 | + unsigned int key_len, u32 *flags) | |
39 | { | |
40 | - struct aes_ctx *ctx = ctx_arg; | |
41 | + struct aes_ctx *ctx = crypto_tfm_ctx(tfm); | |
42 | const __le32 *key = (const __le32 *)in_key; | |
43 | u32 i, j, t, u, v, w; | |
44 | ||
45 | @@ -284,8 +283,18 @@ | |
46 | return 0; | |
47 | } | |
48 | ||
49 | -extern void aes_encrypt(void *ctx_arg, u8 *out, const u8 *in); | |
50 | -extern void aes_decrypt(void *ctx_arg, u8 *out, const u8 *in); | |
51 | +asmlinkage void aes_enc_blk(struct crypto_tfm *tfm, u8 *out, const u8 *in); | |
52 | +asmlinkage void aes_dec_blk(struct crypto_tfm *tfm, u8 *out, const u8 *in); | |
53 | + | |
54 | +static void aes_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
55 | +{ | |
56 | + aes_enc_blk(tfm, dst, src); | |
57 | +} | |
58 | + | |
59 | +static void aes_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
60 | +{ | |
61 | + aes_dec_blk(tfm, dst, src); | |
62 | +} | |
63 | ||
64 | static struct crypto_alg aes_alg = { | |
65 | .cra_name = "aes", | |
66 | Index: linux-2.6.16.50/crypto/aes.c | |
67 | =================================================================== | |
68 | --- linux-2.6.16.50.orig/crypto/aes.c 2006-07-14 18:09:26.351436750 +1200 | |
69 | +++ linux-2.6.16.50/crypto/aes.c 2006-07-14 18:10:31.087482500 +1200 | |
70 | @@ -75,12 +75,11 @@ | |
71 | ||
72 | struct aes_ctx { | |
73 | int key_length; | |
74 | - u32 E[60]; | |
75 | - u32 D[60]; | |
76 | + u32 buf[120]; | |
77 | }; | |
78 | ||
79 | -#define E_KEY ctx->E | |
80 | -#define D_KEY ctx->D | |
81 | +#define E_KEY (&ctx->buf[0]) | |
82 | +#define D_KEY (&ctx->buf[60]) | |
83 | ||
84 | static u8 pow_tab[256] __initdata; | |
85 | static u8 log_tab[256] __initdata; | |
86 | @@ -249,10 +248,10 @@ | |
87 | t ^= E_KEY[8 * i + 7]; E_KEY[8 * i + 15] = t; \ | |
88 | } | |
89 | ||
90 | -static int | |
91 | -aes_set_key(void *ctx_arg, const u8 *in_key, unsigned int key_len, u32 *flags) | |
92 | +static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key, | |
93 | + unsigned int key_len, u32 *flags) | |
94 | { | |
95 | - struct aes_ctx *ctx = ctx_arg; | |
96 | + struct aes_ctx *ctx = crypto_tfm_ctx(tfm); | |
97 | const __le32 *key = (const __le32 *)in_key; | |
98 | u32 i, t, u, v, w; | |
99 | ||
100 | @@ -319,9 +318,9 @@ | |
101 | f_rl(bo, bi, 2, k); \ | |
102 | f_rl(bo, bi, 3, k) | |
103 | ||
104 | -static void aes_encrypt(void *ctx_arg, u8 *out, const u8 *in) | |
105 | +static void aes_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) | |
106 | { | |
107 | - const struct aes_ctx *ctx = ctx_arg; | |
108 | + const struct aes_ctx *ctx = crypto_tfm_ctx(tfm); | |
109 | const __le32 *src = (const __le32 *)in; | |
110 | __le32 *dst = (__le32 *)out; | |
111 | u32 b0[4], b1[4]; | |
112 | @@ -374,9 +373,9 @@ | |
113 | i_rl(bo, bi, 2, k); \ | |
114 | i_rl(bo, bi, 3, k) | |
115 | ||
116 | -static void aes_decrypt(void *ctx_arg, u8 *out, const u8 *in) | |
117 | +static void aes_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) | |
118 | { | |
119 | - const struct aes_ctx *ctx = ctx_arg; | |
120 | + const struct aes_ctx *ctx = crypto_tfm_ctx(tfm); | |
121 | const __le32 *src = (const __le32 *)in; | |
122 | __le32 *dst = (__le32 *)out; | |
123 | u32 b0[4], b1[4]; | |
124 | Index: linux-2.6.16.50/crypto/api.c | |
125 | =================================================================== | |
126 | --- linux-2.6.16.50.orig/crypto/api.c 2006-07-14 18:09:26.351436750 +1200 | |
127 | +++ linux-2.6.16.50/crypto/api.c 2006-07-14 18:10:31.091482750 +1200 | |
128 | @@ -165,7 +165,7 @@ | |
129 | break; | |
130 | } | |
131 | ||
132 | - return len + alg->cra_alignmask; | |
133 | + return len + (alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1)); | |
134 | } | |
135 | ||
136 | struct crypto_tfm *crypto_alloc_tfm(const char *name, u32 flags) | |
137 | @@ -179,24 +179,25 @@ | |
138 | goto out; | |
139 | ||
140 | tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, flags); | |
141 | - tfm = kmalloc(tfm_size, GFP_KERNEL); | |
142 | + tfm = kzalloc(tfm_size, GFP_KERNEL); | |
143 | if (tfm == NULL) | |
144 | goto out_put; | |
145 | ||
146 | - memset(tfm, 0, tfm_size); | |
147 | - | |
148 | tfm->__crt_alg = alg; | |
149 | ||
150 | if (crypto_init_flags(tfm, flags)) | |
151 | goto out_free_tfm; | |
152 | ||
153 | - if (crypto_init_ops(tfm)) { | |
154 | - crypto_exit_ops(tfm); | |
155 | + if (crypto_init_ops(tfm)) | |
156 | goto out_free_tfm; | |
157 | - } | |
158 | + | |
159 | + if (alg->cra_init && alg->cra_init(tfm)) | |
160 | + goto cra_init_failed; | |
161 | ||
162 | goto out; | |
163 | ||
164 | +cra_init_failed: | |
165 | + crypto_exit_ops(tfm); | |
166 | out_free_tfm: | |
167 | kfree(tfm); | |
168 | tfm = NULL; | |
169 | @@ -217,6 +218,8 @@ | |
170 | alg = tfm->__crt_alg; | |
171 | size = sizeof(*tfm) + alg->cra_ctxsize; | |
172 | ||
173 | + if (alg->cra_exit) | |
174 | + alg->cra_exit(tfm); | |
175 | crypto_exit_ops(tfm); | |
176 | crypto_alg_put(alg); | |
177 | memset(tfm, 0, size); | |
178 | @@ -226,7 +229,7 @@ | |
179 | static inline int crypto_set_driver_name(struct crypto_alg *alg) | |
180 | { | |
181 | static const char suffix[] = "-generic"; | |
182 | - char *driver_name = (char *)alg->cra_driver_name; | |
183 | + char *driver_name = alg->cra_driver_name; | |
184 | int len; | |
185 | ||
186 | if (*driver_name) | |
187 | @@ -264,13 +267,13 @@ | |
188 | down_write(&crypto_alg_sem); | |
189 | ||
190 | list_for_each_entry(q, &crypto_alg_list, cra_list) { | |
191 | - if (!strcmp(q->cra_driver_name, alg->cra_driver_name)) { | |
192 | + if (q == alg) { | |
193 | ret = -EEXIST; | |
194 | goto out; | |
195 | } | |
196 | } | |
197 | ||
198 | - list_add_tail(&alg->cra_list, &crypto_alg_list); | |
199 | + list_add(&alg->cra_list, &crypto_alg_list); | |
200 | out: | |
201 | up_write(&crypto_alg_sem); | |
202 | return ret; | |
203 | Index: linux-2.6.16.50/crypto/deflate.c | |
204 | =================================================================== | |
205 | --- linux-2.6.16.50.orig/crypto/deflate.c 2006-07-14 18:09:26.351436750 +1200 | |
206 | +++ linux-2.6.16.50/crypto/deflate.c 2006-07-14 18:10:31.091482750 +1200 | |
207 | @@ -73,12 +73,11 @@ | |
208 | int ret = 0; | |
209 | struct z_stream_s *stream = &ctx->decomp_stream; | |
210 | ||
211 | - stream->workspace = kmalloc(zlib_inflate_workspacesize(), GFP_KERNEL); | |
212 | + stream->workspace = kzalloc(zlib_inflate_workspacesize(), GFP_KERNEL); | |
213 | if (!stream->workspace ) { | |
214 | ret = -ENOMEM; | |
215 | goto out; | |
216 | } | |
217 | - memset(stream->workspace, 0, zlib_inflate_workspacesize()); | |
218 | ret = zlib_inflateInit2(stream, -DEFLATE_DEF_WINBITS); | |
219 | if (ret != Z_OK) { | |
220 | ret = -EINVAL; | |
221 | @@ -103,8 +102,9 @@ | |
222 | kfree(ctx->decomp_stream.workspace); | |
223 | } | |
224 | ||
225 | -static int deflate_init(void *ctx) | |
226 | +static int deflate_init(struct crypto_tfm *tfm) | |
227 | { | |
228 | + struct deflate_ctx *ctx = crypto_tfm_ctx(tfm); | |
229 | int ret; | |
230 | ||
231 | ret = deflate_comp_init(ctx); | |
232 | @@ -117,17 +117,19 @@ | |
233 | return ret; | |
234 | } | |
235 | ||
236 | -static void deflate_exit(void *ctx) | |
237 | +static void deflate_exit(struct crypto_tfm *tfm) | |
238 | { | |
239 | + struct deflate_ctx *ctx = crypto_tfm_ctx(tfm); | |
240 | + | |
241 | deflate_comp_exit(ctx); | |
242 | deflate_decomp_exit(ctx); | |
243 | } | |
244 | ||
245 | -static int deflate_compress(void *ctx, const u8 *src, unsigned int slen, | |
246 | - u8 *dst, unsigned int *dlen) | |
247 | +static int deflate_compress(struct crypto_tfm *tfm, const u8 *src, | |
248 | + unsigned int slen, u8 *dst, unsigned int *dlen) | |
249 | { | |
250 | int ret = 0; | |
251 | - struct deflate_ctx *dctx = ctx; | |
252 | + struct deflate_ctx *dctx = crypto_tfm_ctx(tfm); | |
253 | struct z_stream_s *stream = &dctx->comp_stream; | |
254 | ||
255 | ret = zlib_deflateReset(stream); | |
256 | @@ -152,12 +154,12 @@ | |
257 | return ret; | |
258 | } | |
259 | ||
260 | -static int deflate_decompress(void *ctx, const u8 *src, unsigned int slen, | |
261 | - u8 *dst, unsigned int *dlen) | |
262 | +static int deflate_decompress(struct crypto_tfm *tfm, const u8 *src, | |
263 | + unsigned int slen, u8 *dst, unsigned int *dlen) | |
264 | { | |
265 | ||
266 | int ret = 0; | |
267 | - struct deflate_ctx *dctx = ctx; | |
268 | + struct deflate_ctx *dctx = crypto_tfm_ctx(tfm); | |
269 | struct z_stream_s *stream = &dctx->decomp_stream; | |
270 | ||
271 | ret = zlib_inflateReset(stream); | |
272 | @@ -199,9 +201,9 @@ | |
273 | .cra_ctxsize = sizeof(struct deflate_ctx), | |
274 | .cra_module = THIS_MODULE, | |
275 | .cra_list = LIST_HEAD_INIT(alg.cra_list), | |
276 | + .cra_init = deflate_init, | |
277 | + .cra_exit = deflate_exit, | |
278 | .cra_u = { .compress = { | |
279 | - .coa_init = deflate_init, | |
280 | - .coa_exit = deflate_exit, | |
281 | .coa_compress = deflate_compress, | |
282 | .coa_decompress = deflate_decompress } } | |
283 | }; | |
284 | Index: linux-2.6.16.50/crypto/des.c | |
285 | =================================================================== | |
286 | --- linux-2.6.16.50.orig/crypto/des.c 2006-07-14 18:09:26.355437000 +1200 | |
287 | +++ linux-2.6.16.50/crypto/des.c 2006-07-14 18:10:31.099483250 +1200 | |
288 | @@ -783,9 +783,10 @@ | |
289 | } | |
290 | } | |
291 | ||
292 | -static int des_setkey(void *ctx, const u8 *key, unsigned int keylen, u32 *flags) | |
293 | +static int des_setkey(struct crypto_tfm *tfm, const u8 *key, | |
294 | + unsigned int keylen, u32 *flags) | |
295 | { | |
296 | - struct des_ctx *dctx = ctx; | |
297 | + struct des_ctx *dctx = crypto_tfm_ctx(tfm); | |
298 | u32 tmp[DES_EXPKEY_WORDS]; | |
299 | int ret; | |
300 | ||
301 | @@ -803,9 +804,10 @@ | |
302 | return 0; | |
303 | } | |
304 | ||
305 | -static void des_encrypt(void *ctx, u8 *dst, const u8 *src) | |
306 | +static void des_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
307 | { | |
308 | - const u32 *K = ((struct des_ctx *)ctx)->expkey; | |
309 | + struct des_ctx *ctx = crypto_tfm_ctx(tfm); | |
310 | + const u32 *K = ctx->expkey; | |
311 | const __le32 *s = (const __le32 *)src; | |
312 | __le32 *d = (__le32 *)dst; | |
313 | u32 L, R, A, B; | |
314 | @@ -825,9 +827,10 @@ | |
315 | d[1] = cpu_to_le32(L); | |
316 | } | |
317 | ||
318 | -static void des_decrypt(void *ctx, u8 *dst, const u8 *src) | |
319 | +static void des_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
320 | { | |
321 | - const u32 *K = ((struct des_ctx *)ctx)->expkey + DES_EXPKEY_WORDS - 2; | |
322 | + struct des_ctx *ctx = crypto_tfm_ctx(tfm); | |
323 | + const u32 *K = ctx->expkey + DES_EXPKEY_WORDS - 2; | |
324 | const __le32 *s = (const __le32 *)src; | |
325 | __le32 *d = (__le32 *)dst; | |
326 | u32 L, R, A, B; | |
327 | @@ -860,11 +863,11 @@ | |
328 | * property. | |
329 | * | |
330 | */ | |
331 | -static int des3_ede_setkey(void *ctx, const u8 *key, | |
332 | +static int des3_ede_setkey(struct crypto_tfm *tfm, const u8 *key, | |
333 | unsigned int keylen, u32 *flags) | |
334 | { | |
335 | const u32 *K = (const u32 *)key; | |
336 | - struct des3_ede_ctx *dctx = ctx; | |
337 | + struct des3_ede_ctx *dctx = crypto_tfm_ctx(tfm); | |
338 | u32 *expkey = dctx->expkey; | |
339 | ||
340 | if (unlikely(!((K[0] ^ K[2]) | (K[1] ^ K[3])) || | |
341 | @@ -881,9 +884,9 @@ | |
342 | return 0; | |
343 | } | |
344 | ||
345 | -static void des3_ede_encrypt(void *ctx, u8 *dst, const u8 *src) | |
346 | +static void des3_ede_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
347 | { | |
348 | - struct des3_ede_ctx *dctx = ctx; | |
349 | + struct des3_ede_ctx *dctx = crypto_tfm_ctx(tfm); | |
350 | const u32 *K = dctx->expkey; | |
351 | const __le32 *s = (const __le32 *)src; | |
352 | __le32 *d = (__le32 *)dst; | |
353 | @@ -912,9 +915,9 @@ | |
354 | d[1] = cpu_to_le32(L); | |
355 | } | |
356 | ||
357 | -static void des3_ede_decrypt(void *ctx, u8 *dst, const u8 *src) | |
358 | +static void des3_ede_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
359 | { | |
360 | - struct des3_ede_ctx *dctx = ctx; | |
361 | + struct des3_ede_ctx *dctx = crypto_tfm_ctx(tfm); | |
362 | const u32 *K = dctx->expkey + DES3_EDE_EXPKEY_WORDS - 2; | |
363 | const __le32 *s = (const __le32 *)src; | |
364 | __le32 *d = (__le32 *)dst; | |
365 | @@ -965,6 +968,7 @@ | |
366 | .cra_blocksize = DES3_EDE_BLOCK_SIZE, | |
367 | .cra_ctxsize = sizeof(struct des3_ede_ctx), | |
368 | .cra_module = THIS_MODULE, | |
369 | + .cra_alignmask = 3, | |
370 | .cra_list = LIST_HEAD_INIT(des3_ede_alg.cra_list), | |
371 | .cra_u = { .cipher = { | |
372 | .cia_min_keysize = DES3_EDE_KEY_SIZE, | |
373 | Index: linux-2.6.16.50/crypto/serpent.c | |
374 | =================================================================== | |
375 | --- linux-2.6.16.50.orig/crypto/serpent.c 2006-07-14 18:09:26.355437000 +1200 | |
376 | +++ linux-2.6.16.50/crypto/serpent.c 2006-07-14 18:10:31.103483500 +1200 | |
377 | @@ -215,9 +215,11 @@ | |
378 | }; | |
379 | ||
380 | ||
381 | -static int serpent_setkey(void *ctx, const u8 *key, unsigned int keylen, u32 *flags) | |
382 | +static int serpent_setkey(struct crypto_tfm *tfm, const u8 *key, | |
383 | + unsigned int keylen, u32 *flags) | |
384 | { | |
385 | - u32 *k = ((struct serpent_ctx *)ctx)->expkey; | |
386 | + struct serpent_ctx *ctx = crypto_tfm_ctx(tfm); | |
387 | + u32 *k = ctx->expkey; | |
388 | u8 *k8 = (u8 *)k; | |
389 | u32 r0,r1,r2,r3,r4; | |
390 | int i; | |
391 | @@ -365,10 +367,11 @@ | |
392 | return 0; | |
393 | } | |
394 | ||
395 | -static void serpent_encrypt(void *ctx, u8 *dst, const u8 *src) | |
396 | +static void serpent_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
397 | { | |
398 | + struct serpent_ctx *ctx = crypto_tfm_ctx(tfm); | |
399 | const u32 | |
400 | - *k = ((struct serpent_ctx *)ctx)->expkey, | |
401 | + *k = ctx->expkey, | |
402 | *s = (const u32 *)src; | |
403 | u32 *d = (u32 *)dst, | |
404 | r0, r1, r2, r3, r4; | |
405 | @@ -423,8 +426,9 @@ | |
406 | d[3] = cpu_to_le32(r3); | |
407 | } | |
408 | ||
409 | -static void serpent_decrypt(void *ctx, u8 *dst, const u8 *src) | |
410 | +static void serpent_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
411 | { | |
412 | + struct serpent_ctx *ctx = crypto_tfm_ctx(tfm); | |
413 | const u32 | |
414 | *k = ((struct serpent_ctx *)ctx)->expkey, | |
415 | *s = (const u32 *)src; | |
416 | @@ -481,6 +485,7 @@ | |
417 | .cra_flags = CRYPTO_ALG_TYPE_CIPHER, | |
418 | .cra_blocksize = SERPENT_BLOCK_SIZE, | |
419 | .cra_ctxsize = sizeof(struct serpent_ctx), | |
420 | + .cra_alignmask = 3, | |
421 | .cra_module = THIS_MODULE, | |
422 | .cra_list = LIST_HEAD_INIT(serpent_alg.cra_list), | |
423 | .cra_u = { .cipher = { | |
424 | @@ -491,7 +496,8 @@ | |
425 | .cia_decrypt = serpent_decrypt } } | |
426 | }; | |
427 | ||
428 | -static int tnepres_setkey(void *ctx, const u8 *key, unsigned int keylen, u32 *flags) | |
429 | +static int tnepres_setkey(struct crypto_tfm *tfm, const u8 *key, | |
430 | + unsigned int keylen, u32 *flags) | |
431 | { | |
432 | u8 rev_key[SERPENT_MAX_KEY_SIZE]; | |
433 | int i; | |
434 | @@ -505,10 +511,10 @@ | |
435 | for (i = 0; i < keylen; ++i) | |
436 | rev_key[keylen - i - 1] = key[i]; | |
437 | ||
438 | - return serpent_setkey(ctx, rev_key, keylen, flags); | |
439 | + return serpent_setkey(tfm, rev_key, keylen, flags); | |
440 | } | |
441 | ||
442 | -static void tnepres_encrypt(void *ctx, u8 *dst, const u8 *src) | |
443 | +static void tnepres_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
444 | { | |
445 | const u32 * const s = (const u32 * const)src; | |
446 | u32 * const d = (u32 * const)dst; | |
447 | @@ -520,7 +526,7 @@ | |
448 | rs[2] = swab32(s[1]); | |
449 | rs[3] = swab32(s[0]); | |
450 | ||
451 | - serpent_encrypt(ctx, (u8 *)rd, (u8 *)rs); | |
452 | + serpent_encrypt(tfm, (u8 *)rd, (u8 *)rs); | |
453 | ||
454 | d[0] = swab32(rd[3]); | |
455 | d[1] = swab32(rd[2]); | |
456 | @@ -528,7 +534,7 @@ | |
457 | d[3] = swab32(rd[0]); | |
458 | } | |
459 | ||
460 | -static void tnepres_decrypt(void *ctx, u8 *dst, const u8 *src) | |
461 | +static void tnepres_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
462 | { | |
463 | const u32 * const s = (const u32 * const)src; | |
464 | u32 * const d = (u32 * const)dst; | |
465 | @@ -540,7 +546,7 @@ | |
466 | rs[2] = swab32(s[1]); | |
467 | rs[3] = swab32(s[0]); | |
468 | ||
469 | - serpent_decrypt(ctx, (u8 *)rd, (u8 *)rs); | |
470 | + serpent_decrypt(tfm, (u8 *)rd, (u8 *)rs); | |
471 | ||
472 | d[0] = swab32(rd[3]); | |
473 | d[1] = swab32(rd[2]); | |
474 | Index: linux-2.6.16.50/crypto/tcrypt.h | |
475 | =================================================================== | |
476 | --- linux-2.6.16.50.orig/crypto/tcrypt.h 2006-07-14 18:09:26.355437000 +1200 | |
477 | +++ linux-2.6.16.50/crypto/tcrypt.h 2006-07-14 18:10:31.111484000 +1200 | |
478 | @@ -26,37 +26,38 @@ | |
479 | #define MAX_IVLEN 32 | |
480 | ||
481 | struct hash_testvec { | |
482 | + /* only used with keyed hash algorithms */ | |
483 | + char key[128] __attribute__ ((__aligned__(4))); | |
484 | char plaintext[128]; | |
485 | - unsigned char psize; | |
486 | char digest[MAX_DIGEST_SIZE]; | |
487 | - unsigned char np; | |
488 | unsigned char tap[MAX_TAP]; | |
489 | - char key[128]; /* only used with keyed hash algorithms */ | |
490 | + unsigned char psize; | |
491 | + unsigned char np; | |
492 | unsigned char ksize; | |
493 | }; | |
494 | ||
495 | struct hmac_testvec { | |
496 | char key[128]; | |
497 | - unsigned char ksize; | |
498 | char plaintext[128]; | |
499 | - unsigned char psize; | |
500 | char digest[MAX_DIGEST_SIZE]; | |
501 | - unsigned char np; | |
502 | unsigned char tap[MAX_TAP]; | |
503 | + unsigned char ksize; | |
504 | + unsigned char psize; | |
505 | + unsigned char np; | |
506 | }; | |
507 | ||
508 | struct cipher_testvec { | |
509 | + char key[MAX_KEYLEN] __attribute__ ((__aligned__(4))); | |
510 | + char iv[MAX_IVLEN]; | |
511 | + char input[48]; | |
512 | + char result[48]; | |
513 | + unsigned char tap[MAX_TAP]; | |
514 | + int np; | |
515 | unsigned char fail; | |
516 | unsigned char wk; /* weak key flag */ | |
517 | - char key[MAX_KEYLEN]; | |
518 | unsigned char klen; | |
519 | - char iv[MAX_IVLEN]; | |
520 | - char input[48]; | |
521 | unsigned char ilen; | |
522 | - char result[48]; | |
523 | unsigned char rlen; | |
524 | - int np; | |
525 | - unsigned char tap[MAX_TAP]; | |
526 | }; | |
527 | ||
528 | struct cipher_speed { | |
529 | @@ -64,6 +65,11 @@ | |
530 | unsigned int blen; | |
531 | }; | |
532 | ||
533 | +struct digest_speed { | |
534 | + unsigned int blen; /* buffer length */ | |
535 | + unsigned int plen; /* per-update length */ | |
536 | +}; | |
537 | + | |
538 | /* | |
539 | * MD4 test vectors from RFC1320 | |
540 | */ | |
541 | @@ -2974,4 +2980,35 @@ | |
542 | { .klen = 0, .blen = 0, } | |
543 | }; | |
544 | ||
545 | +/* | |
546 | + * Digest speed tests | |
547 | + */ | |
548 | +static struct digest_speed generic_digest_speed_template[] = { | |
549 | + { .blen = 16, .plen = 16, }, | |
550 | + { .blen = 64, .plen = 16, }, | |
551 | + { .blen = 64, .plen = 64, }, | |
552 | + { .blen = 256, .plen = 16, }, | |
553 | + { .blen = 256, .plen = 64, }, | |
554 | + { .blen = 256, .plen = 256, }, | |
555 | + { .blen = 1024, .plen = 16, }, | |
556 | + { .blen = 1024, .plen = 256, }, | |
557 | + { .blen = 1024, .plen = 1024, }, | |
558 | + { .blen = 2048, .plen = 16, }, | |
559 | + { .blen = 2048, .plen = 256, }, | |
560 | + { .blen = 2048, .plen = 1024, }, | |
561 | + { .blen = 2048, .plen = 2048, }, | |
562 | + { .blen = 4096, .plen = 16, }, | |
563 | + { .blen = 4096, .plen = 256, }, | |
564 | + { .blen = 4096, .plen = 1024, }, | |
565 | + { .blen = 4096, .plen = 4096, }, | |
566 | + { .blen = 8192, .plen = 16, }, | |
567 | + { .blen = 8192, .plen = 256, }, | |
568 | + { .blen = 8192, .plen = 1024, }, | |
569 | + { .blen = 8192, .plen = 4096, }, | |
570 | + { .blen = 8192, .plen = 8192, }, | |
571 | + | |
572 | + /* End marker */ | |
573 | + { .blen = 0, .plen = 0, } | |
574 | +}; | |
575 | + | |
576 | #endif /* _CRYPTO_TCRYPT_H */ | |
577 | Index: linux-2.6.16.50/crypto/twofish.c | |
578 | =================================================================== | |
579 | --- linux-2.6.16.50.orig/crypto/twofish.c 2006-07-14 18:09:26.359437250 +1200 | |
580 | +++ linux-2.6.16.50/crypto/twofish.c 2006-07-14 18:10:31.119484500 +1200 | |
581 | @@ -44,6 +44,7 @@ | |
582 | #include <linux/types.h> | |
583 | #include <linux/errno.h> | |
584 | #include <linux/crypto.h> | |
585 | +#include <linux/bitops.h> | |
586 | ||
587 | ||
588 | /* The large precomputed tables for the Twofish cipher (twofish.c) | |
589 | @@ -542,9 +543,9 @@ | |
590 | #define CALC_K(a, j, k, l, m, n) \ | |
591 | x = CALC_K_2 (k, l, k, l, 0); \ | |
592 | y = CALC_K_2 (m, n, m, n, 4); \ | |
593 | - y = (y << 8) + (y >> 24); \ | |
594 | + y = rol32(y, 8); \ | |
595 | x += y; y += x; ctx->a[j] = x; \ | |
596 | - ctx->a[(j) + 1] = (y << 9) + (y >> 23) | |
597 | + ctx->a[(j) + 1] = rol32(y, 9) | |
598 | ||
599 | #define CALC_K192_2(a, b, c, d, j) \ | |
600 | CALC_K_2 (q0[a ^ key[(j) + 16]], \ | |
601 | @@ -555,9 +556,9 @@ | |
602 | #define CALC_K192(a, j, k, l, m, n) \ | |
603 | x = CALC_K192_2 (l, l, k, k, 0); \ | |
604 | y = CALC_K192_2 (n, n, m, m, 4); \ | |
605 | - y = (y << 8) + (y >> 24); \ | |
606 | + y = rol32(y, 8); \ | |
607 | x += y; y += x; ctx->a[j] = x; \ | |
608 | - ctx->a[(j) + 1] = (y << 9) + (y >> 23) | |
609 | + ctx->a[(j) + 1] = rol32(y, 9) | |
610 | ||
611 | #define CALC_K256_2(a, b, j) \ | |
612 | CALC_K192_2 (q1[b ^ key[(j) + 24]], \ | |
613 | @@ -568,9 +569,9 @@ | |
614 | #define CALC_K256(a, j, k, l, m, n) \ | |
615 | x = CALC_K256_2 (k, l, 0); \ | |
616 | y = CALC_K256_2 (m, n, 4); \ | |
617 | - y = (y << 8) + (y >> 24); \ | |
618 | + y = rol32(y, 8); \ | |
619 | x += y; y += x; ctx->a[j] = x; \ | |
620 | - ctx->a[(j) + 1] = (y << 9) + (y >> 23) | |
621 | + ctx->a[(j) + 1] = rol32(y, 9) | |
622 | ||
623 | ||
624 | /* Macros to compute the g() function in the encryption and decryption | |
625 | @@ -594,15 +595,15 @@ | |
626 | x = G1 (a); y = G2 (b); \ | |
627 | x += y; y += x + ctx->k[2 * (n) + 1]; \ | |
628 | (c) ^= x + ctx->k[2 * (n)]; \ | |
629 | - (c) = ((c) >> 1) + ((c) << 31); \ | |
630 | - (d) = (((d) << 1)+((d) >> 31)) ^ y | |
631 | + (c) = ror32((c), 1); \ | |
632 | + (d) = rol32((d), 1) ^ y | |
633 | ||
634 | #define DECROUND(n, a, b, c, d) \ | |
635 | x = G1 (a); y = G2 (b); \ | |
636 | x += y; y += x; \ | |
637 | (d) ^= y + ctx->k[2 * (n) + 1]; \ | |
638 | - (d) = ((d) >> 1) + ((d) << 31); \ | |
639 | - (c) = (((c) << 1)+((c) >> 31)); \ | |
640 | + (d) = ror32((d), 1); \ | |
641 | + (c) = rol32((c), 1); \ | |
642 | (c) ^= (x + ctx->k[2 * (n)]) | |
643 | ||
644 | /* Encryption and decryption cycles; each one is simply two Feistel rounds | |
645 | @@ -642,11 +643,11 @@ | |
646 | }; | |
647 | ||
648 | /* Perform the key setup. */ | |
649 | -static int twofish_setkey(void *cx, const u8 *key, | |
650 | - unsigned int key_len, u32 *flags) | |
651 | +static int twofish_setkey(struct crypto_tfm *tfm, const u8 *key, | |
652 | + unsigned int key_len, u32 *flags) | |
653 | { | |
654 | ||
655 | - struct twofish_ctx *ctx = cx; | |
656 | + struct twofish_ctx *ctx = crypto_tfm_ctx(tfm); | |
657 | ||
658 | int i, j, k; | |
659 | ||
660 | @@ -801,9 +802,9 @@ | |
661 | } | |
662 | ||
663 | /* Encrypt one block. in and out may be the same. */ | |
664 | -static void twofish_encrypt(void *cx, u8 *out, const u8 *in) | |
665 | +static void twofish_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) | |
666 | { | |
667 | - struct twofish_ctx *ctx = cx; | |
668 | + struct twofish_ctx *ctx = crypto_tfm_ctx(tfm); | |
669 | const __le32 *src = (const __le32 *)in; | |
670 | __le32 *dst = (__le32 *)out; | |
671 | ||
672 | @@ -838,9 +839,9 @@ | |
673 | } | |
674 | ||
675 | /* Decrypt one block. in and out may be the same. */ | |
676 | -static void twofish_decrypt(void *cx, u8 *out, const u8 *in) | |
677 | +static void twofish_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) | |
678 | { | |
679 | - struct twofish_ctx *ctx = cx; | |
680 | + struct twofish_ctx *ctx = crypto_tfm_ctx(tfm); | |
681 | const __le32 *src = (const __le32 *)in; | |
682 | __le32 *dst = (__le32 *)out; | |
683 | ||
684 | Index: linux-2.6.16.50/drivers/crypto/padlock-aes.c | |
685 | =================================================================== | |
686 | --- linux-2.6.16.50.orig/drivers/crypto/padlock-aes.c 2006-07-14 18:09:26.387439000 +1200 | |
687 | +++ linux-2.6.16.50/drivers/crypto/padlock-aes.c 2006-07-18 01:35:50.305291201 +1200 | |
688 | @@ -59,16 +59,20 @@ | |
689 | #define AES_EXTENDED_KEY_SIZE 64 /* in uint32_t units */ | |
690 | #define AES_EXTENDED_KEY_SIZE_B (AES_EXTENDED_KEY_SIZE * sizeof(uint32_t)) | |
691 | ||
692 | +/* Whenever making any changes to the following | |
693 | + * structure *make sure* you keep E, d_data | |
694 | + * and cword aligned on 16 Bytes boundaries!!! */ | |
695 | struct aes_ctx { | |
696 | - uint32_t e_data[AES_EXTENDED_KEY_SIZE]; | |
697 | - uint32_t d_data[AES_EXTENDED_KEY_SIZE]; | |
698 | struct { | |
699 | struct cword encrypt; | |
700 | struct cword decrypt; | |
701 | } cword; | |
702 | - uint32_t *E; | |
703 | - uint32_t *D; | |
704 | + u32 *D; | |
705 | int key_length; | |
706 | + u32 E[AES_EXTENDED_KEY_SIZE] | |
707 | + __attribute__ ((__aligned__(PADLOCK_ALIGNMENT))); | |
708 | + u32 d_data[AES_EXTENDED_KEY_SIZE] | |
709 | + __attribute__ ((__aligned__(PADLOCK_ALIGNMENT))); | |
710 | }; | |
711 | ||
712 | /* ====== Key management routines ====== */ | |
713 | @@ -282,15 +286,20 @@ | |
714 | return 0; | |
715 | } | |
716 | ||
717 | -static inline struct aes_ctx *aes_ctx(void *ctx) | |
718 | +static inline struct aes_ctx *aes_ctx(struct crypto_tfm *tfm) | |
719 | { | |
720 | - return (struct aes_ctx *)ALIGN((unsigned long)ctx, PADLOCK_ALIGNMENT); | |
721 | + unsigned long addr = (unsigned long)crypto_tfm_ctx(tfm); | |
722 | + unsigned long align = PADLOCK_ALIGNMENT; | |
723 | + | |
724 | + if (align <= crypto_tfm_ctx_alignment()) | |
725 | + align = 1; | |
726 | + return (struct aes_ctx *)ALIGN(addr, align); | |
727 | } | |
728 | ||
729 | -static int | |
730 | -aes_set_key(void *ctx_arg, const uint8_t *in_key, unsigned int key_len, uint32_t *flags) | |
731 | +static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key, | |
732 | + unsigned int key_len, u32 *flags) | |
733 | { | |
734 | - struct aes_ctx *ctx = aes_ctx(ctx_arg); | |
735 | + struct aes_ctx *ctx = aes_ctx(tfm); | |
736 | const __le32 *key = (const __le32 *)in_key; | |
737 | uint32_t i, t, u, v, w; | |
738 | uint32_t P[AES_EXTENDED_KEY_SIZE]; | |
739 | @@ -308,8 +317,7 @@ | |
740 | * itself we must supply the plain key for both encryption | |
741 | * and decryption. | |
742 | */ | |
743 | - ctx->E = ctx->e_data; | |
744 | - ctx->D = ctx->e_data; | |
745 | + ctx->D = ctx->E; | |
746 | ||
747 | E_KEY[0] = le32_to_cpu(key[0]); | |
748 | E_KEY[1] = le32_to_cpu(key[1]); | |
749 | @@ -410,24 +418,22 @@ | |
750 | return iv; | |
751 | } | |
752 | ||
753 | -static void | |
754 | -aes_encrypt(void *ctx_arg, uint8_t *out, const uint8_t *in) | |
755 | +static void aes_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) | |
756 | { | |
757 | - struct aes_ctx *ctx = aes_ctx(ctx_arg); | |
758 | + struct aes_ctx *ctx = aes_ctx(tfm); | |
759 | padlock_xcrypt_ecb(in, out, ctx->E, &ctx->cword.encrypt, 1); | |
760 | } | |
761 | ||
762 | -static void | |
763 | -aes_decrypt(void *ctx_arg, uint8_t *out, const uint8_t *in) | |
764 | +static void aes_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) | |
765 | { | |
766 | - struct aes_ctx *ctx = aes_ctx(ctx_arg); | |
767 | + struct aes_ctx *ctx = aes_ctx(tfm); | |
768 | padlock_xcrypt_ecb(in, out, ctx->D, &ctx->cword.decrypt, 1); | |
769 | } | |
770 | ||
771 | static unsigned int aes_encrypt_ecb(const struct cipher_desc *desc, u8 *out, | |
772 | const u8 *in, unsigned int nbytes) | |
773 | { | |
774 | - struct aes_ctx *ctx = aes_ctx(crypto_tfm_ctx(desc->tfm)); | |
775 | + struct aes_ctx *ctx = aes_ctx(desc->tfm); | |
776 | padlock_xcrypt_ecb(in, out, ctx->E, &ctx->cword.encrypt, | |
777 | nbytes / AES_BLOCK_SIZE); | |
778 | return nbytes & ~(AES_BLOCK_SIZE - 1); | |
779 | @@ -436,7 +442,7 @@ | |
780 | static unsigned int aes_decrypt_ecb(const struct cipher_desc *desc, u8 *out, | |
781 | const u8 *in, unsigned int nbytes) | |
782 | { | |
783 | - struct aes_ctx *ctx = aes_ctx(crypto_tfm_ctx(desc->tfm)); | |
784 | + struct aes_ctx *ctx = aes_ctx(desc->tfm); | |
785 | padlock_xcrypt_ecb(in, out, ctx->D, &ctx->cword.decrypt, | |
786 | nbytes / AES_BLOCK_SIZE); | |
787 | return nbytes & ~(AES_BLOCK_SIZE - 1); | |
788 | @@ -445,7 +451,7 @@ | |
789 | static unsigned int aes_encrypt_cbc(const struct cipher_desc *desc, u8 *out, | |
790 | const u8 *in, unsigned int nbytes) | |
791 | { | |
792 | - struct aes_ctx *ctx = aes_ctx(crypto_tfm_ctx(desc->tfm)); | |
793 | + struct aes_ctx *ctx = aes_ctx(desc->tfm); | |
794 | u8 *iv; | |
795 | ||
796 | iv = padlock_xcrypt_cbc(in, out, ctx->E, desc->info, | |
797 | @@ -458,7 +464,7 @@ | |
798 | static unsigned int aes_decrypt_cbc(const struct cipher_desc *desc, u8 *out, | |
799 | const u8 *in, unsigned int nbytes) | |
800 | { | |
801 | - struct aes_ctx *ctx = aes_ctx(crypto_tfm_ctx(desc->tfm)); | |
802 | + struct aes_ctx *ctx = aes_ctx(desc->tfm); | |
803 | padlock_xcrypt_cbc(in, out, ctx->D, desc->info, &ctx->cword.decrypt, | |
804 | nbytes / AES_BLOCK_SIZE); | |
805 | return nbytes & ~(AES_BLOCK_SIZE - 1); | |
806 | Index: linux-2.6.16.50/include/linux/crypto.h | |
807 | =================================================================== | |
808 | --- linux-2.6.16.50.orig/include/linux/crypto.h 2006-07-14 18:09:26.387439000 +1200 | |
809 | +++ linux-2.6.16.50/include/linux/crypto.h 2006-07-18 01:35:17.475239451 +1200 | |
810 | @@ -67,7 +67,7 @@ | |
811 | ||
812 | struct cipher_desc { | |
813 | struct crypto_tfm *tfm; | |
814 | - void (*crfn)(void *ctx, u8 *dst, const u8 *src); | |
815 | + void (*crfn)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); | |
816 | unsigned int (*prfn)(const struct cipher_desc *desc, u8 *dst, | |
817 | const u8 *src, unsigned int nbytes); | |
818 | void *info; | |
819 | @@ -80,10 +80,10 @@ | |
820 | struct cipher_alg { | |
821 | unsigned int cia_min_keysize; | |
822 | unsigned int cia_max_keysize; | |
823 | - int (*cia_setkey)(void *ctx, const u8 *key, | |
824 | + int (*cia_setkey)(struct crypto_tfm *tfm, const u8 *key, | |
825 | unsigned int keylen, u32 *flags); | |
826 | - void (*cia_encrypt)(void *ctx, u8 *dst, const u8 *src); | |
827 | - void (*cia_decrypt)(void *ctx, u8 *dst, const u8 *src); | |
828 | + void (*cia_encrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); | |
829 | + void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src); | |
830 | ||
831 | unsigned int (*cia_encrypt_ecb)(const struct cipher_desc *desc, | |
832 | u8 *dst, const u8 *src, | |
833 | @@ -101,20 +101,19 @@ | |
834 | ||
835 | struct digest_alg { | |
836 | unsigned int dia_digestsize; | |
837 | - void (*dia_init)(void *ctx); | |
838 | - void (*dia_update)(void *ctx, const u8 *data, unsigned int len); | |
839 | - void (*dia_final)(void *ctx, u8 *out); | |
840 | - int (*dia_setkey)(void *ctx, const u8 *key, | |
841 | + void (*dia_init)(struct crypto_tfm *tfm); | |
842 | + void (*dia_update)(struct crypto_tfm *tfm, const u8 *data, | |
843 | + unsigned int len); | |
844 | + void (*dia_final)(struct crypto_tfm *tfm, u8 *out); | |
845 | + int (*dia_setkey)(struct crypto_tfm *tfm, const u8 *key, | |
846 | unsigned int keylen, u32 *flags); | |
847 | }; | |
848 | ||
849 | struct compress_alg { | |
850 | - int (*coa_init)(void *ctx); | |
851 | - void (*coa_exit)(void *ctx); | |
852 | - int (*coa_compress)(void *ctx, const u8 *src, unsigned int slen, | |
853 | - u8 *dst, unsigned int *dlen); | |
854 | - int (*coa_decompress)(void *ctx, const u8 *src, unsigned int slen, | |
855 | - u8 *dst, unsigned int *dlen); | |
856 | + int (*coa_compress)(struct crypto_tfm *tfm, const u8 *src, | |
857 | + unsigned int slen, u8 *dst, unsigned int *dlen); | |
858 | + int (*coa_decompress)(struct crypto_tfm *tfm, const u8 *src, | |
859 | + unsigned int slen, u8 *dst, unsigned int *dlen); | |
860 | }; | |
861 | ||
862 | #define cra_cipher cra_u.cipher | |
863 | @@ -130,14 +129,17 @@ | |
864 | ||
865 | int cra_priority; | |
866 | ||
867 | - const char cra_name[CRYPTO_MAX_ALG_NAME]; | |
868 | - const char cra_driver_name[CRYPTO_MAX_ALG_NAME]; | |
869 | + char cra_name[CRYPTO_MAX_ALG_NAME]; | |
870 | + char cra_driver_name[CRYPTO_MAX_ALG_NAME]; | |
871 | ||
872 | union { | |
873 | struct cipher_alg cipher; | |
874 | struct digest_alg digest; | |
875 | struct compress_alg compress; | |
876 | } cra_u; | |
877 | + | |
878 | + int (*cra_init)(struct crypto_tfm *tfm); | |
879 | + void (*cra_exit)(struct crypto_tfm *tfm); | |
880 | ||
881 | struct module *cra_module; | |
882 | }; | |
883 | @@ -229,6 +231,8 @@ | |
884 | } crt_u; | |
885 | ||
886 | struct crypto_alg *__crt_alg; | |
887 | + | |
888 | + char __crt_ctx[] __attribute__ ((__aligned__)); | |
889 | }; | |
890 | ||
891 | /* | |
892 | @@ -301,7 +305,13 @@ | |
893 | ||
894 | static inline void *crypto_tfm_ctx(struct crypto_tfm *tfm) | |
895 | { | |
896 | - return (void *)&tfm[1]; | |
897 | + return tfm->__crt_ctx; | |
898 | +} | |
899 | + | |
900 | +static inline unsigned int crypto_tfm_ctx_alignment(void) | |
901 | +{ | |
902 | + struct crypto_tfm *tfm; | |
903 | + return __alignof__(tfm->__crt_ctx); | |
904 | } | |
905 | ||
906 | /* | |
907 | Index: linux-2.6.16.50/arch/i386/crypto/aes-i586-asm.S | |
908 | =================================================================== | |
909 | --- linux-2.6.16.50.orig/arch/i386/crypto/aes-i586-asm.S 2006-07-14 18:09:26.339436000 +1200 | |
910 | +++ linux-2.6.16.50/arch/i386/crypto/aes-i586-asm.S 2006-07-14 18:10:31.131485250 +1200 | |
911 | @@ -36,22 +36,19 @@ | |
912 | .file "aes-i586-asm.S" | |
913 | .text | |
914 | ||
915 | -// aes_rval aes_enc_blk(const unsigned char in_blk[], unsigned char out_blk[], const aes_ctx cx[1])// | |
916 | -// aes_rval aes_dec_blk(const unsigned char in_blk[], unsigned char out_blk[], const aes_ctx cx[1])// | |
917 | - | |
918 | -#define tlen 1024 // length of each of 4 'xor' arrays (256 32-bit words) | |
919 | - | |
920 | -// offsets to parameters with one register pushed onto stack | |
921 | +#include <asm/asm-offsets.h> | |
922 | ||
923 | -#define in_blk 8 // input byte array address parameter | |
924 | -#define out_blk 12 // output byte array address parameter | |
925 | -#define ctx 16 // AES context structure | |
926 | - | |
927 | -// offsets in context structure | |
928 | +#define tlen 1024 // length of each of 4 'xor' arrays (256 32-bit words) | |
929 | ||
930 | -#define ekey 0 // encryption key schedule base address | |
931 | -#define nrnd 256 // number of rounds | |
932 | -#define dkey 260 // decryption key schedule base address | |
933 | +/* offsets to parameters with one register pushed onto stack */ | |
934 | +#define tfm 8 | |
935 | +#define out_blk 12 | |
936 | +#define in_blk 16 | |
937 | + | |
938 | +/* offsets in crypto_tfm structure */ | |
939 | +#define ekey (crypto_tfm_ctx_offset + 0) | |
940 | +#define nrnd (crypto_tfm_ctx_offset + 256) | |
941 | +#define dkey (crypto_tfm_ctx_offset + 260) | |
942 | ||
943 | // register mapping for encrypt and decrypt subroutines | |
944 | ||
945 | @@ -220,6 +217,7 @@ | |
946 | do_col (table, r5,r0,r1,r4, r2,r3); /* idx=r5 */ | |
947 | ||
948 | // AES (Rijndael) Encryption Subroutine | |
949 | +/* void aes_enc_blk(struct crypto_tfm *tfm, u8 *out_blk, const u8 *in_blk) */ | |
950 | ||
951 | .global aes_enc_blk | |
952 | ||
953 | @@ -230,7 +228,7 @@ | |
954 | ||
955 | aes_enc_blk: | |
956 | push %ebp | |
957 | - mov ctx(%esp),%ebp // pointer to context | |
958 | + mov tfm(%esp),%ebp | |
959 | ||
960 | // CAUTION: the order and the values used in these assigns | |
961 | // rely on the register mappings | |
962 | @@ -295,6 +293,7 @@ | |
963 | ret | |
964 | ||
965 | // AES (Rijndael) Decryption Subroutine | |
966 | +/* void aes_dec_blk(struct crypto_tfm *tfm, u8 *out_blk, const u8 *in_blk) */ | |
967 | ||
968 | .global aes_dec_blk | |
969 | ||
970 | @@ -305,7 +304,7 @@ | |
971 | ||
972 | aes_dec_blk: | |
973 | push %ebp | |
974 | - mov ctx(%esp),%ebp // pointer to context | |
975 | + mov tfm(%esp),%ebp | |
976 | ||
977 | // CAUTION: the order and the values used in these assigns | |
978 | // rely on the register mappings | |
979 | Index: linux-2.6.16.50/arch/i386/crypto/aes.c | |
980 | =================================================================== | |
981 | --- linux-2.6.16.50.orig/arch/i386/crypto/aes.c 2006-07-14 18:09:26.343436250 +1200 | |
982 | +++ linux-2.6.16.50/arch/i386/crypto/aes.c 2006-07-14 18:10:31.135485500 +1200 | |
983 | @@ -45,8 +45,8 @@ | |
984 | #include <linux/crypto.h> | |
985 | #include <linux/linkage.h> | |
986 | ||
987 | -asmlinkage void aes_enc_blk(const u8 *src, u8 *dst, void *ctx); | |
988 | -asmlinkage void aes_dec_blk(const u8 *src, u8 *dst, void *ctx); | |
989 | +asmlinkage void aes_enc_blk(struct crypto_tfm *tfm, u8 *dst, const u8 *src); | |
990 | +asmlinkage void aes_dec_blk(struct crypto_tfm *tfm, u8 *dst, const u8 *src); | |
991 | ||
992 | #define AES_MIN_KEY_SIZE 16 | |
993 | #define AES_MAX_KEY_SIZE 32 | |
994 | @@ -378,12 +378,12 @@ | |
995 | k[8*(i)+11] = ss[3]; \ | |
996 | } | |
997 | ||
998 | -static int | |
999 | -aes_set_key(void *ctx_arg, const u8 *in_key, unsigned int key_len, u32 *flags) | |
1000 | +static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key, | |
1001 | + unsigned int key_len, u32 *flags) | |
1002 | { | |
1003 | int i; | |
1004 | u32 ss[8]; | |
1005 | - struct aes_ctx *ctx = ctx_arg; | |
1006 | + struct aes_ctx *ctx = crypto_tfm_ctx(tfm); | |
1007 | const __le32 *key = (const __le32 *)in_key; | |
1008 | ||
1009 | /* encryption schedule */ | |
1010 | @@ -464,16 +464,16 @@ | |
1011 | return 0; | |
1012 | } | |
1013 | ||
1014 | -static inline void aes_encrypt(void *ctx, u8 *dst, const u8 *src) | |
1015 | +static void aes_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
1016 | { | |
1017 | - aes_enc_blk(src, dst, ctx); | |
1018 | + aes_enc_blk(tfm, dst, src); | |
1019 | } | |
1020 | -static inline void aes_decrypt(void *ctx, u8 *dst, const u8 *src) | |
1021 | + | |
1022 | +static void aes_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
1023 | { | |
1024 | - aes_dec_blk(src, dst, ctx); | |
1025 | + aes_dec_blk(tfm, dst, src); | |
1026 | } | |
1027 | ||
1028 | - | |
1029 | static struct crypto_alg aes_alg = { | |
1030 | .cra_name = "aes", | |
1031 | .cra_driver_name = "aes-i586", | |
1032 | Index: linux-2.6.16.50/arch/i386/kernel/asm-offsets.c | |
1033 | =================================================================== | |
1034 | --- linux-2.6.16.50.orig/arch/i386/kernel/asm-offsets.c 2006-07-14 18:09:26.343436250 +1200 | |
1035 | +++ linux-2.6.16.50/arch/i386/kernel/asm-offsets.c 2006-07-14 18:10:31.139485750 +1200 | |
1036 | @@ -8,6 +8,7 @@ | |
1037 | #include <linux/signal.h> | |
1038 | #include <linux/personality.h> | |
1039 | #include <linux/suspend.h> | |
1040 | +#include <linux/crypto.h> | |
1041 | #include <asm/ucontext.h> | |
1042 | #include "sigframe.h" | |
1043 | #include <asm/fixmap.h> | |
1044 | @@ -69,4 +70,6 @@ | |
1045 | ||
1046 | DEFINE(PAGE_SIZE_asm, PAGE_SIZE); | |
1047 | DEFINE(VSYSCALL_BASE, __fix_to_virt(FIX_VSYSCALL)); | |
1048 | + | |
1049 | + OFFSET(crypto_tfm_ctx_offset, crypto_tfm, __crt_ctx); | |
1050 | } | |
1051 | Index: linux-2.6.16.50/arch/s390/crypto/aes_s390.c | |
1052 | =================================================================== | |
1053 | --- linux-2.6.16.50.orig/arch/s390/crypto/aes_s390.c 2006-07-14 18:09:26.343436250 +1200 | |
1054 | +++ linux-2.6.16.50/arch/s390/crypto/aes_s390.c 2006-07-14 18:10:31.139485750 +1200 | |
1055 | @@ -37,10 +37,10 @@ | |
1056 | int key_len; | |
1057 | }; | |
1058 | ||
1059 | -static int aes_set_key(void *ctx, const u8 *in_key, unsigned int key_len, | |
1060 | - u32 *flags) | |
1061 | +static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key, | |
1062 | + unsigned int key_len, u32 *flags) | |
1063 | { | |
1064 | - struct s390_aes_ctx *sctx = ctx; | |
1065 | + struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm); | |
1066 | ||
1067 | switch (key_len) { | |
1068 | case 16: | |
1069 | @@ -70,9 +70,9 @@ | |
1070 | return -EINVAL; | |
1071 | } | |
1072 | ||
1073 | -static void aes_encrypt(void *ctx, u8 *out, const u8 *in) | |
1074 | +static void aes_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) | |
1075 | { | |
1076 | - const struct s390_aes_ctx *sctx = ctx; | |
1077 | + const struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm); | |
1078 | ||
1079 | switch (sctx->key_len) { | |
1080 | case 16: | |
1081 | @@ -90,9 +90,9 @@ | |
1082 | } | |
1083 | } | |
1084 | ||
1085 | -static void aes_decrypt(void *ctx, u8 *out, const u8 *in) | |
1086 | +static void aes_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) | |
1087 | { | |
1088 | - const struct s390_aes_ctx *sctx = ctx; | |
1089 | + const struct s390_aes_ctx *sctx = crypto_tfm_ctx(tfm); | |
1090 | ||
1091 | switch (sctx->key_len) { | |
1092 | case 16: | |
1093 | Index: linux-2.6.16.50/arch/s390/crypto/des_s390.c | |
1094 | =================================================================== | |
1095 | --- linux-2.6.16.50.orig/arch/s390/crypto/des_s390.c 2006-07-14 18:09:26.347436500 +1200 | |
1096 | +++ linux-2.6.16.50/arch/s390/crypto/des_s390.c 2006-07-14 18:10:31.147486250 +1200 | |
1097 | @@ -44,10 +44,10 @@ | |
1098 | u8 key[DES3_192_KEY_SIZE]; | |
1099 | }; | |
1100 | ||
1101 | -static int des_setkey(void *ctx, const u8 *key, unsigned int keylen, | |
1102 | - u32 *flags) | |
1103 | +static int des_setkey(struct crypto_tfm *tfm, const u8 *key, | |
1104 | + unsigned int keylen, u32 *flags) | |
1105 | { | |
1106 | - struct crypt_s390_des_ctx *dctx = ctx; | |
1107 | + struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm); | |
1108 | int ret; | |
1109 | ||
1110 | /* test if key is valid (not a weak key) */ | |
1111 | @@ -57,16 +57,16 @@ | |
1112 | return ret; | |
1113 | } | |
1114 | ||
1115 | -static void des_encrypt(void *ctx, u8 *out, const u8 *in) | |
1116 | +static void des_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) | |
1117 | { | |
1118 | - struct crypt_s390_des_ctx *dctx = ctx; | |
1119 | + struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm); | |
1120 | ||
1121 | crypt_s390_km(KM_DEA_ENCRYPT, dctx->key, out, in, DES_BLOCK_SIZE); | |
1122 | } | |
1123 | ||
1124 | -static void des_decrypt(void *ctx, u8 *out, const u8 *in) | |
1125 | +static void des_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) | |
1126 | { | |
1127 | - struct crypt_s390_des_ctx *dctx = ctx; | |
1128 | + struct crypt_s390_des_ctx *dctx = crypto_tfm_ctx(tfm); | |
1129 | ||
1130 | crypt_s390_km(KM_DEA_DECRYPT, dctx->key, out, in, DES_BLOCK_SIZE); | |
1131 | } | |
1132 | @@ -166,11 +166,11 @@ | |
1133 | * Implementers MUST reject keys that exhibit this property. | |
1134 | * | |
1135 | */ | |
1136 | -static int des3_128_setkey(void *ctx, const u8 *key, unsigned int keylen, | |
1137 | - u32 *flags) | |
1138 | +static int des3_128_setkey(struct crypto_tfm *tfm, const u8 *key, | |
1139 | + unsigned int keylen, u32 *flags) | |
1140 | { | |
1141 | int i, ret; | |
1142 | - struct crypt_s390_des3_128_ctx *dctx = ctx; | |
1143 | + struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm); | |
1144 | const u8* temp_key = key; | |
1145 | ||
1146 | if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE))) { | |
1147 | @@ -186,17 +186,17 @@ | |
1148 | return 0; | |
1149 | } | |
1150 | ||
1151 | -static void des3_128_encrypt(void *ctx, u8 *dst, const u8 *src) | |
1152 | +static void des3_128_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
1153 | { | |
1154 | - struct crypt_s390_des3_128_ctx *dctx = ctx; | |
1155 | + struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm); | |
1156 | ||
1157 | crypt_s390_km(KM_TDEA_128_ENCRYPT, dctx->key, dst, (void*)src, | |
1158 | DES3_128_BLOCK_SIZE); | |
1159 | } | |
1160 | ||
1161 | -static void des3_128_decrypt(void *ctx, u8 *dst, const u8 *src) | |
1162 | +static void des3_128_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
1163 | { | |
1164 | - struct crypt_s390_des3_128_ctx *dctx = ctx; | |
1165 | + struct crypt_s390_des3_128_ctx *dctx = crypto_tfm_ctx(tfm); | |
1166 | ||
1167 | crypt_s390_km(KM_TDEA_128_DECRYPT, dctx->key, dst, (void*)src, | |
1168 | DES3_128_BLOCK_SIZE); | |
1169 | @@ -302,11 +302,11 @@ | |
1170 | * property. | |
1171 | * | |
1172 | */ | |
1173 | -static int des3_192_setkey(void *ctx, const u8 *key, unsigned int keylen, | |
1174 | - u32 *flags) | |
1175 | +static int des3_192_setkey(struct crypto_tfm *tfm, const u8 *key, | |
1176 | + unsigned int keylen, u32 *flags) | |
1177 | { | |
1178 | int i, ret; | |
1179 | - struct crypt_s390_des3_192_ctx *dctx = ctx; | |
1180 | + struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm); | |
1181 | const u8* temp_key = key; | |
1182 | ||
1183 | if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) && | |
1184 | @@ -325,17 +325,17 @@ | |
1185 | return 0; | |
1186 | } | |
1187 | ||
1188 | -static void des3_192_encrypt(void *ctx, u8 *dst, const u8 *src) | |
1189 | +static void des3_192_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
1190 | { | |
1191 | - struct crypt_s390_des3_192_ctx *dctx = ctx; | |
1192 | + struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm); | |
1193 | ||
1194 | crypt_s390_km(KM_TDEA_192_ENCRYPT, dctx->key, dst, (void*)src, | |
1195 | DES3_192_BLOCK_SIZE); | |
1196 | } | |
1197 | ||
1198 | -static void des3_192_decrypt(void *ctx, u8 *dst, const u8 *src) | |
1199 | +static void des3_192_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
1200 | { | |
1201 | - struct crypt_s390_des3_192_ctx *dctx = ctx; | |
1202 | + struct crypt_s390_des3_192_ctx *dctx = crypto_tfm_ctx(tfm); | |
1203 | ||
1204 | crypt_s390_km(KM_TDEA_192_DECRYPT, dctx->key, dst, (void*)src, | |
1205 | DES3_192_BLOCK_SIZE); | |
1206 | Index: linux-2.6.16.50/arch/s390/crypto/sha1_s390.c | |
1207 | =================================================================== | |
1208 | --- linux-2.6.16.50.orig/arch/s390/crypto/sha1_s390.c 2006-07-14 18:09:26.347436500 +1200 | |
1209 | +++ linux-2.6.16.50/arch/s390/crypto/sha1_s390.c 2006-07-14 18:10:31.147486250 +1200 | |
1210 | @@ -40,28 +40,29 @@ | |
1211 | u8 buffer[2 * SHA1_BLOCK_SIZE]; | |
1212 | }; | |
1213 | ||
1214 | -static void | |
1215 | -sha1_init(void *ctx) | |
1216 | +static void sha1_init(struct crypto_tfm *tfm) | |
1217 | { | |
1218 | - static const struct crypt_s390_sha1_ctx initstate = { | |
1219 | - .state = { | |
1220 | - 0x67452301, | |
1221 | - 0xEFCDAB89, | |
1222 | - 0x98BADCFE, | |
1223 | - 0x10325476, | |
1224 | - 0xC3D2E1F0 | |
1225 | - }, | |
1226 | + struct crypt_s390_sha1_ctx *ctx = crypto_tfm_ctx(tfm); | |
1227 | + static const u32 initstate[5] = { | |
1228 | + 0x67452301, | |
1229 | + 0xEFCDAB89, | |
1230 | + 0x98BADCFE, | |
1231 | + 0x10325476, | |
1232 | + 0xC3D2E1F0 | |
1233 | }; | |
1234 | - memcpy(ctx, &initstate, sizeof(initstate)); | |
1235 | + | |
1236 | + ctx->count = 0; | |
1237 | + memcpy(ctx->state, &initstate, sizeof(initstate)); | |
1238 | + ctx->buf_len = 0; | |
1239 | } | |
1240 | ||
1241 | -static void | |
1242 | -sha1_update(void *ctx, const u8 *data, unsigned int len) | |
1243 | +static void sha1_update(struct crypto_tfm *tfm, const u8 *data, | |
1244 | + unsigned int len) | |
1245 | { | |
1246 | struct crypt_s390_sha1_ctx *sctx; | |
1247 | long imd_len; | |
1248 | ||
1249 | - sctx = ctx; | |
1250 | + sctx = crypto_tfm_ctx(tfm); | |
1251 | sctx->count += len * 8; //message bit length | |
1252 | ||
1253 | //anything in buffer yet? -> must be completed | |
1254 | @@ -110,10 +111,9 @@ | |
1255 | } | |
1256 | ||
1257 | /* Add padding and return the message digest. */ | |
1258 | -static void | |
1259 | -sha1_final(void* ctx, u8 *out) | |
1260 | +static void sha1_final(struct crypto_tfm *tfm, u8 *out) | |
1261 | { | |
1262 | - struct crypt_s390_sha1_ctx *sctx = ctx; | |
1263 | + struct crypt_s390_sha1_ctx *sctx = crypto_tfm_ctx(tfm); | |
1264 | ||
1265 | //must perform manual padding | |
1266 | pad_message(sctx); | |
1267 | Index: linux-2.6.16.50/arch/s390/crypto/sha256_s390.c | |
1268 | =================================================================== | |
1269 | --- linux-2.6.16.50.orig/arch/s390/crypto/sha256_s390.c 2006-07-14 18:09:26.347436500 +1200 | |
1270 | +++ linux-2.6.16.50/arch/s390/crypto/sha256_s390.c 2006-07-14 18:10:31.151486500 +1200 | |
1271 | @@ -31,9 +31,9 @@ | |
1272 | u8 buf[2 * SHA256_BLOCK_SIZE]; | |
1273 | }; | |
1274 | ||
1275 | -static void sha256_init(void *ctx) | |
1276 | +static void sha256_init(struct crypto_tfm *tfm) | |
1277 | { | |
1278 | - struct s390_sha256_ctx *sctx = ctx; | |
1279 | + struct s390_sha256_ctx *sctx = crypto_tfm_ctx(tfm); | |
1280 | ||
1281 | sctx->state[0] = 0x6a09e667; | |
1282 | sctx->state[1] = 0xbb67ae85; | |
1283 | @@ -44,12 +44,12 @@ | |
1284 | sctx->state[6] = 0x1f83d9ab; | |
1285 | sctx->state[7] = 0x5be0cd19; | |
1286 | sctx->count = 0; | |
1287 | - memset(sctx->buf, 0, sizeof(sctx->buf)); | |
1288 | } | |
1289 | ||
1290 | -static void sha256_update(void *ctx, const u8 *data, unsigned int len) | |
1291 | +static void sha256_update(struct crypto_tfm *tfm, const u8 *data, | |
1292 | + unsigned int len) | |
1293 | { | |
1294 | - struct s390_sha256_ctx *sctx = ctx; | |
1295 | + struct s390_sha256_ctx *sctx = crypto_tfm_ctx(tfm); | |
1296 | unsigned int index; | |
1297 | int ret; | |
1298 | ||
1299 | @@ -108,9 +108,9 @@ | |
1300 | } | |
1301 | ||
1302 | /* Add padding and return the message digest */ | |
1303 | -static void sha256_final(void* ctx, u8 *out) | |
1304 | +static void sha256_final(struct crypto_tfm *tfm, u8 *out) | |
1305 | { | |
1306 | - struct s390_sha256_ctx *sctx = ctx; | |
1307 | + struct s390_sha256_ctx *sctx = crypto_tfm_ctx(tfm); | |
1308 | ||
1309 | /* must perform manual padding */ | |
1310 | pad_message(sctx); | |
1311 | Index: linux-2.6.16.50/arch/x86_64/crypto/aes-x86_64-asm.S | |
1312 | =================================================================== | |
1313 | --- linux-2.6.16.50.orig/arch/x86_64/crypto/aes-x86_64-asm.S 2006-07-14 18:09:26.339436000 +1200 | |
1314 | +++ linux-2.6.16.50/arch/x86_64/crypto/aes-x86_64-asm.S 2006-07-14 18:10:31.151486500 +1200 | |
1315 | @@ -15,6 +15,10 @@ | |
1316 | ||
1317 | .text | |
1318 | ||
1319 | +#include <asm/asm-offsets.h> | |
1320 | + | |
1321 | +#define BASE crypto_tfm_ctx_offset | |
1322 | + | |
1323 | #define R1 %rax | |
1324 | #define R1E %eax | |
1325 | #define R1X %ax | |
1326 | @@ -46,19 +50,19 @@ | |
1327 | #define R10 %r10 | |
1328 | #define R11 %r11 | |
1329 | ||
1330 | -#define prologue(FUNC,BASE,B128,B192,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11) \ | |
1331 | +#define prologue(FUNC,KEY,B128,B192,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11) \ | |
1332 | .global FUNC; \ | |
1333 | .type FUNC,@function; \ | |
1334 | .align 8; \ | |
1335 | FUNC: movq r1,r2; \ | |
1336 | movq r3,r4; \ | |
1337 | - leaq BASE+52(r8),r9; \ | |
1338 | + leaq BASE+KEY+52(r8),r9; \ | |
1339 | movq r10,r11; \ | |
1340 | movl (r7),r5 ## E; \ | |
1341 | movl 4(r7),r1 ## E; \ | |
1342 | movl 8(r7),r6 ## E; \ | |
1343 | movl 12(r7),r7 ## E; \ | |
1344 | - movl (r8),r10 ## E; \ | |
1345 | + movl BASE(r8),r10 ## E; \ | |
1346 | xorl -48(r9),r5 ## E; \ | |
1347 | xorl -44(r9),r1 ## E; \ | |
1348 | xorl -40(r9),r6 ## E; \ | |
1349 | @@ -128,8 +132,8 @@ | |
1350 | movl r3 ## E,r1 ## E; \ | |
1351 | movl r4 ## E,r2 ## E; | |
1352 | ||
1353 | -#define entry(FUNC,BASE,B128,B192) \ | |
1354 | - prologue(FUNC,BASE,B128,B192,R2,R8,R7,R9,R1,R3,R4,R6,R10,R5,R11) | |
1355 | +#define entry(FUNC,KEY,B128,B192) \ | |
1356 | + prologue(FUNC,KEY,B128,B192,R2,R8,R7,R9,R1,R3,R4,R6,R10,R5,R11) | |
1357 | ||
1358 | #define return epilogue(R8,R2,R9,R7,R5,R6,R3,R4,R11) | |
1359 | ||
1360 | @@ -147,9 +151,9 @@ | |
1361 | #define decrypt_final(TAB,OFFSET) \ | |
1362 | round(TAB,OFFSET,R2,R1,R4,R3,R6,R5,R7,R10,R5,R6,R3,R4) | |
1363 | ||
1364 | -/* void aes_encrypt(void *ctx, u8 *out, const u8 *in) */ | |
1365 | +/* void aes_enc_blk(stuct crypto_tfm *tfm, u8 *out, const u8 *in) */ | |
1366 | ||
1367 | - entry(aes_encrypt,0,enc128,enc192) | |
1368 | + entry(aes_enc_blk,0,enc128,enc192) | |
1369 | encrypt_round(aes_ft_tab,-96) | |
1370 | encrypt_round(aes_ft_tab,-80) | |
1371 | enc192: encrypt_round(aes_ft_tab,-64) | |
1372 | @@ -166,9 +170,9 @@ | |
1373 | encrypt_final(aes_fl_tab,112) | |
1374 | return | |
1375 | ||
1376 | -/* void aes_decrypt(void *ctx, u8 *out, const u8 *in) */ | |
1377 | +/* void aes_dec_blk(struct crypto_tfm *tfm, u8 *out, const u8 *in) */ | |
1378 | ||
1379 | - entry(aes_decrypt,240,dec128,dec192) | |
1380 | + entry(aes_dec_blk,240,dec128,dec192) | |
1381 | decrypt_round(aes_it_tab,-96) | |
1382 | decrypt_round(aes_it_tab,-80) | |
1383 | dec192: decrypt_round(aes_it_tab,-64) | |
1384 | Index: linux-2.6.16.50/arch/x86_64/kernel/asm-offsets.c | |
1385 | =================================================================== | |
1386 | --- linux-2.6.16.50.orig/arch/x86_64/kernel/asm-offsets.c 2006-07-14 18:09:26.339436000 +1200 | |
1387 | +++ linux-2.6.16.50/arch/x86_64/kernel/asm-offsets.c 2006-07-14 18:10:31.155486750 +1200 | |
1388 | @@ -68,5 +68,7 @@ | |
1389 | DEFINE(pbe_next, offsetof(struct pbe, next)); | |
1390 | BLANK(); | |
1391 | DEFINE(TSS_ist, offsetof(struct tss_struct, ist)); | |
1392 | + BLANK(); | |
1393 | + DEFINE(crypto_tfm_ctx_offset, offsetof(struct crypto_tfm, __crt_ctx)); | |
1394 | return 0; | |
1395 | } | |
1396 | Index: linux-2.6.16.50/crypto/Kconfig | |
1397 | =================================================================== | |
1398 | --- linux-2.6.16.50.orig/crypto/Kconfig 2006-07-14 18:09:26.359437250 +1200 | |
1399 | +++ linux-2.6.16.50/crypto/Kconfig 2006-07-14 18:10:31.159487000 +1200 | |
1400 | @@ -337,7 +337,7 @@ | |
1401 | ||
1402 | config CRYPTO_TEST | |
1403 | tristate "Testing module" | |
1404 | - depends on CRYPTO | |
1405 | + depends on CRYPTO && m | |
1406 | help | |
1407 | Quick & dirty crypto test module. | |
1408 | ||
1409 | Index: linux-2.6.16.50/crypto/anubis.c | |
1410 | =================================================================== | |
1411 | --- linux-2.6.16.50.orig/crypto/anubis.c 2006-07-14 18:09:26.359437250 +1200 | |
1412 | +++ linux-2.6.16.50/crypto/anubis.c 2006-07-14 18:10:31.163487250 +1200 | |
1413 | @@ -460,16 +460,15 @@ | |
1414 | 0xf726ffedU, 0xe89d6f8eU, 0x19a0f089U, | |
1415 | }; | |
1416 | ||
1417 | -static int anubis_setkey(void *ctx_arg, const u8 *in_key, | |
1418 | +static int anubis_setkey(struct crypto_tfm *tfm, const u8 *in_key, | |
1419 | unsigned int key_len, u32 *flags) | |
1420 | { | |
1421 | + struct anubis_ctx *ctx = crypto_tfm_ctx(tfm); | |
1422 | const __be32 *key = (const __be32 *)in_key; | |
1423 | int N, R, i, r; | |
1424 | u32 kappa[ANUBIS_MAX_N]; | |
1425 | u32 inter[ANUBIS_MAX_N]; | |
1426 | ||
1427 | - struct anubis_ctx *ctx = ctx_arg; | |
1428 | - | |
1429 | switch (key_len) | |
1430 | { | |
1431 | case 16: case 20: case 24: case 28: | |
1432 | @@ -660,15 +659,15 @@ | |
1433 | dst[i] = cpu_to_be32(inter[i]); | |
1434 | } | |
1435 | ||
1436 | -static void anubis_encrypt(void *ctx_arg, u8 *dst, const u8 *src) | |
1437 | +static void anubis_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
1438 | { | |
1439 | - struct anubis_ctx *ctx = ctx_arg; | |
1440 | + struct anubis_ctx *ctx = crypto_tfm_ctx(tfm); | |
1441 | anubis_crypt(ctx->E, dst, src, ctx->R); | |
1442 | } | |
1443 | ||
1444 | -static void anubis_decrypt(void *ctx_arg, u8 *dst, const u8 *src) | |
1445 | +static void anubis_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
1446 | { | |
1447 | - struct anubis_ctx *ctx = ctx_arg; | |
1448 | + struct anubis_ctx *ctx = crypto_tfm_ctx(tfm); | |
1449 | anubis_crypt(ctx->D, dst, src, ctx->R); | |
1450 | } | |
1451 | ||
1452 | Index: linux-2.6.16.50/crypto/arc4.c | |
1453 | =================================================================== | |
1454 | --- linux-2.6.16.50.orig/crypto/arc4.c 2006-07-14 18:09:26.359437250 +1200 | |
1455 | +++ linux-2.6.16.50/crypto/arc4.c 2006-07-14 18:10:31.163487250 +1200 | |
1456 | @@ -24,9 +24,10 @@ | |
1457 | u8 x, y; | |
1458 | }; | |
1459 | ||
1460 | -static int arc4_set_key(void *ctx_arg, const u8 *in_key, unsigned int key_len, u32 *flags) | |
1461 | +static int arc4_set_key(struct crypto_tfm *tfm, const u8 *in_key, | |
1462 | + unsigned int key_len, u32 *flags) | |
1463 | { | |
1464 | - struct arc4_ctx *ctx = ctx_arg; | |
1465 | + struct arc4_ctx *ctx = crypto_tfm_ctx(tfm); | |
1466 | int i, j = 0, k = 0; | |
1467 | ||
1468 | ctx->x = 1; | |
1469 | @@ -48,9 +49,9 @@ | |
1470 | return 0; | |
1471 | } | |
1472 | ||
1473 | -static void arc4_crypt(void *ctx_arg, u8 *out, const u8 *in) | |
1474 | +static void arc4_crypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) | |
1475 | { | |
1476 | - struct arc4_ctx *ctx = ctx_arg; | |
1477 | + struct arc4_ctx *ctx = crypto_tfm_ctx(tfm); | |
1478 | ||
1479 | u8 *const S = ctx->S; | |
1480 | u8 x = ctx->x; | |
1481 | Index: linux-2.6.16.50/crypto/blowfish.c | |
1482 | =================================================================== | |
1483 | --- linux-2.6.16.50.orig/crypto/blowfish.c 2006-07-14 18:09:26.363437500 +1200 | |
1484 | +++ linux-2.6.16.50/crypto/blowfish.c 2006-07-14 18:10:31.167487500 +1200 | |
1485 | @@ -349,7 +349,7 @@ | |
1486 | dst[1] = yl; | |
1487 | } | |
1488 | ||
1489 | -static void bf_encrypt(void *ctx, u8 *dst, const u8 *src) | |
1490 | +static void bf_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
1491 | { | |
1492 | const __be32 *in_blk = (const __be32 *)src; | |
1493 | __be32 *const out_blk = (__be32 *)dst; | |
1494 | @@ -357,17 +357,18 @@ | |
1495 | ||
1496 | in32[0] = be32_to_cpu(in_blk[0]); | |
1497 | in32[1] = be32_to_cpu(in_blk[1]); | |
1498 | - encrypt_block(ctx, out32, in32); | |
1499 | + encrypt_block(crypto_tfm_ctx(tfm), out32, in32); | |
1500 | out_blk[0] = cpu_to_be32(out32[0]); | |
1501 | out_blk[1] = cpu_to_be32(out32[1]); | |
1502 | } | |
1503 | ||
1504 | -static void bf_decrypt(void *ctx, u8 *dst, const u8 *src) | |
1505 | +static void bf_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
1506 | { | |
1507 | + struct bf_ctx *ctx = crypto_tfm_ctx(tfm); | |
1508 | const __be32 *in_blk = (const __be32 *)src; | |
1509 | __be32 *const out_blk = (__be32 *)dst; | |
1510 | - const u32 *P = ((struct bf_ctx *)ctx)->p; | |
1511 | - const u32 *S = ((struct bf_ctx *)ctx)->s; | |
1512 | + const u32 *P = ctx->p; | |
1513 | + const u32 *S = ctx->s; | |
1514 | u32 yl = be32_to_cpu(in_blk[0]); | |
1515 | u32 yr = be32_to_cpu(in_blk[1]); | |
1516 | ||
1517 | @@ -398,12 +399,14 @@ | |
1518 | /* | |
1519 | * Calculates the blowfish S and P boxes for encryption and decryption. | |
1520 | */ | |
1521 | -static int bf_setkey(void *ctx, const u8 *key, unsigned int keylen, u32 *flags) | |
1522 | +static int bf_setkey(struct crypto_tfm *tfm, const u8 *key, | |
1523 | + unsigned int keylen, u32 *flags) | |
1524 | { | |
1525 | + struct bf_ctx *ctx = crypto_tfm_ctx(tfm); | |
1526 | + u32 *P = ctx->p; | |
1527 | + u32 *S = ctx->s; | |
1528 | short i, j, count; | |
1529 | u32 data[2], temp; | |
1530 | - u32 *P = ((struct bf_ctx *)ctx)->p; | |
1531 | - u32 *S = ((struct bf_ctx *)ctx)->s; | |
1532 | ||
1533 | /* Copy the initialization s-boxes */ | |
1534 | for (i = 0, count = 0; i < 256; i++) | |
1535 | Index: linux-2.6.16.50/crypto/cast5.c | |
1536 | =================================================================== | |
1537 | --- linux-2.6.16.50.orig/crypto/cast5.c 2006-07-14 18:09:26.363437500 +1200 | |
1538 | +++ linux-2.6.16.50/crypto/cast5.c 2006-07-14 18:10:31.171487750 +1200 | |
1539 | @@ -577,9 +577,9 @@ | |
1540 | (((s1[I >> 24] + s2[(I>>16)&0xff]) ^ s3[(I>>8)&0xff]) - s4[I&0xff]) ) | |
1541 | ||
1542 | ||
1543 | -static void cast5_encrypt(void *ctx, u8 * outbuf, const u8 * inbuf) | |
1544 | +static void cast5_encrypt(struct crypto_tfm *tfm, u8 *outbuf, const u8 *inbuf) | |
1545 | { | |
1546 | - struct cast5_ctx *c = (struct cast5_ctx *) ctx; | |
1547 | + struct cast5_ctx *c = crypto_tfm_ctx(tfm); | |
1548 | const __be32 *src = (const __be32 *)inbuf; | |
1549 | __be32 *dst = (__be32 *)outbuf; | |
1550 | u32 l, r, t; | |
1551 | @@ -642,9 +642,9 @@ | |
1552 | dst[1] = cpu_to_be32(l); | |
1553 | } | |
1554 | ||
1555 | -static void cast5_decrypt(void *ctx, u8 * outbuf, const u8 * inbuf) | |
1556 | +static void cast5_decrypt(struct crypto_tfm *tfm, u8 *outbuf, const u8 *inbuf) | |
1557 | { | |
1558 | - struct cast5_ctx *c = (struct cast5_ctx *) ctx; | |
1559 | + struct cast5_ctx *c = crypto_tfm_ctx(tfm); | |
1560 | const __be32 *src = (const __be32 *)inbuf; | |
1561 | __be32 *dst = (__be32 *)outbuf; | |
1562 | u32 l, r, t; | |
1563 | @@ -769,15 +769,15 @@ | |
1564 | } | |
1565 | ||
1566 | ||
1567 | -static int | |
1568 | -cast5_setkey(void *ctx, const u8 * key, unsigned key_len, u32 * flags) | |
1569 | +static int cast5_setkey(struct crypto_tfm *tfm, const u8 *key, | |
1570 | + unsigned key_len, u32 *flags) | |
1571 | { | |
1572 | + struct cast5_ctx *c = crypto_tfm_ctx(tfm); | |
1573 | int i; | |
1574 | u32 x[4]; | |
1575 | u32 z[4]; | |
1576 | u32 k[16]; | |
1577 | __be32 p_key[4]; | |
1578 | - struct cast5_ctx *c = (struct cast5_ctx *) ctx; | |
1579 | ||
1580 | if (key_len < 5 || key_len > 16) { | |
1581 | *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN; | |
1582 | Index: linux-2.6.16.50/crypto/cast6.c | |
1583 | =================================================================== | |
1584 | --- linux-2.6.16.50.orig/crypto/cast6.c 2006-07-14 18:09:26.363437500 +1200 | |
1585 | +++ linux-2.6.16.50/crypto/cast6.c 2006-07-14 18:10:31.175488000 +1200 | |
1586 | @@ -381,13 +381,13 @@ | |
1587 | key[7] ^= F2(key[0], Tr[i % 4][7], Tm[i][7]); | |
1588 | } | |
1589 | ||
1590 | -static int | |
1591 | -cast6_setkey(void *ctx, const u8 * in_key, unsigned key_len, u32 * flags) | |
1592 | +static int cast6_setkey(struct crypto_tfm *tfm, const u8 *in_key, | |
1593 | + unsigned key_len, u32 *flags) | |
1594 | { | |
1595 | int i; | |
1596 | u32 key[8]; | |
1597 | __be32 p_key[8]; /* padded key */ | |
1598 | - struct cast6_ctx *c = (struct cast6_ctx *) ctx; | |
1599 | + struct cast6_ctx *c = crypto_tfm_ctx(tfm); | |
1600 | ||
1601 | if (key_len < 16 || key_len > 32 || key_len % 4 != 0) { | |
1602 | *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN; | |
1603 | @@ -444,8 +444,9 @@ | |
1604 | block[2] ^= F1(block[3], Kr[0], Km[0]); | |
1605 | } | |
1606 | ||
1607 | -static void cast6_encrypt (void * ctx, u8 * outbuf, const u8 * inbuf) { | |
1608 | - struct cast6_ctx * c = (struct cast6_ctx *)ctx; | |
1609 | +static void cast6_encrypt(struct crypto_tfm *tfm, u8 *outbuf, const u8 *inbuf) | |
1610 | +{ | |
1611 | + struct cast6_ctx *c = crypto_tfm_ctx(tfm); | |
1612 | const __be32 *src = (const __be32 *)inbuf; | |
1613 | __be32 *dst = (__be32 *)outbuf; | |
1614 | u32 block[4]; | |
1615 | @@ -476,8 +477,8 @@ | |
1616 | dst[3] = cpu_to_be32(block[3]); | |
1617 | } | |
1618 | ||
1619 | -static void cast6_decrypt (void * ctx, u8 * outbuf, const u8 * inbuf) { | |
1620 | - struct cast6_ctx * c = (struct cast6_ctx *)ctx; | |
1621 | +static void cast6_decrypt(struct crypto_tfm *tfm, u8 *outbuf, const u8 *inbuf) { | |
1622 | + struct cast6_ctx * c = crypto_tfm_ctx(tfm); | |
1623 | const __be32 *src = (const __be32 *)inbuf; | |
1624 | __be32 *dst = (__be32 *)outbuf; | |
1625 | u32 block[4]; | |
1626 | Index: linux-2.6.16.50/crypto/cipher.c | |
1627 | =================================================================== | |
1628 | --- linux-2.6.16.50.orig/crypto/cipher.c 2006-07-14 18:09:26.367437750 +1200 | |
1629 | +++ linux-2.6.16.50/crypto/cipher.c 2006-07-14 18:10:31.179488250 +1200 | |
1630 | @@ -187,7 +187,7 @@ | |
1631 | void (*xor)(u8 *, const u8 *) = tfm->crt_u.cipher.cit_xor_block; | |
1632 | int bsize = crypto_tfm_alg_blocksize(tfm); | |
1633 | ||
1634 | - void (*fn)(void *, u8 *, const u8 *) = desc->crfn; | |
1635 | + void (*fn)(struct crypto_tfm *, u8 *, const u8 *) = desc->crfn; | |
1636 | u8 *iv = desc->info; | |
1637 | unsigned int done = 0; | |
1638 | ||
1639 | @@ -195,7 +195,7 @@ | |
1640 | ||
1641 | do { | |
1642 | xor(iv, src); | |
1643 | - fn(crypto_tfm_ctx(tfm), dst, iv); | |
1644 | + fn(tfm, dst, iv); | |
1645 | memcpy(iv, dst, bsize); | |
1646 | ||
1647 | src += bsize; | |
1648 | @@ -218,7 +218,7 @@ | |
1649 | u8 *buf = (u8 *)ALIGN((unsigned long)stack, alignmask + 1); | |
1650 | u8 **dst_p = src == dst ? &buf : &dst; | |
1651 | ||
1652 | - void (*fn)(void *, u8 *, const u8 *) = desc->crfn; | |
1653 | + void (*fn)(struct crypto_tfm *, u8 *, const u8 *) = desc->crfn; | |
1654 | u8 *iv = desc->info; | |
1655 | unsigned int done = 0; | |
1656 | ||
1657 | @@ -227,7 +227,7 @@ | |
1658 | do { | |
1659 | u8 *tmp_dst = *dst_p; | |
1660 | ||
1661 | - fn(crypto_tfm_ctx(tfm), tmp_dst, src); | |
1662 | + fn(tfm, tmp_dst, src); | |
1663 | xor(tmp_dst, iv); | |
1664 | memcpy(iv, src, bsize); | |
1665 | if (tmp_dst != dst) | |
1666 | @@ -245,13 +245,13 @@ | |
1667 | { | |
1668 | struct crypto_tfm *tfm = desc->tfm; | |
1669 | int bsize = crypto_tfm_alg_blocksize(tfm); | |
1670 | - void (*fn)(void *, u8 *, const u8 *) = desc->crfn; | |
1671 | + void (*fn)(struct crypto_tfm *, u8 *, const u8 *) = desc->crfn; | |
1672 | unsigned int done = 0; | |
1673 | ||
1674 | nbytes -= bsize; | |
1675 | ||
1676 | do { | |
1677 | - fn(crypto_tfm_ctx(tfm), dst, src); | |
1678 | + fn(tfm, dst, src); | |
1679 | ||
1680 | src += bsize; | |
1681 | dst += bsize; | |
1682 | @@ -268,7 +268,7 @@ | |
1683 | tfm->crt_flags |= CRYPTO_TFM_RES_BAD_KEY_LEN; | |
1684 | return -EINVAL; | |
1685 | } else | |
1686 | - return cia->cia_setkey(crypto_tfm_ctx(tfm), key, keylen, | |
1687 | + return cia->cia_setkey(tfm, key, keylen, | |
1688 | &tfm->crt_flags); | |
1689 | } | |
1690 | ||
1691 | Index: linux-2.6.16.50/crypto/compress.c | |
1692 | =================================================================== | |
1693 | --- linux-2.6.16.50.orig/crypto/compress.c 2006-07-14 18:09:26.367437750 +1200 | |
1694 | +++ linux-2.6.16.50/crypto/compress.c 2006-07-14 18:10:31.183488500 +1200 | |
1695 | @@ -22,8 +22,7 @@ | |
1696 | const u8 *src, unsigned int slen, | |
1697 | u8 *dst, unsigned int *dlen) | |
1698 | { | |
1699 | - return tfm->__crt_alg->cra_compress.coa_compress(crypto_tfm_ctx(tfm), | |
1700 | - src, slen, dst, | |
1701 | + return tfm->__crt_alg->cra_compress.coa_compress(tfm, src, slen, dst, | |
1702 | dlen); | |
1703 | } | |
1704 | ||
1705 | @@ -31,8 +30,7 @@ | |
1706 | const u8 *src, unsigned int slen, | |
1707 | u8 *dst, unsigned int *dlen) | |
1708 | { | |
1709 | - return tfm->__crt_alg->cra_compress.coa_decompress(crypto_tfm_ctx(tfm), | |
1710 | - src, slen, dst, | |
1711 | + return tfm->__crt_alg->cra_compress.coa_decompress(tfm, src, slen, dst, | |
1712 | dlen); | |
1713 | } | |
1714 | ||
1715 | @@ -43,21 +41,14 @@ | |
1716 | ||
1717 | int crypto_init_compress_ops(struct crypto_tfm *tfm) | |
1718 | { | |
1719 | - int ret = 0; | |
1720 | struct compress_tfm *ops = &tfm->crt_compress; | |
1721 | - | |
1722 | - ret = tfm->__crt_alg->cra_compress.coa_init(crypto_tfm_ctx(tfm)); | |
1723 | - if (ret) | |
1724 | - goto out; | |
1725 | ||
1726 | ops->cot_compress = crypto_compress; | |
1727 | ops->cot_decompress = crypto_decompress; | |
1728 | ||
1729 | -out: | |
1730 | - return ret; | |
1731 | + return 0; | |
1732 | } | |
1733 | ||
1734 | void crypto_exit_compress_ops(struct crypto_tfm *tfm) | |
1735 | { | |
1736 | - tfm->__crt_alg->cra_compress.coa_exit(crypto_tfm_ctx(tfm)); | |
1737 | } | |
1738 | Index: linux-2.6.16.50/crypto/crc32c.c | |
1739 | =================================================================== | |
1740 | --- linux-2.6.16.50.orig/crypto/crc32c.c 2006-07-14 18:09:26.367437750 +1200 | |
1741 | +++ linux-2.6.16.50/crypto/crc32c.c 2006-07-14 18:10:31.183488500 +1200 | |
1742 | @@ -31,9 +31,9 @@ | |
1743 | * crc using table. | |
1744 | */ | |
1745 | ||
1746 | -static void chksum_init(void *ctx) | |
1747 | +static void chksum_init(struct crypto_tfm *tfm) | |
1748 | { | |
1749 | - struct chksum_ctx *mctx = ctx; | |
1750 | + struct chksum_ctx *mctx = crypto_tfm_ctx(tfm); | |
1751 | ||
1752 | mctx->crc = ~(u32)0; /* common usage */ | |
1753 | } | |
1754 | @@ -43,10 +43,10 @@ | |
1755 | * If your algorithm starts with ~0, then XOR with ~0 before you set | |
1756 | * the seed. | |
1757 | */ | |
1758 | -static int chksum_setkey(void *ctx, const u8 *key, unsigned int keylen, | |
1759 | - u32 *flags) | |
1760 | +static int chksum_setkey(struct crypto_tfm *tfm, const u8 *key, | |
1761 | + unsigned int keylen, u32 *flags) | |
1762 | { | |
1763 | - struct chksum_ctx *mctx = ctx; | |
1764 | + struct chksum_ctx *mctx = crypto_tfm_ctx(tfm); | |
1765 | ||
1766 | if (keylen != sizeof(mctx->crc)) { | |
1767 | if (flags) | |
1768 | @@ -57,9 +57,10 @@ | |
1769 | return 0; | |
1770 | } | |
1771 | ||
1772 | -static void chksum_update(void *ctx, const u8 *data, unsigned int length) | |
1773 | +static void chksum_update(struct crypto_tfm *tfm, const u8 *data, | |
1774 | + unsigned int length) | |
1775 | { | |
1776 | - struct chksum_ctx *mctx = ctx; | |
1777 | + struct chksum_ctx *mctx = crypto_tfm_ctx(tfm); | |
1778 | u32 mcrc; | |
1779 | ||
1780 | mcrc = crc32c(mctx->crc, data, (size_t)length); | |
1781 | @@ -67,9 +68,9 @@ | |
1782 | mctx->crc = mcrc; | |
1783 | } | |
1784 | ||
1785 | -static void chksum_final(void *ctx, u8 *out) | |
1786 | +static void chksum_final(struct crypto_tfm *tfm, u8 *out) | |
1787 | { | |
1788 | - struct chksum_ctx *mctx = ctx; | |
1789 | + struct chksum_ctx *mctx = crypto_tfm_ctx(tfm); | |
1790 | u32 mcrc = (mctx->crc ^ ~(u32)0); | |
1791 | ||
1792 | *(u32 *)out = __le32_to_cpu(mcrc); | |
1793 | Index: linux-2.6.16.50/crypto/crypto_null.c | |
1794 | =================================================================== | |
1795 | --- linux-2.6.16.50.orig/crypto/crypto_null.c 2006-07-14 18:09:26.371438000 +1200 | |
1796 | +++ linux-2.6.16.50/crypto/crypto_null.c 2006-07-14 18:10:31.187488750 +1200 | |
1797 | @@ -27,8 +27,8 @@ | |
1798 | #define NULL_BLOCK_SIZE 1 | |
1799 | #define NULL_DIGEST_SIZE 0 | |
1800 | ||
1801 | -static int null_compress(void *ctx, const u8 *src, unsigned int slen, | |
1802 | - u8 *dst, unsigned int *dlen) | |
1803 | +static int null_compress(struct crypto_tfm *tfm, const u8 *src, | |
1804 | + unsigned int slen, u8 *dst, unsigned int *dlen) | |
1805 | { | |
1806 | if (slen > *dlen) | |
1807 | return -EINVAL; | |
1808 | @@ -37,20 +37,21 @@ | |
1809 | return 0; | |
1810 | } | |
1811 | ||
1812 | -static void null_init(void *ctx) | |
1813 | +static void null_init(struct crypto_tfm *tfm) | |
1814 | { } | |
1815 | ||
1816 | -static void null_update(void *ctx, const u8 *data, unsigned int len) | |
1817 | +static void null_update(struct crypto_tfm *tfm, const u8 *data, | |
1818 | + unsigned int len) | |
1819 | { } | |
1820 | ||
1821 | -static void null_final(void *ctx, u8 *out) | |
1822 | +static void null_final(struct crypto_tfm *tfm, u8 *out) | |
1823 | { } | |
1824 | ||
1825 | -static int null_setkey(void *ctx, const u8 *key, | |
1826 | - unsigned int keylen, u32 *flags) | |
1827 | +static int null_setkey(struct crypto_tfm *tfm, const u8 *key, | |
1828 | + unsigned int keylen, u32 *flags) | |
1829 | { return 0; } | |
1830 | ||
1831 | -static void null_crypt(void *ctx, u8 *dst, const u8 *src) | |
1832 | +static void null_crypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
1833 | { | |
1834 | memcpy(dst, src, NULL_BLOCK_SIZE); | |
1835 | } | |
1836 | Index: linux-2.6.16.50/crypto/digest.c | |
1837 | =================================================================== | |
1838 | --- linux-2.6.16.50.orig/crypto/digest.c 2006-07-14 18:09:26.371438000 +1200 | |
1839 | +++ linux-2.6.16.50/crypto/digest.c 2006-07-14 18:10:31.191489000 +1200 | |
1840 | @@ -20,13 +20,14 @@ | |
1841 | ||
1842 | static void init(struct crypto_tfm *tfm) | |
1843 | { | |
1844 | - tfm->__crt_alg->cra_digest.dia_init(crypto_tfm_ctx(tfm)); | |
1845 | + tfm->__crt_alg->cra_digest.dia_init(tfm); | |
1846 | } | |
1847 | ||
1848 | static void update(struct crypto_tfm *tfm, | |
1849 | struct scatterlist *sg, unsigned int nsg) | |
1850 | { | |
1851 | unsigned int i; | |
1852 | + unsigned int alignmask = crypto_tfm_alg_alignmask(tfm); | |
1853 | ||
1854 | for (i = 0; i < nsg; i++) { | |
1855 | ||
1856 | @@ -38,12 +39,22 @@ | |
1857 | unsigned int bytes_from_page = min(l, ((unsigned int) | |
1858 | (PAGE_SIZE)) - | |
1859 | offset); | |
1860 | - char *p = crypto_kmap(pg, 0) + offset; | |
1861 | + char *src = crypto_kmap(pg, 0); | |
1862 | + char *p = src + offset; | |
1863 | ||
1864 | - tfm->__crt_alg->cra_digest.dia_update | |
1865 | - (crypto_tfm_ctx(tfm), p, | |
1866 | - bytes_from_page); | |
1867 | - crypto_kunmap(p, 0); | |
1868 | + if (unlikely(offset & alignmask)) { | |
1869 | + unsigned int bytes = | |
1870 | + alignmask + 1 - (offset & alignmask); | |
1871 | + bytes = min(bytes, bytes_from_page); | |
1872 | + tfm->__crt_alg->cra_digest.dia_update(tfm, p, | |
1873 | + bytes); | |
1874 | + p += bytes; | |
1875 | + bytes_from_page -= bytes; | |
1876 | + l -= bytes; | |
1877 | + } | |
1878 | + tfm->__crt_alg->cra_digest.dia_update(tfm, p, | |
1879 | + bytes_from_page); | |
1880 | + crypto_kunmap(src, 0); | |
1881 | crypto_yield(tfm); | |
1882 | offset = 0; | |
1883 | pg++; | |
1884 | @@ -54,7 +65,15 @@ | |
1885 | ||
1886 | static void final(struct crypto_tfm *tfm, u8 *out) | |
1887 | { | |
1888 | - tfm->__crt_alg->cra_digest.dia_final(crypto_tfm_ctx(tfm), out); | |
1889 | + unsigned long alignmask = crypto_tfm_alg_alignmask(tfm); | |
1890 | + if (unlikely((unsigned long)out & alignmask)) { | |
1891 | + unsigned int size = crypto_tfm_alg_digestsize(tfm); | |
1892 | + u8 buffer[size + alignmask]; | |
1893 | + u8 *dst = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1); | |
1894 | + tfm->__crt_alg->cra_digest.dia_final(tfm, dst); | |
1895 | + memcpy(out, dst, size); | |
1896 | + } else | |
1897 | + tfm->__crt_alg->cra_digest.dia_final(tfm, out); | |
1898 | } | |
1899 | ||
1900 | static int setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen) | |
1901 | @@ -62,25 +81,15 @@ | |
1902 | u32 flags; | |
1903 | if (tfm->__crt_alg->cra_digest.dia_setkey == NULL) | |
1904 | return -ENOSYS; | |
1905 | - return tfm->__crt_alg->cra_digest.dia_setkey(crypto_tfm_ctx(tfm), | |
1906 | - key, keylen, &flags); | |
1907 | + return tfm->__crt_alg->cra_digest.dia_setkey(tfm, key, keylen, &flags); | |
1908 | } | |
1909 | ||
1910 | static void digest(struct crypto_tfm *tfm, | |
1911 | struct scatterlist *sg, unsigned int nsg, u8 *out) | |
1912 | { | |
1913 | - unsigned int i; | |
1914 | - | |
1915 | - tfm->crt_digest.dit_init(tfm); | |
1916 | - | |
1917 | - for (i = 0; i < nsg; i++) { | |
1918 | - char *p = crypto_kmap(sg[i].page, 0) + sg[i].offset; | |
1919 | - tfm->__crt_alg->cra_digest.dia_update(crypto_tfm_ctx(tfm), | |
1920 | - p, sg[i].length); | |
1921 | - crypto_kunmap(p, 0); | |
1922 | - crypto_yield(tfm); | |
1923 | - } | |
1924 | - crypto_digest_final(tfm, out); | |
1925 | + init(tfm); | |
1926 | + update(tfm, sg, nsg); | |
1927 | + final(tfm, out); | |
1928 | } | |
1929 | ||
1930 | int crypto_init_digest_flags(struct crypto_tfm *tfm, u32 flags) | |
1931 | Index: linux-2.6.16.50/crypto/khazad.c | |
1932 | =================================================================== | |
1933 | --- linux-2.6.16.50.orig/crypto/khazad.c 2006-07-14 18:09:26.371438000 +1200 | |
1934 | +++ linux-2.6.16.50/crypto/khazad.c 2006-07-14 18:10:31.195489250 +1200 | |
1935 | @@ -754,11 +754,11 @@ | |
1936 | 0xccc41d14c363da5dULL, 0x5fdc7dcd7f5a6c5cULL, 0xf726ffede89d6f8eULL | |
1937 | }; | |
1938 | ||
1939 | -static int khazad_setkey(void *ctx_arg, const u8 *in_key, | |
1940 | - unsigned int key_len, u32 *flags) | |
1941 | +static int khazad_setkey(struct crypto_tfm *tfm, const u8 *in_key, | |
1942 | + unsigned int key_len, u32 *flags) | |
1943 | { | |
1944 | - struct khazad_ctx *ctx = ctx_arg; | |
1945 | - const __be64 *key = (const __be64 *)in_key; | |
1946 | + struct khazad_ctx *ctx = crypto_tfm_ctx(tfm); | |
1947 | + const __be32 *key = (const __be32 *)in_key; | |
1948 | int r; | |
1949 | const u64 *S = T7; | |
1950 | u64 K2, K1; | |
1951 | @@ -769,8 +769,9 @@ | |
1952 | return -EINVAL; | |
1953 | } | |
1954 | ||
1955 | - K2 = be64_to_cpu(key[0]); | |
1956 | - K1 = be64_to_cpu(key[1]); | |
1957 | + /* key is supposed to be 32-bit aligned */ | |
1958 | + K2 = ((u64)be32_to_cpu(key[0]) << 32) | be32_to_cpu(key[1]); | |
1959 | + K1 = ((u64)be32_to_cpu(key[2]) << 32) | be32_to_cpu(key[3]); | |
1960 | ||
1961 | /* setup the encrypt key */ | |
1962 | for (r = 0; r <= KHAZAD_ROUNDS; r++) { | |
1963 | @@ -840,15 +841,15 @@ | |
1964 | *dst = cpu_to_be64(state); | |
1965 | } | |
1966 | ||
1967 | -static void khazad_encrypt(void *ctx_arg, u8 *dst, const u8 *src) | |
1968 | +static void khazad_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
1969 | { | |
1970 | - struct khazad_ctx *ctx = ctx_arg; | |
1971 | + struct khazad_ctx *ctx = crypto_tfm_ctx(tfm); | |
1972 | khazad_crypt(ctx->E, dst, src); | |
1973 | } | |
1974 | ||
1975 | -static void khazad_decrypt(void *ctx_arg, u8 *dst, const u8 *src) | |
1976 | +static void khazad_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
1977 | { | |
1978 | - struct khazad_ctx *ctx = ctx_arg; | |
1979 | + struct khazad_ctx *ctx = crypto_tfm_ctx(tfm); | |
1980 | khazad_crypt(ctx->D, dst, src); | |
1981 | } | |
1982 | ||
1983 | Index: linux-2.6.16.50/crypto/md4.c | |
1984 | =================================================================== | |
1985 | --- linux-2.6.16.50.orig/crypto/md4.c 2006-07-14 18:09:26.375438250 +1200 | |
1986 | +++ linux-2.6.16.50/crypto/md4.c 2006-07-14 18:10:31.199489500 +1200 | |
1987 | @@ -152,9 +152,9 @@ | |
1988 | md4_transform(ctx->hash, ctx->block); | |
1989 | } | |
1990 | ||
1991 | -static void md4_init(void *ctx) | |
1992 | +static void md4_init(struct crypto_tfm *tfm) | |
1993 | { | |
1994 | - struct md4_ctx *mctx = ctx; | |
1995 | + struct md4_ctx *mctx = crypto_tfm_ctx(tfm); | |
1996 | ||
1997 | mctx->hash[0] = 0x67452301; | |
1998 | mctx->hash[1] = 0xefcdab89; | |
1999 | @@ -163,9 +163,9 @@ | |
2000 | mctx->byte_count = 0; | |
2001 | } | |
2002 | ||
2003 | -static void md4_update(void *ctx, const u8 *data, unsigned int len) | |
2004 | +static void md4_update(struct crypto_tfm *tfm, const u8 *data, unsigned int len) | |
2005 | { | |
2006 | - struct md4_ctx *mctx = ctx; | |
2007 | + struct md4_ctx *mctx = crypto_tfm_ctx(tfm); | |
2008 | const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f); | |
2009 | ||
2010 | mctx->byte_count += len; | |
2011 | @@ -193,9 +193,9 @@ | |
2012 | memcpy(mctx->block, data, len); | |
2013 | } | |
2014 | ||
2015 | -static void md4_final(void *ctx, u8 *out) | |
2016 | +static void md4_final(struct crypto_tfm *tfm, u8 *out) | |
2017 | { | |
2018 | - struct md4_ctx *mctx = ctx; | |
2019 | + struct md4_ctx *mctx = crypto_tfm_ctx(tfm); | |
2020 | const unsigned int offset = mctx->byte_count & 0x3f; | |
2021 | char *p = (char *)mctx->block + offset; | |
2022 | int padding = 56 - (offset + 1); | |
2023 | Index: linux-2.6.16.50/crypto/md5.c | |
2024 | =================================================================== | |
2025 | --- linux-2.6.16.50.orig/crypto/md5.c 2006-07-14 18:09:26.375438250 +1200 | |
2026 | +++ linux-2.6.16.50/crypto/md5.c 2006-07-14 18:10:31.199489500 +1200 | |
2027 | @@ -147,9 +147,9 @@ | |
2028 | md5_transform(ctx->hash, ctx->block); | |
2029 | } | |
2030 | ||
2031 | -static void md5_init(void *ctx) | |
2032 | +static void md5_init(struct crypto_tfm *tfm) | |
2033 | { | |
2034 | - struct md5_ctx *mctx = ctx; | |
2035 | + struct md5_ctx *mctx = crypto_tfm_ctx(tfm); | |
2036 | ||
2037 | mctx->hash[0] = 0x67452301; | |
2038 | mctx->hash[1] = 0xefcdab89; | |
2039 | @@ -158,9 +158,9 @@ | |
2040 | mctx->byte_count = 0; | |
2041 | } | |
2042 | ||
2043 | -static void md5_update(void *ctx, const u8 *data, unsigned int len) | |
2044 | +static void md5_update(struct crypto_tfm *tfm, const u8 *data, unsigned int len) | |
2045 | { | |
2046 | - struct md5_ctx *mctx = ctx; | |
2047 | + struct md5_ctx *mctx = crypto_tfm_ctx(tfm); | |
2048 | const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f); | |
2049 | ||
2050 | mctx->byte_count += len; | |
2051 | @@ -188,9 +188,9 @@ | |
2052 | memcpy(mctx->block, data, len); | |
2053 | } | |
2054 | ||
2055 | -static void md5_final(void *ctx, u8 *out) | |
2056 | +static void md5_final(struct crypto_tfm *tfm, u8 *out) | |
2057 | { | |
2058 | - struct md5_ctx *mctx = ctx; | |
2059 | + struct md5_ctx *mctx = crypto_tfm_ctx(tfm); | |
2060 | const unsigned int offset = mctx->byte_count & 0x3f; | |
2061 | char *p = (char *)mctx->block + offset; | |
2062 | int padding = 56 - (offset + 1); | |
2063 | Index: linux-2.6.16.50/crypto/michael_mic.c | |
2064 | =================================================================== | |
2065 | --- linux-2.6.16.50.orig/crypto/michael_mic.c 2006-07-14 18:09:26.375438250 +1200 | |
2066 | +++ linux-2.6.16.50/crypto/michael_mic.c 2006-07-14 18:10:31.203489750 +1200 | |
2067 | @@ -45,16 +45,17 @@ | |
2068 | } while (0) | |
2069 | ||
2070 | ||
2071 | -static void michael_init(void *ctx) | |
2072 | +static void michael_init(struct crypto_tfm *tfm) | |
2073 | { | |
2074 | - struct michael_mic_ctx *mctx = ctx; | |
2075 | + struct michael_mic_ctx *mctx = crypto_tfm_ctx(tfm); | |
2076 | mctx->pending_len = 0; | |
2077 | } | |
2078 | ||
2079 | ||
2080 | -static void michael_update(void *ctx, const u8 *data, unsigned int len) | |
2081 | +static void michael_update(struct crypto_tfm *tfm, const u8 *data, | |
2082 | + unsigned int len) | |
2083 | { | |
2084 | - struct michael_mic_ctx *mctx = ctx; | |
2085 | + struct michael_mic_ctx *mctx = crypto_tfm_ctx(tfm); | |
2086 | const __le32 *src; | |
2087 | ||
2088 | if (mctx->pending_len) { | |
2089 | @@ -90,9 +91,9 @@ | |
2090 | } | |
2091 | ||
2092 | ||
2093 | -static void michael_final(void *ctx, u8 *out) | |
2094 | +static void michael_final(struct crypto_tfm *tfm, u8 *out) | |
2095 | { | |
2096 | - struct michael_mic_ctx *mctx = ctx; | |
2097 | + struct michael_mic_ctx *mctx = crypto_tfm_ctx(tfm); | |
2098 | u8 *data = mctx->pending; | |
2099 | __le32 *dst = (__le32 *)out; | |
2100 | ||
2101 | @@ -121,10 +122,10 @@ | |
2102 | } | |
2103 | ||
2104 | ||
2105 | -static int michael_setkey(void *ctx, const u8 *key, unsigned int keylen, | |
2106 | - u32 *flags) | |
2107 | +static int michael_setkey(struct crypto_tfm *tfm, const u8 *key, | |
2108 | + unsigned int keylen, u32 *flags) | |
2109 | { | |
2110 | - struct michael_mic_ctx *mctx = ctx; | |
2111 | + struct michael_mic_ctx *mctx = crypto_tfm_ctx(tfm); | |
2112 | const __le32 *data = (const __le32 *)key; | |
2113 | ||
2114 | if (keylen != 8) { | |
2115 | @@ -145,6 +146,7 @@ | |
2116 | .cra_blocksize = 8, | |
2117 | .cra_ctxsize = sizeof(struct michael_mic_ctx), | |
2118 | .cra_module = THIS_MODULE, | |
2119 | + .cra_alignmask = 3, | |
2120 | .cra_list = LIST_HEAD_INIT(michael_mic_alg.cra_list), | |
2121 | .cra_u = { .digest = { | |
2122 | .dia_digestsize = 8, | |
2123 | Index: linux-2.6.16.50/crypto/sha1.c | |
2124 | =================================================================== | |
2125 | --- linux-2.6.16.50.orig/crypto/sha1.c 2006-07-14 18:09:26.379438500 +1200 | |
2126 | +++ linux-2.6.16.50/crypto/sha1.c 2006-07-18 01:35:17.455238201 +1200 | |
2127 | @@ -34,9 +34,9 @@ | |
2128 | u8 buffer[64]; | |
2129 | }; | |
2130 | ||
2131 | -static void sha1_init(void *ctx) | |
2132 | +static void sha1_init(struct crypto_tfm *tfm) | |
2133 | { | |
2134 | - struct sha1_ctx *sctx = ctx; | |
2135 | + struct sha1_ctx *sctx = crypto_tfm_ctx(tfm); | |
2136 | static const struct sha1_ctx initstate = { | |
2137 | 0, | |
2138 | { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 }, | |
2139 | @@ -46,9 +46,10 @@ | |
2140 | *sctx = initstate; | |
2141 | } | |
2142 | ||
2143 | -static void sha1_update(void *ctx, const u8 *data, unsigned int len) | |
2144 | +static void sha1_update(struct crypto_tfm *tfm, const u8 *data, | |
2145 | + unsigned int len) | |
2146 | { | |
2147 | - struct sha1_ctx *sctx = ctx; | |
2148 | + struct sha1_ctx *sctx = crypto_tfm_ctx(tfm); | |
2149 | unsigned int partial, done; | |
2150 | const u8 *src; | |
2151 | ||
2152 | @@ -80,9 +81,9 @@ | |
2153 | ||
2154 | ||
2155 | /* Add padding and return the message digest. */ | |
2156 | -static void sha1_final(void* ctx, u8 *out) | |
2157 | +static void sha1_final(struct crypto_tfm *tfm, u8 *out) | |
2158 | { | |
2159 | - struct sha1_ctx *sctx = ctx; | |
2160 | + struct sha1_ctx *sctx = crypto_tfm_ctx(tfm); | |
2161 | __be32 *dst = (__be32 *)out; | |
2162 | u32 i, index, padlen; | |
2163 | __be64 bits; | |
2164 | @@ -93,10 +94,10 @@ | |
2165 | /* Pad out to 56 mod 64 */ | |
2166 | index = sctx->count & 0x3f; | |
2167 | padlen = (index < 56) ? (56 - index) : ((64+56) - index); | |
2168 | - sha1_update(sctx, padding, padlen); | |
2169 | + sha1_update(tfm, padding, padlen); | |
2170 | ||
2171 | /* Append length */ | |
2172 | - sha1_update(sctx, (const u8 *)&bits, sizeof(bits)); | |
2173 | + sha1_update(tfm, (const u8 *)&bits, sizeof(bits)); | |
2174 | ||
2175 | /* Store state in digest */ | |
2176 | for (i = 0; i < 5; i++) | |
2177 | @@ -112,6 +113,7 @@ | |
2178 | .cra_blocksize = SHA1_HMAC_BLOCK_SIZE, | |
2179 | .cra_ctxsize = sizeof(struct sha1_ctx), | |
2180 | .cra_module = THIS_MODULE, | |
2181 | + .cra_alignmask = 3, | |
2182 | .cra_list = LIST_HEAD_INIT(alg.cra_list), | |
2183 | .cra_u = { .digest = { | |
2184 | .dia_digestsize = SHA1_DIGEST_SIZE, | |
2185 | Index: linux-2.6.16.50/crypto/sha256.c | |
2186 | =================================================================== | |
2187 | --- linux-2.6.16.50.orig/crypto/sha256.c 2006-07-14 18:09:26.379438500 +1200 | |
2188 | +++ linux-2.6.16.50/crypto/sha256.c 2006-07-18 01:35:17.455238201 +1200 | |
2189 | @@ -230,9 +230,9 @@ | |
2190 | memset(W, 0, 64 * sizeof(u32)); | |
2191 | } | |
2192 | ||
2193 | -static void sha256_init(void *ctx) | |
2194 | +static void sha256_init(struct crypto_tfm *tfm) | |
2195 | { | |
2196 | - struct sha256_ctx *sctx = ctx; | |
2197 | + struct sha256_ctx *sctx = crypto_tfm_ctx(tfm); | |
2198 | sctx->state[0] = H0; | |
2199 | sctx->state[1] = H1; | |
2200 | sctx->state[2] = H2; | |
2201 | @@ -242,12 +242,12 @@ | |
2202 | sctx->state[6] = H6; | |
2203 | sctx->state[7] = H7; | |
2204 | sctx->count[0] = sctx->count[1] = 0; | |
2205 | - memset(sctx->buf, 0, sizeof(sctx->buf)); | |
2206 | } | |
2207 | ||
2208 | -static void sha256_update(void *ctx, const u8 *data, unsigned int len) | |
2209 | +static void sha256_update(struct crypto_tfm *tfm, const u8 *data, | |
2210 | + unsigned int len) | |
2211 | { | |
2212 | - struct sha256_ctx *sctx = ctx; | |
2213 | + struct sha256_ctx *sctx = crypto_tfm_ctx(tfm); | |
2214 | unsigned int i, index, part_len; | |
2215 | ||
2216 | /* Compute number of bytes mod 128 */ | |
2217 | @@ -277,9 +277,9 @@ | |
2218 | memcpy(&sctx->buf[index], &data[i], len-i); | |
2219 | } | |
2220 | ||
2221 | -static void sha256_final(void* ctx, u8 *out) | |
2222 | +static void sha256_final(struct crypto_tfm *tfm, u8 *out) | |
2223 | { | |
2224 | - struct sha256_ctx *sctx = ctx; | |
2225 | + struct sha256_ctx *sctx = crypto_tfm_ctx(tfm); | |
2226 | __be32 *dst = (__be32 *)out; | |
2227 | __be32 bits[2]; | |
2228 | unsigned int index, pad_len; | |
2229 | @@ -293,10 +293,10 @@ | |
2230 | /* Pad out to 56 mod 64. */ | |
2231 | index = (sctx->count[0] >> 3) & 0x3f; | |
2232 | pad_len = (index < 56) ? (56 - index) : ((64+56) - index); | |
2233 | - sha256_update(sctx, padding, pad_len); | |
2234 | + sha256_update(tfm, padding, pad_len); | |
2235 | ||
2236 | /* Append length (before padding) */ | |
2237 | - sha256_update(sctx, (const u8 *)bits, sizeof(bits)); | |
2238 | + sha256_update(tfm, (const u8 *)bits, sizeof(bits)); | |
2239 | ||
2240 | /* Store state in digest */ | |
2241 | for (i = 0; i < 8; i++) | |
2242 | @@ -313,6 +313,7 @@ | |
2243 | .cra_blocksize = SHA256_HMAC_BLOCK_SIZE, | |
2244 | .cra_ctxsize = sizeof(struct sha256_ctx), | |
2245 | .cra_module = THIS_MODULE, | |
2246 | + .cra_alignmask = 3, | |
2247 | .cra_list = LIST_HEAD_INIT(alg.cra_list), | |
2248 | .cra_u = { .digest = { | |
2249 | .dia_digestsize = SHA256_DIGEST_SIZE, | |
2250 | Index: linux-2.6.16.50/crypto/sha512.c | |
2251 | =================================================================== | |
2252 | --- linux-2.6.16.50.orig/crypto/sha512.c 2006-07-14 18:09:26.379438500 +1200 | |
2253 | +++ linux-2.6.16.50/crypto/sha512.c 2006-07-14 18:10:31.211490250 +1200 | |
2254 | @@ -161,9 +161,9 @@ | |
2255 | } | |
2256 | ||
2257 | static void | |
2258 | -sha512_init(void *ctx) | |
2259 | +sha512_init(struct crypto_tfm *tfm) | |
2260 | { | |
2261 | - struct sha512_ctx *sctx = ctx; | |
2262 | + struct sha512_ctx *sctx = crypto_tfm_ctx(tfm); | |
2263 | sctx->state[0] = H0; | |
2264 | sctx->state[1] = H1; | |
2265 | sctx->state[2] = H2; | |
2266 | @@ -173,13 +173,12 @@ | |
2267 | sctx->state[6] = H6; | |
2268 | sctx->state[7] = H7; | |
2269 | sctx->count[0] = sctx->count[1] = sctx->count[2] = sctx->count[3] = 0; | |
2270 | - memset(sctx->buf, 0, sizeof(sctx->buf)); | |
2271 | } | |
2272 | ||
2273 | static void | |
2274 | -sha384_init(void *ctx) | |
2275 | +sha384_init(struct crypto_tfm *tfm) | |
2276 | { | |
2277 | - struct sha512_ctx *sctx = ctx; | |
2278 | + struct sha512_ctx *sctx = crypto_tfm_ctx(tfm); | |
2279 | sctx->state[0] = HP0; | |
2280 | sctx->state[1] = HP1; | |
2281 | sctx->state[2] = HP2; | |
2282 | @@ -189,13 +188,12 @@ | |
2283 | sctx->state[6] = HP6; | |
2284 | sctx->state[7] = HP7; | |
2285 | sctx->count[0] = sctx->count[1] = sctx->count[2] = sctx->count[3] = 0; | |
2286 | - memset(sctx->buf, 0, sizeof(sctx->buf)); | |
2287 | } | |
2288 | ||
2289 | static void | |
2290 | -sha512_update(void *ctx, const u8 *data, unsigned int len) | |
2291 | +sha512_update(struct crypto_tfm *tfm, const u8 *data, unsigned int len) | |
2292 | { | |
2293 | - struct sha512_ctx *sctx = ctx; | |
2294 | + struct sha512_ctx *sctx = crypto_tfm_ctx(tfm); | |
2295 | ||
2296 | unsigned int i, index, part_len; | |
2297 | ||
2298 | @@ -233,9 +231,9 @@ | |
2299 | } | |
2300 | ||
2301 | static void | |
2302 | -sha512_final(void *ctx, u8 *hash) | |
2303 | +sha512_final(struct crypto_tfm *tfm, u8 *hash) | |
2304 | { | |
2305 | - struct sha512_ctx *sctx = ctx; | |
2306 | + struct sha512_ctx *sctx = crypto_tfm_ctx(tfm); | |
2307 | static u8 padding[128] = { 0x80, }; | |
2308 | __be64 *dst = (__be64 *)hash; | |
2309 | __be32 bits[4]; | |
2310 | @@ -251,10 +249,10 @@ | |
2311 | /* Pad out to 112 mod 128. */ | |
2312 | index = (sctx->count[0] >> 3) & 0x7f; | |
2313 | pad_len = (index < 112) ? (112 - index) : ((128+112) - index); | |
2314 | - sha512_update(sctx, padding, pad_len); | |
2315 | + sha512_update(tfm, padding, pad_len); | |
2316 | ||
2317 | /* Append length (before padding) */ | |
2318 | - sha512_update(sctx, (const u8 *)bits, sizeof(bits)); | |
2319 | + sha512_update(tfm, (const u8 *)bits, sizeof(bits)); | |
2320 | ||
2321 | /* Store state in digest */ | |
2322 | for (i = 0; i < 8; i++) | |
2323 | @@ -264,12 +262,11 @@ | |
2324 | memset(sctx, 0, sizeof(struct sha512_ctx)); | |
2325 | } | |
2326 | ||
2327 | -static void sha384_final(void *ctx, u8 *hash) | |
2328 | +static void sha384_final(struct crypto_tfm *tfm, u8 *hash) | |
2329 | { | |
2330 | - struct sha512_ctx *sctx = ctx; | |
2331 | u8 D[64]; | |
2332 | ||
2333 | - sha512_final(sctx, D); | |
2334 | + sha512_final(tfm, D); | |
2335 | ||
2336 | memcpy(hash, D, 48); | |
2337 | memset(D, 0, 64); | |
2338 | @@ -281,6 +278,7 @@ | |
2339 | .cra_blocksize = SHA512_HMAC_BLOCK_SIZE, | |
2340 | .cra_ctxsize = sizeof(struct sha512_ctx), | |
2341 | .cra_module = THIS_MODULE, | |
2342 | + .cra_alignmask = 3, | |
2343 | .cra_list = LIST_HEAD_INIT(sha512.cra_list), | |
2344 | .cra_u = { .digest = { | |
2345 | .dia_digestsize = SHA512_DIGEST_SIZE, | |
2346 | @@ -295,6 +293,7 @@ | |
2347 | .cra_flags = CRYPTO_ALG_TYPE_DIGEST, | |
2348 | .cra_blocksize = SHA384_HMAC_BLOCK_SIZE, | |
2349 | .cra_ctxsize = sizeof(struct sha512_ctx), | |
2350 | + .cra_alignmask = 3, | |
2351 | .cra_module = THIS_MODULE, | |
2352 | .cra_list = LIST_HEAD_INIT(sha384.cra_list), | |
2353 | .cra_u = { .digest = { | |
2354 | Index: linux-2.6.16.50/crypto/tcrypt.c | |
2355 | =================================================================== | |
2356 | --- linux-2.6.16.50.orig/crypto/tcrypt.c 2006-07-14 18:09:26.379438500 +1200 | |
2357 | +++ linux-2.6.16.50/crypto/tcrypt.c 2006-07-18 01:36:18.591058951 +1200 | |
2358 | @@ -570,6 +570,122 @@ | |
2359 | crypto_free_tfm(tfm); | |
2360 | } | |
2361 | ||
2362 | +static void test_digest_jiffies(struct crypto_tfm *tfm, char *p, int blen, | |
2363 | + int plen, char *out, int sec) | |
2364 | +{ | |
2365 | + struct scatterlist sg[1]; | |
2366 | + unsigned long start, end; | |
2367 | + int bcount, pcount; | |
2368 | + | |
2369 | + for (start = jiffies, end = start + sec * HZ, bcount = 0; | |
2370 | + time_before(jiffies, end); bcount++) { | |
2371 | + crypto_digest_init(tfm); | |
2372 | + for (pcount = 0; pcount < blen; pcount += plen) { | |
2373 | + sg_set_buf(sg, p + pcount, plen); | |
2374 | + crypto_digest_update(tfm, sg, 1); | |
2375 | + } | |
2376 | + /* we assume there is enough space in 'out' for the result */ | |
2377 | + crypto_digest_final(tfm, out); | |
2378 | + } | |
2379 | + | |
2380 | + printk("%6u opers/sec, %9lu bytes/sec\n", | |
2381 | + bcount / sec, ((long)bcount * blen) / sec); | |
2382 | + | |
2383 | + return; | |
2384 | +} | |
2385 | + | |
2386 | +static void test_digest_cycles(struct crypto_tfm *tfm, char *p, int blen, | |
2387 | + int plen, char *out) | |
2388 | +{ | |
2389 | + struct scatterlist sg[1]; | |
2390 | + unsigned long cycles = 0; | |
2391 | + int i, pcount; | |
2392 | + | |
2393 | + local_bh_disable(); | |
2394 | + local_irq_disable(); | |
2395 | + | |
2396 | + /* Warm-up run. */ | |
2397 | + for (i = 0; i < 4; i++) { | |
2398 | + crypto_digest_init(tfm); | |
2399 | + for (pcount = 0; pcount < blen; pcount += plen) { | |
2400 | + sg_set_buf(sg, p + pcount, plen); | |
2401 | + crypto_digest_update(tfm, sg, 1); | |
2402 | + } | |
2403 | + crypto_digest_final(tfm, out); | |
2404 | + } | |
2405 | + | |
2406 | + /* The real thing. */ | |
2407 | + for (i = 0; i < 8; i++) { | |
2408 | + cycles_t start, end; | |
2409 | + | |
2410 | + crypto_digest_init(tfm); | |
2411 | + | |
2412 | + start = get_cycles(); | |
2413 | + | |
2414 | + for (pcount = 0; pcount < blen; pcount += plen) { | |
2415 | + sg_set_buf(sg, p + pcount, plen); | |
2416 | + crypto_digest_update(tfm, sg, 1); | |
2417 | + } | |
2418 | + crypto_digest_final(tfm, out); | |
2419 | + | |
2420 | + end = get_cycles(); | |
2421 | + | |
2422 | + cycles += end - start; | |
2423 | + } | |
2424 | + | |
2425 | + local_irq_enable(); | |
2426 | + local_bh_enable(); | |
2427 | + | |
2428 | + printk("%6lu cycles/operation, %4lu cycles/byte\n", | |
2429 | + cycles / 8, cycles / (8 * blen)); | |
2430 | + | |
2431 | + return; | |
2432 | +} | |
2433 | + | |
2434 | +static void test_digest_speed(char *algo, unsigned int sec, | |
2435 | + struct digest_speed *speed) | |
2436 | +{ | |
2437 | + struct crypto_tfm *tfm; | |
2438 | + char output[1024]; | |
2439 | + int i; | |
2440 | + | |
2441 | + printk("\ntesting speed of %s\n", algo); | |
2442 | + | |
2443 | + tfm = crypto_alloc_tfm(algo, 0); | |
2444 | + | |
2445 | + if (tfm == NULL) { | |
2446 | + printk("failed to load transform for %s\n", algo); | |
2447 | + return; | |
2448 | + } | |
2449 | + | |
2450 | + if (crypto_tfm_alg_digestsize(tfm) > sizeof(output)) { | |
2451 | + printk("digestsize(%u) > outputbuffer(%zu)\n", | |
2452 | + crypto_tfm_alg_digestsize(tfm), sizeof(output)); | |
2453 | + goto out; | |
2454 | + } | |
2455 | + | |
2456 | + for (i = 0; speed[i].blen != 0; i++) { | |
2457 | + if (speed[i].blen > TVMEMSIZE) { | |
2458 | + printk("template (%u) too big for tvmem (%u)\n", | |
2459 | + speed[i].blen, TVMEMSIZE); | |
2460 | + goto out; | |
2461 | + } | |
2462 | + | |
2463 | + printk("test%3u (%5u byte blocks,%5u bytes per update,%4u updates): ", | |
2464 | + i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen); | |
2465 | + | |
2466 | + memset(tvmem, 0xff, speed[i].blen); | |
2467 | + | |
2468 | + if (sec) | |
2469 | + test_digest_jiffies(tfm, tvmem, speed[i].blen, speed[i].plen, output, sec); | |
2470 | + else | |
2471 | + test_digest_cycles(tfm, tvmem, speed[i].blen, speed[i].plen, output); | |
2472 | + } | |
2473 | + | |
2474 | +out: | |
2475 | + crypto_free_tfm(tfm); | |
2476 | +} | |
2477 | + | |
2478 | static void test_deflate(void) | |
2479 | { | |
2480 | unsigned int i; | |
2481 | @@ -1086,6 +1202,60 @@ | |
2482 | des_speed_template); | |
2483 | break; | |
2484 | ||
2485 | + case 300: | |
2486 | + /* fall through */ | |
2487 | + | |
2488 | + case 301: | |
2489 | + test_digest_speed("md4", sec, generic_digest_speed_template); | |
2490 | + if (mode > 300 && mode < 400) break; | |
2491 | + | |
2492 | + case 302: | |
2493 | + test_digest_speed("md5", sec, generic_digest_speed_template); | |
2494 | + if (mode > 300 && mode < 400) break; | |
2495 | + | |
2496 | + case 303: | |
2497 | + test_digest_speed("sha1", sec, generic_digest_speed_template); | |
2498 | + if (mode > 300 && mode < 400) break; | |
2499 | + | |
2500 | + case 304: | |
2501 | + test_digest_speed("sha256", sec, generic_digest_speed_template); | |
2502 | + if (mode > 300 && mode < 400) break; | |
2503 | + | |
2504 | + case 305: | |
2505 | + test_digest_speed("sha384", sec, generic_digest_speed_template); | |
2506 | + if (mode > 300 && mode < 400) break; | |
2507 | + | |
2508 | + case 306: | |
2509 | + test_digest_speed("sha512", sec, generic_digest_speed_template); | |
2510 | + if (mode > 300 && mode < 400) break; | |
2511 | + | |
2512 | + case 307: | |
2513 | + test_digest_speed("wp256", sec, generic_digest_speed_template); | |
2514 | + if (mode > 300 && mode < 400) break; | |
2515 | + | |
2516 | + case 308: | |
2517 | + test_digest_speed("wp384", sec, generic_digest_speed_template); | |
2518 | + if (mode > 300 && mode < 400) break; | |
2519 | + | |
2520 | + case 309: | |
2521 | + test_digest_speed("wp512", sec, generic_digest_speed_template); | |
2522 | + if (mode > 300 && mode < 400) break; | |
2523 | + | |
2524 | + case 310: | |
2525 | + test_digest_speed("tgr128", sec, generic_digest_speed_template); | |
2526 | + if (mode > 300 && mode < 400) break; | |
2527 | + | |
2528 | + case 311: | |
2529 | + test_digest_speed("tgr160", sec, generic_digest_speed_template); | |
2530 | + if (mode > 300 && mode < 400) break; | |
2531 | + | |
2532 | + case 312: | |
2533 | + test_digest_speed("tgr192", sec, generic_digest_speed_template); | |
2534 | + if (mode > 300 && mode < 400) break; | |
2535 | + | |
2536 | + case 399: | |
2537 | + break; | |
2538 | + | |
2539 | case 1000: | |
2540 | test_available(); | |
2541 | break; | |
2542 | @@ -1113,7 +1283,14 @@ | |
2543 | ||
2544 | kfree(xbuf); | |
2545 | kfree(tvmem); | |
2546 | - return 0; | |
2547 | + | |
2548 | + /* We intentionaly return -EAGAIN to prevent keeping | |
2549 | + * the module. It does all its work from init() | |
2550 | + * and doesn't offer any runtime functionality | |
2551 | + * => we don't need it in the memory, do we? | |
2552 | + * -- mludvig | |
2553 | + */ | |
2554 | + return -EAGAIN; | |
2555 | } | |
2556 | ||
2557 | /* | |
2558 | Index: linux-2.6.16.50/crypto/tea.c | |
2559 | =================================================================== | |
2560 | --- linux-2.6.16.50.orig/crypto/tea.c 2006-07-14 18:09:26.383438750 +1200 | |
2561 | +++ linux-2.6.16.50/crypto/tea.c 2006-07-14 18:10:31.223491000 +1200 | |
2562 | @@ -45,10 +45,10 @@ | |
2563 | u32 KEY[4]; | |
2564 | }; | |
2565 | ||
2566 | -static int tea_setkey(void *ctx_arg, const u8 *in_key, | |
2567 | - unsigned int key_len, u32 *flags) | |
2568 | -{ | |
2569 | - struct tea_ctx *ctx = ctx_arg; | |
2570 | +static int tea_setkey(struct crypto_tfm *tfm, const u8 *in_key, | |
2571 | + unsigned int key_len, u32 *flags) | |
2572 | +{ | |
2573 | + struct tea_ctx *ctx = crypto_tfm_ctx(tfm); | |
2574 | const __le32 *key = (const __le32 *)in_key; | |
2575 | ||
2576 | if (key_len != 16) | |
2577 | @@ -66,12 +66,11 @@ | |
2578 | ||
2579 | } | |
2580 | ||
2581 | -static void tea_encrypt(void *ctx_arg, u8 *dst, const u8 *src) | |
2582 | -{ | |
2583 | +static void tea_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
2584 | +{ | |
2585 | u32 y, z, n, sum = 0; | |
2586 | u32 k0, k1, k2, k3; | |
2587 | - | |
2588 | - struct tea_ctx *ctx = ctx_arg; | |
2589 | + struct tea_ctx *ctx = crypto_tfm_ctx(tfm); | |
2590 | const __le32 *in = (const __le32 *)src; | |
2591 | __le32 *out = (__le32 *)dst; | |
2592 | ||
2593 | @@ -95,11 +94,11 @@ | |
2594 | out[1] = cpu_to_le32(z); | |
2595 | } | |
2596 | ||
2597 | -static void tea_decrypt(void *ctx_arg, u8 *dst, const u8 *src) | |
2598 | -{ | |
2599 | +static void tea_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
2600 | +{ | |
2601 | u32 y, z, n, sum; | |
2602 | u32 k0, k1, k2, k3; | |
2603 | - struct tea_ctx *ctx = ctx_arg; | |
2604 | + struct tea_ctx *ctx = crypto_tfm_ctx(tfm); | |
2605 | const __le32 *in = (const __le32 *)src; | |
2606 | __le32 *out = (__le32 *)dst; | |
2607 | ||
2608 | @@ -125,10 +124,10 @@ | |
2609 | out[1] = cpu_to_le32(z); | |
2610 | } | |
2611 | ||
2612 | -static int xtea_setkey(void *ctx_arg, const u8 *in_key, | |
2613 | - unsigned int key_len, u32 *flags) | |
2614 | -{ | |
2615 | - struct xtea_ctx *ctx = ctx_arg; | |
2616 | +static int xtea_setkey(struct crypto_tfm *tfm, const u8 *in_key, | |
2617 | + unsigned int key_len, u32 *flags) | |
2618 | +{ | |
2619 | + struct xtea_ctx *ctx = crypto_tfm_ctx(tfm); | |
2620 | const __le32 *key = (const __le32 *)in_key; | |
2621 | ||
2622 | if (key_len != 16) | |
2623 | @@ -146,12 +145,11 @@ | |
2624 | ||
2625 | } | |
2626 | ||
2627 | -static void xtea_encrypt(void *ctx_arg, u8 *dst, const u8 *src) | |
2628 | -{ | |
2629 | +static void xtea_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
2630 | +{ | |
2631 | u32 y, z, sum = 0; | |
2632 | u32 limit = XTEA_DELTA * XTEA_ROUNDS; | |
2633 | - | |
2634 | - struct xtea_ctx *ctx = ctx_arg; | |
2635 | + struct xtea_ctx *ctx = crypto_tfm_ctx(tfm); | |
2636 | const __le32 *in = (const __le32 *)src; | |
2637 | __le32 *out = (__le32 *)dst; | |
2638 | ||
2639 | @@ -168,10 +166,10 @@ | |
2640 | out[1] = cpu_to_le32(z); | |
2641 | } | |
2642 | ||
2643 | -static void xtea_decrypt(void *ctx_arg, u8 *dst, const u8 *src) | |
2644 | -{ | |
2645 | +static void xtea_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
2646 | +{ | |
2647 | u32 y, z, sum; | |
2648 | - struct tea_ctx *ctx = ctx_arg; | |
2649 | + struct tea_ctx *ctx = crypto_tfm_ctx(tfm); | |
2650 | const __le32 *in = (const __le32 *)src; | |
2651 | __le32 *out = (__le32 *)dst; | |
2652 | ||
2653 | @@ -191,12 +189,11 @@ | |
2654 | } | |
2655 | ||
2656 | ||
2657 | -static void xeta_encrypt(void *ctx_arg, u8 *dst, const u8 *src) | |
2658 | -{ | |
2659 | +static void xeta_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
2660 | +{ | |
2661 | u32 y, z, sum = 0; | |
2662 | u32 limit = XTEA_DELTA * XTEA_ROUNDS; | |
2663 | - | |
2664 | - struct xtea_ctx *ctx = ctx_arg; | |
2665 | + struct xtea_ctx *ctx = crypto_tfm_ctx(tfm); | |
2666 | const __le32 *in = (const __le32 *)src; | |
2667 | __le32 *out = (__le32 *)dst; | |
2668 | ||
2669 | @@ -213,10 +210,10 @@ | |
2670 | out[1] = cpu_to_le32(z); | |
2671 | } | |
2672 | ||
2673 | -static void xeta_decrypt(void *ctx_arg, u8 *dst, const u8 *src) | |
2674 | -{ | |
2675 | +static void xeta_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) | |
2676 | +{ | |
2677 | u32 y, z, sum; | |
2678 | - struct tea_ctx *ctx = ctx_arg; | |
2679 | + struct tea_ctx *ctx = crypto_tfm_ctx(tfm); | |
2680 | const __le32 *in = (const __le32 *)src; | |
2681 | __le32 *out = (__le32 *)dst; | |
2682 | ||
2683 | Index: linux-2.6.16.50/crypto/tgr192.c | |
2684 | =================================================================== | |
2685 | --- linux-2.6.16.50.orig/crypto/tgr192.c 2006-07-14 18:09:26.383438750 +1200 | |
2686 | +++ linux-2.6.16.50/crypto/tgr192.c 2006-07-14 18:10:31.227491250 +1200 | |
2687 | @@ -496,11 +496,10 @@ | |
2688 | tctx->c = c; | |
2689 | } | |
2690 | ||
2691 | -static void tgr192_init(void *ctx) | |
2692 | +static void tgr192_init(struct crypto_tfm *tfm) | |
2693 | { | |
2694 | - struct tgr192_ctx *tctx = ctx; | |
2695 | + struct tgr192_ctx *tctx = crypto_tfm_ctx(tfm); | |
2696 | ||
2697 | - memset (tctx->hash, 0, 64); | |
2698 | tctx->a = 0x0123456789abcdefULL; | |
2699 | tctx->b = 0xfedcba9876543210ULL; | |
2700 | tctx->c = 0xf096a5b4c3b2e187ULL; | |
2701 | @@ -511,9 +510,10 @@ | |
2702 | ||
2703 | /* Update the message digest with the contents | |
2704 | * of INBUF with length INLEN. */ | |
2705 | -static void tgr192_update(void *ctx, const u8 * inbuf, unsigned int len) | |
2706 | +static void tgr192_update(struct crypto_tfm *tfm, const u8 *inbuf, | |
2707 | + unsigned int len) | |
2708 | { | |
2709 | - struct tgr192_ctx *tctx = ctx; | |
2710 | + struct tgr192_ctx *tctx = crypto_tfm_ctx(tfm); | |
2711 | ||
2712 | if (tctx->count == 64) { /* flush the buffer */ | |
2713 | tgr192_transform(tctx, tctx->hash); | |
2714 | @@ -527,7 +527,7 @@ | |
2715 | for (; len && tctx->count < 64; len--) { | |
2716 | tctx->hash[tctx->count++] = *inbuf++; | |
2717 | } | |
2718 | - tgr192_update(tctx, NULL, 0); | |
2719 | + tgr192_update(tfm, NULL, 0); | |
2720 | if (!len) { | |
2721 | return; | |
2722 | } | |
2723 | @@ -549,15 +549,15 @@ | |
2724 | ||
2725 | ||
2726 | /* The routine terminates the computation */ | |
2727 | -static void tgr192_final(void *ctx, u8 * out) | |
2728 | +static void tgr192_final(struct crypto_tfm *tfm, u8 * out) | |
2729 | { | |
2730 | - struct tgr192_ctx *tctx = ctx; | |
2731 | + struct tgr192_ctx *tctx = crypto_tfm_ctx(tfm); | |
2732 | __be64 *dst = (__be64 *)out; | |
2733 | __be64 *be64p; | |
2734 | __le32 *le32p; | |
2735 | u32 t, msb, lsb; | |
2736 | ||
2737 | - tgr192_update(tctx, NULL, 0); /* flush */ ; | |
2738 | + tgr192_update(tfm, NULL, 0); /* flush */ ; | |
2739 | ||
2740 | msb = 0; | |
2741 | t = tctx->nblocks; | |
2742 | @@ -585,7 +585,7 @@ | |
2743 | while (tctx->count < 64) { | |
2744 | tctx->hash[tctx->count++] = 0; | |
2745 | } | |
2746 | - tgr192_update(tctx, NULL, 0); /* flush */ ; | |
2747 | + tgr192_update(tfm, NULL, 0); /* flush */ ; | |
2748 | memset(tctx->hash, 0, 56); /* fill next block with zeroes */ | |
2749 | } | |
2750 | /* append the 64 bit count */ | |
2751 | @@ -601,22 +601,20 @@ | |
2752 | dst[2] = be64p[2] = cpu_to_be64(tctx->c); | |
2753 | } | |
2754 | ||
2755 | -static void tgr160_final(void *ctx, u8 * out) | |
2756 | +static void tgr160_final(struct crypto_tfm *tfm, u8 * out) | |
2757 | { | |
2758 | - struct tgr192_ctx *wctx = ctx; | |
2759 | u8 D[64]; | |
2760 | ||
2761 | - tgr192_final(wctx, D); | |
2762 | + tgr192_final(tfm, D); | |
2763 | memcpy(out, D, TGR160_DIGEST_SIZE); | |
2764 | memset(D, 0, TGR192_DIGEST_SIZE); | |
2765 | } | |
2766 | ||
2767 | -static void tgr128_final(void *ctx, u8 * out) | |
2768 | +static void tgr128_final(struct crypto_tfm *tfm, u8 * out) | |
2769 | { | |
2770 | - struct tgr192_ctx *wctx = ctx; | |
2771 | u8 D[64]; | |
2772 | ||
2773 | - tgr192_final(wctx, D); | |
2774 | + tgr192_final(tfm, D); | |
2775 | memcpy(out, D, TGR128_DIGEST_SIZE); | |
2776 | memset(D, 0, TGR192_DIGEST_SIZE); | |
2777 | } | |
2778 | @@ -627,6 +625,7 @@ | |
2779 | .cra_blocksize = TGR192_BLOCK_SIZE, | |
2780 | .cra_ctxsize = sizeof(struct tgr192_ctx), | |
2781 | .cra_module = THIS_MODULE, | |
2782 | + .cra_alignmask = 7, | |
2783 | .cra_list = LIST_HEAD_INIT(tgr192.cra_list), | |
2784 | .cra_u = {.digest = { | |
2785 | .dia_digestsize = TGR192_DIGEST_SIZE, | |
2786 | @@ -641,6 +640,7 @@ | |
2787 | .cra_blocksize = TGR192_BLOCK_SIZE, | |
2788 | .cra_ctxsize = sizeof(struct tgr192_ctx), | |
2789 | .cra_module = THIS_MODULE, | |
2790 | + .cra_alignmask = 7, | |
2791 | .cra_list = LIST_HEAD_INIT(tgr160.cra_list), | |
2792 | .cra_u = {.digest = { | |
2793 | .dia_digestsize = TGR160_DIGEST_SIZE, | |
2794 | @@ -655,6 +655,7 @@ | |
2795 | .cra_blocksize = TGR192_BLOCK_SIZE, | |
2796 | .cra_ctxsize = sizeof(struct tgr192_ctx), | |
2797 | .cra_module = THIS_MODULE, | |
2798 | + .cra_alignmask = 7, | |
2799 | .cra_list = LIST_HEAD_INIT(tgr128.cra_list), | |
2800 | .cra_u = {.digest = { | |
2801 | .dia_digestsize = TGR128_DIGEST_SIZE, | |
2802 | Index: linux-2.6.16.50/crypto/wp512.c | |
2803 | =================================================================== | |
2804 | --- linux-2.6.16.50.orig/crypto/wp512.c 2006-07-14 18:09:26.383438750 +1200 | |
2805 | +++ linux-2.6.16.50/crypto/wp512.c 2006-07-14 18:10:31.235491750 +1200 | |
2806 | @@ -981,9 +981,9 @@ | |
2807 | ||
2808 | } | |
2809 | ||
2810 | -static void wp512_init (void *ctx) { | |
2811 | +static void wp512_init(struct crypto_tfm *tfm) { | |
2812 | + struct wp512_ctx *wctx = crypto_tfm_ctx(tfm); | |
2813 | int i; | |
2814 | - struct wp512_ctx *wctx = ctx; | |
2815 | ||
2816 | memset(wctx->bitLength, 0, 32); | |
2817 | wctx->bufferBits = wctx->bufferPos = 0; | |
2818 | @@ -993,10 +993,10 @@ | |
2819 | } | |
2820 | } | |
2821 | ||
2822 | -static void wp512_update(void *ctx, const u8 *source, unsigned int len) | |
2823 | +static void wp512_update(struct crypto_tfm *tfm, const u8 *source, | |
2824 | + unsigned int len) | |
2825 | { | |
2826 | - | |
2827 | - struct wp512_ctx *wctx = ctx; | |
2828 | + struct wp512_ctx *wctx = crypto_tfm_ctx(tfm); | |
2829 | int sourcePos = 0; | |
2830 | unsigned int bits_len = len * 8; // convert to number of bits | |
2831 | int sourceGap = (8 - ((int)bits_len & 7)) & 7; | |
2832 | @@ -1054,9 +1054,9 @@ | |
2833 | ||
2834 | } | |
2835 | ||
2836 | -static void wp512_final(void *ctx, u8 *out) | |
2837 | +static void wp512_final(struct crypto_tfm *tfm, u8 *out) | |
2838 | { | |
2839 | - struct wp512_ctx *wctx = ctx; | |
2840 | + struct wp512_ctx *wctx = crypto_tfm_ctx(tfm); | |
2841 | int i; | |
2842 | u8 *buffer = wctx->buffer; | |
2843 | u8 *bitLength = wctx->bitLength; | |
2844 | @@ -1087,22 +1087,20 @@ | |
2845 | wctx->bufferPos = bufferPos; | |
2846 | } | |
2847 | ||
2848 | -static void wp384_final(void *ctx, u8 *out) | |
2849 | +static void wp384_final(struct crypto_tfm *tfm, u8 *out) | |
2850 | { | |
2851 | - struct wp512_ctx *wctx = ctx; | |
2852 | u8 D[64]; | |
2853 | ||
2854 | - wp512_final (wctx, D); | |
2855 | + wp512_final(tfm, D); | |
2856 | memcpy (out, D, WP384_DIGEST_SIZE); | |
2857 | memset (D, 0, WP512_DIGEST_SIZE); | |
2858 | } | |
2859 | ||
2860 | -static void wp256_final(void *ctx, u8 *out) | |
2861 | +static void wp256_final(struct crypto_tfm *tfm, u8 *out) | |
2862 | { | |
2863 | - struct wp512_ctx *wctx = ctx; | |
2864 | u8 D[64]; | |
2865 | ||
2866 | - wp512_final (wctx, D); | |
2867 | + wp512_final(tfm, D); | |
2868 | memcpy (out, D, WP256_DIGEST_SIZE); | |
2869 | memset (D, 0, WP512_DIGEST_SIZE); | |
2870 | } | |
2871 | Index: linux-2.6.16.50/arch/i386/kernel/cpu/proc.c | |
2872 | =================================================================== | |
2873 | --- linux-2.6.16.50.orig/arch/i386/kernel/cpu/proc.c 2006-07-15 00:03:51.220033250 +1200 | |
2874 | +++ linux-2.6.16.50/arch/i386/kernel/cpu/proc.c 2006-07-15 00:04:02.552741500 +1200 | |
2875 | @@ -52,7 +52,7 @@ | |
2876 | ||
2877 | /* VIA/Cyrix/Centaur-defined */ | |
2878 | NULL, NULL, "rng", "rng_en", NULL, NULL, "ace", "ace_en", | |
2879 | - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
2880 | + "ace2", "ace2_en", "phe", "phe_en", "pmm", "pmm_en", NULL, NULL, | |
2881 | NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
2882 | NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, | |
2883 | ||
2884 | Index: linux-2.6.16.50/include/asm-i386/cpufeature.h | |
2885 | =================================================================== | |
2886 | --- linux-2.6.16.50.orig/include/asm-i386/cpufeature.h 2006-07-15 00:03:51.648060000 +1200 | |
2887 | +++ linux-2.6.16.50/include/asm-i386/cpufeature.h 2006-07-15 00:04:02.552741500 +1200 | |
2888 | @@ -86,6 +86,12 @@ | |
2889 | #define X86_FEATURE_XSTORE_EN (5*32+ 3) /* on-CPU RNG enabled */ | |
2890 | #define X86_FEATURE_XCRYPT (5*32+ 6) /* on-CPU crypto (xcrypt insn) */ | |
2891 | #define X86_FEATURE_XCRYPT_EN (5*32+ 7) /* on-CPU crypto enabled */ | |
2892 | +#define X86_FEATURE_ACE2 (5*32+ 8) /* Advanced Cryptography Engine v2 */ | |
2893 | +#define X86_FEATURE_ACE2_EN (5*32+ 9) /* ACE v2 enabled */ | |
2894 | +#define X86_FEATURE_PHE (5*32+ 10) /* PadLock Hash Engine */ | |
2895 | +#define X86_FEATURE_PHE_EN (5*32+ 11) /* PHE enabled */ | |
2896 | +#define X86_FEATURE_PMM (5*32+ 12) /* PadLock Montgomery Multiplier */ | |
2897 | +#define X86_FEATURE_PMM_EN (5*32+ 13) /* PMM enabled */ | |
2898 | ||
2899 | /* More extended AMD flags: CPUID level 0x80000001, ecx, word 6 */ | |
2900 | #define X86_FEATURE_LAHF_LM (6*32+ 0) /* LAHF/SAHF in long mode */ | |
2901 | @@ -119,6 +125,12 @@ | |
2902 | #define cpu_has_xstore_enabled boot_cpu_has(X86_FEATURE_XSTORE_EN) | |
2903 | #define cpu_has_xcrypt boot_cpu_has(X86_FEATURE_XCRYPT) | |
2904 | #define cpu_has_xcrypt_enabled boot_cpu_has(X86_FEATURE_XCRYPT_EN) | |
2905 | +#define cpu_has_ace2 boot_cpu_has(X86_FEATURE_ACE2) | |
2906 | +#define cpu_has_ace2_enabled boot_cpu_has(X86_FEATURE_ACE2_EN) | |
2907 | +#define cpu_has_phe boot_cpu_has(X86_FEATURE_PHE) | |
2908 | +#define cpu_has_phe_enabled boot_cpu_has(X86_FEATURE_PHE_EN) | |
2909 | +#define cpu_has_pmm boot_cpu_has(X86_FEATURE_PMM) | |
2910 | +#define cpu_has_pmm_enabled boot_cpu_has(X86_FEATURE_PMM_EN) | |
2911 | ||
2912 | #endif /* __ASM_I386_CPUFEATURE_H */ | |
2913 |