]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * | |
3 | * Glue Code for optimized 586 assembler version of AES | |
4 | * | |
5 | * Copyright (c) 2002, Dr Brian Gladman <>, Worcester, UK. | |
6 | * All rights reserved. | |
7 | * | |
8 | * LICENSE TERMS | |
9 | * | |
10 | * The free distribution and use of this software in both source and binary | |
11 | * form is allowed (with or without changes) provided that: | |
12 | * | |
13 | * 1. distributions of this source code include the above copyright | |
14 | * notice, this list of conditions and the following disclaimer; | |
15 | * | |
16 | * 2. distributions in binary form include the above copyright | |
17 | * notice, this list of conditions and the following disclaimer | |
18 | * in the documentation and/or other associated materials; | |
19 | * | |
20 | * 3. the copyright holder's name is not used to endorse products | |
21 | * built using this software without specific written permission. | |
22 | * | |
23 | * ALTERNATIVELY, provided that this notice is retained in full, this product | |
24 | * may be distributed under the terms of the GNU General Public License (GPL), | |
25 | * in which case the provisions of the GPL apply INSTEAD OF those given above. | |
26 | * | |
27 | * DISCLAIMER | |
28 | * | |
29 | * This software is provided 'as is' with no explicit or implied warranties | |
30 | * in respect of its properties, including, but not limited to, correctness | |
31 | * and/or fitness for purpose. | |
32 | * | |
33 | * Copyright (c) 2003, Adam J. Richter <adam@yggdrasil.com> (conversion to | |
34 | * 2.5 API). | |
35 | * Copyright (c) 2003, 2004 Fruhwirth Clemens <clemens@endorphin.org> | |
36 | * Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com> | |
37 | * | |
38 | */ | |
06ace7a9 HX |
39 | |
40 | #include <asm/byteorder.h> | |
1da177e4 LT |
41 | #include <linux/kernel.h> |
42 | #include <linux/module.h> | |
43 | #include <linux/init.h> | |
44 | #include <linux/types.h> | |
45 | #include <linux/crypto.h> | |
46 | #include <linux/linkage.h> | |
47 | ||
6c2bb98b HX |
48 | asmlinkage void aes_enc_blk(struct crypto_tfm *tfm, u8 *dst, const u8 *src); |
49 | asmlinkage void aes_dec_blk(struct crypto_tfm *tfm, u8 *dst, const u8 *src); | |
1da177e4 LT |
50 | |
51 | #define AES_MIN_KEY_SIZE 16 | |
52 | #define AES_MAX_KEY_SIZE 32 | |
53 | #define AES_BLOCK_SIZE 16 | |
54 | #define AES_KS_LENGTH 4 * AES_BLOCK_SIZE | |
55 | #define RC_LENGTH 29 | |
56 | ||
57 | struct aes_ctx { | |
58 | u32 ekey[AES_KS_LENGTH]; | |
59 | u32 rounds; | |
60 | u32 dkey[AES_KS_LENGTH]; | |
61 | }; | |
62 | ||
63 | #define WPOLY 0x011b | |
1da177e4 LT |
64 | #define bytes2word(b0, b1, b2, b3) \ |
65 | (((u32)(b3) << 24) | ((u32)(b2) << 16) | ((u32)(b1) << 8) | (b0)) | |
66 | ||
67 | /* define the finite field multiplies required for Rijndael */ | |
68 | #define f2(x) ((x) ? pow[log[x] + 0x19] : 0) | |
69 | #define f3(x) ((x) ? pow[log[x] + 0x01] : 0) | |
70 | #define f9(x) ((x) ? pow[log[x] + 0xc7] : 0) | |
71 | #define fb(x) ((x) ? pow[log[x] + 0x68] : 0) | |
72 | #define fd(x) ((x) ? pow[log[x] + 0xee] : 0) | |
73 | #define fe(x) ((x) ? pow[log[x] + 0xdf] : 0) | |
74 | #define fi(x) ((x) ? pow[255 - log[x]]: 0) | |
75 | ||
76 | static inline u32 upr(u32 x, int n) | |
77 | { | |
78 | return (x << 8 * n) | (x >> (32 - 8 * n)); | |
79 | } | |
80 | ||
81 | static inline u8 bval(u32 x, int n) | |
82 | { | |
83 | return x >> 8 * n; | |
84 | } | |
85 | ||
86 | /* The forward and inverse affine transformations used in the S-box */ | |
87 | #define fwd_affine(x) \ | |
88 | (w = (u32)x, w ^= (w<<1)^(w<<2)^(w<<3)^(w<<4), 0x63^(u8)(w^(w>>8))) | |
89 | ||
90 | #define inv_affine(x) \ | |
91 | (w = (u32)x, w = (w<<1)^(w<<3)^(w<<6), 0x05^(u8)(w^(w>>8))) | |
92 | ||
93 | static u32 rcon_tab[RC_LENGTH]; | |
94 | ||
95 | u32 ft_tab[4][256]; | |
96 | u32 fl_tab[4][256]; | |
1da177e4 LT |
97 | static u32 im_tab[4][256]; |
98 | u32 il_tab[4][256]; | |
99 | u32 it_tab[4][256]; | |
100 | ||
101 | static void gen_tabs(void) | |
102 | { | |
103 | u32 i, w; | |
104 | u8 pow[512], log[256]; | |
105 | ||
106 | /* | |
107 | * log and power tables for GF(2^8) finite field with | |
108 | * WPOLY as modular polynomial - the simplest primitive | |
109 | * root is 0x03, used here to generate the tables. | |
110 | */ | |
111 | i = 0; w = 1; | |
112 | ||
113 | do { | |
114 | pow[i] = (u8)w; | |
115 | pow[i + 255] = (u8)w; | |
116 | log[w] = (u8)i++; | |
117 | w ^= (w << 1) ^ (w & 0x80 ? WPOLY : 0); | |
118 | } while (w != 1); | |
119 | ||
120 | for(i = 0, w = 1; i < RC_LENGTH; ++i) { | |
121 | rcon_tab[i] = bytes2word(w, 0, 0, 0); | |
122 | w = f2(w); | |
123 | } | |
124 | ||
125 | for(i = 0; i < 256; ++i) { | |
126 | u8 b; | |
127 | ||
128 | b = fwd_affine(fi((u8)i)); | |
129 | w = bytes2word(f2(b), b, b, f3(b)); | |
130 | ||
131 | /* tables for a normal encryption round */ | |
132 | ft_tab[0][i] = w; | |
133 | ft_tab[1][i] = upr(w, 1); | |
134 | ft_tab[2][i] = upr(w, 2); | |
135 | ft_tab[3][i] = upr(w, 3); | |
136 | w = bytes2word(b, 0, 0, 0); | |
137 | ||
138 | /* | |
139 | * tables for last encryption round | |
140 | * (may also be used in the key schedule) | |
141 | */ | |
142 | fl_tab[0][i] = w; | |
143 | fl_tab[1][i] = upr(w, 1); | |
144 | fl_tab[2][i] = upr(w, 2); | |
145 | fl_tab[3][i] = upr(w, 3); | |
146 | ||
1da177e4 LT |
147 | b = fi(inv_affine((u8)i)); |
148 | w = bytes2word(fe(b), f9(b), fd(b), fb(b)); | |
149 | ||
150 | /* tables for the inverse mix column operation */ | |
151 | im_tab[0][b] = w; | |
152 | im_tab[1][b] = upr(w, 1); | |
153 | im_tab[2][b] = upr(w, 2); | |
154 | im_tab[3][b] = upr(w, 3); | |
155 | ||
156 | /* tables for a normal decryption round */ | |
157 | it_tab[0][i] = w; | |
158 | it_tab[1][i] = upr(w,1); | |
159 | it_tab[2][i] = upr(w,2); | |
160 | it_tab[3][i] = upr(w,3); | |
161 | ||
162 | w = bytes2word(b, 0, 0, 0); | |
163 | ||
164 | /* tables for last decryption round */ | |
165 | il_tab[0][i] = w; | |
166 | il_tab[1][i] = upr(w,1); | |
167 | il_tab[2][i] = upr(w,2); | |
168 | il_tab[3][i] = upr(w,3); | |
169 | } | |
170 | } | |
171 | ||
172 | #define four_tables(x,tab,vf,rf,c) \ | |
173 | ( tab[0][bval(vf(x,0,c),rf(0,c))] ^ \ | |
174 | tab[1][bval(vf(x,1,c),rf(1,c))] ^ \ | |
175 | tab[2][bval(vf(x,2,c),rf(2,c))] ^ \ | |
176 | tab[3][bval(vf(x,3,c),rf(3,c))] \ | |
177 | ) | |
178 | ||
179 | #define vf1(x,r,c) (x) | |
180 | #define rf1(r,c) (r) | |
181 | #define rf2(r,c) ((r-c)&3) | |
182 | ||
183 | #define inv_mcol(x) four_tables(x,im_tab,vf1,rf1,0) | |
184 | #define ls_box(x,c) four_tables(x,fl_tab,vf1,rf2,c) | |
185 | ||
186 | #define ff(x) inv_mcol(x) | |
187 | ||
188 | #define ke4(k,i) \ | |
189 | { \ | |
190 | k[4*(i)+4] = ss[0] ^= ls_box(ss[3],3) ^ rcon_tab[i]; \ | |
191 | k[4*(i)+5] = ss[1] ^= ss[0]; \ | |
192 | k[4*(i)+6] = ss[2] ^= ss[1]; \ | |
193 | k[4*(i)+7] = ss[3] ^= ss[2]; \ | |
194 | } | |
195 | ||
196 | #define kel4(k,i) \ | |
197 | { \ | |
198 | k[4*(i)+4] = ss[0] ^= ls_box(ss[3],3) ^ rcon_tab[i]; \ | |
199 | k[4*(i)+5] = ss[1] ^= ss[0]; \ | |
200 | k[4*(i)+6] = ss[2] ^= ss[1]; k[4*(i)+7] = ss[3] ^= ss[2]; \ | |
201 | } | |
202 | ||
203 | #define ke6(k,i) \ | |
204 | { \ | |
205 | k[6*(i)+ 6] = ss[0] ^= ls_box(ss[5],3) ^ rcon_tab[i]; \ | |
206 | k[6*(i)+ 7] = ss[1] ^= ss[0]; \ | |
207 | k[6*(i)+ 8] = ss[2] ^= ss[1]; \ | |
208 | k[6*(i)+ 9] = ss[3] ^= ss[2]; \ | |
209 | k[6*(i)+10] = ss[4] ^= ss[3]; \ | |
210 | k[6*(i)+11] = ss[5] ^= ss[4]; \ | |
211 | } | |
212 | ||
213 | #define kel6(k,i) \ | |
214 | { \ | |
215 | k[6*(i)+ 6] = ss[0] ^= ls_box(ss[5],3) ^ rcon_tab[i]; \ | |
216 | k[6*(i)+ 7] = ss[1] ^= ss[0]; \ | |
217 | k[6*(i)+ 8] = ss[2] ^= ss[1]; \ | |
218 | k[6*(i)+ 9] = ss[3] ^= ss[2]; \ | |
219 | } | |
220 | ||
221 | #define ke8(k,i) \ | |
222 | { \ | |
223 | k[8*(i)+ 8] = ss[0] ^= ls_box(ss[7],3) ^ rcon_tab[i]; \ | |
224 | k[8*(i)+ 9] = ss[1] ^= ss[0]; \ | |
225 | k[8*(i)+10] = ss[2] ^= ss[1]; \ | |
226 | k[8*(i)+11] = ss[3] ^= ss[2]; \ | |
227 | k[8*(i)+12] = ss[4] ^= ls_box(ss[3],0); \ | |
228 | k[8*(i)+13] = ss[5] ^= ss[4]; \ | |
229 | k[8*(i)+14] = ss[6] ^= ss[5]; \ | |
230 | k[8*(i)+15] = ss[7] ^= ss[6]; \ | |
231 | } | |
232 | ||
233 | #define kel8(k,i) \ | |
234 | { \ | |
235 | k[8*(i)+ 8] = ss[0] ^= ls_box(ss[7],3) ^ rcon_tab[i]; \ | |
236 | k[8*(i)+ 9] = ss[1] ^= ss[0]; \ | |
237 | k[8*(i)+10] = ss[2] ^= ss[1]; \ | |
238 | k[8*(i)+11] = ss[3] ^= ss[2]; \ | |
239 | } | |
240 | ||
241 | #define kdf4(k,i) \ | |
242 | { \ | |
243 | ss[0] = ss[0] ^ ss[2] ^ ss[1] ^ ss[3]; \ | |
244 | ss[1] = ss[1] ^ ss[3]; \ | |
245 | ss[2] = ss[2] ^ ss[3]; \ | |
246 | ss[3] = ss[3]; \ | |
247 | ss[4] = ls_box(ss[(i+3) % 4], 3) ^ rcon_tab[i]; \ | |
248 | ss[i % 4] ^= ss[4]; \ | |
249 | ss[4] ^= k[4*(i)]; \ | |
250 | k[4*(i)+4] = ff(ss[4]); \ | |
251 | ss[4] ^= k[4*(i)+1]; \ | |
252 | k[4*(i)+5] = ff(ss[4]); \ | |
253 | ss[4] ^= k[4*(i)+2]; \ | |
254 | k[4*(i)+6] = ff(ss[4]); \ | |
255 | ss[4] ^= k[4*(i)+3]; \ | |
256 | k[4*(i)+7] = ff(ss[4]); \ | |
257 | } | |
258 | ||
259 | #define kd4(k,i) \ | |
260 | { \ | |
261 | ss[4] = ls_box(ss[(i+3) % 4], 3) ^ rcon_tab[i]; \ | |
262 | ss[i % 4] ^= ss[4]; \ | |
263 | ss[4] = ff(ss[4]); \ | |
264 | k[4*(i)+4] = ss[4] ^= k[4*(i)]; \ | |
265 | k[4*(i)+5] = ss[4] ^= k[4*(i)+1]; \ | |
266 | k[4*(i)+6] = ss[4] ^= k[4*(i)+2]; \ | |
267 | k[4*(i)+7] = ss[4] ^= k[4*(i)+3]; \ | |
268 | } | |
269 | ||
270 | #define kdl4(k,i) \ | |
271 | { \ | |
272 | ss[4] = ls_box(ss[(i+3) % 4], 3) ^ rcon_tab[i]; \ | |
273 | ss[i % 4] ^= ss[4]; \ | |
274 | k[4*(i)+4] = (ss[0] ^= ss[1]) ^ ss[2] ^ ss[3]; \ | |
275 | k[4*(i)+5] = ss[1] ^ ss[3]; \ | |
276 | k[4*(i)+6] = ss[0]; \ | |
277 | k[4*(i)+7] = ss[1]; \ | |
278 | } | |
279 | ||
280 | #define kdf6(k,i) \ | |
281 | { \ | |
282 | ss[0] ^= ls_box(ss[5],3) ^ rcon_tab[i]; \ | |
283 | k[6*(i)+ 6] = ff(ss[0]); \ | |
284 | ss[1] ^= ss[0]; \ | |
285 | k[6*(i)+ 7] = ff(ss[1]); \ | |
286 | ss[2] ^= ss[1]; \ | |
287 | k[6*(i)+ 8] = ff(ss[2]); \ | |
288 | ss[3] ^= ss[2]; \ | |
289 | k[6*(i)+ 9] = ff(ss[3]); \ | |
290 | ss[4] ^= ss[3]; \ | |
291 | k[6*(i)+10] = ff(ss[4]); \ | |
292 | ss[5] ^= ss[4]; \ | |
293 | k[6*(i)+11] = ff(ss[5]); \ | |
294 | } | |
295 | ||
296 | #define kd6(k,i) \ | |
297 | { \ | |
298 | ss[6] = ls_box(ss[5],3) ^ rcon_tab[i]; \ | |
299 | ss[0] ^= ss[6]; ss[6] = ff(ss[6]); \ | |
300 | k[6*(i)+ 6] = ss[6] ^= k[6*(i)]; \ | |
301 | ss[1] ^= ss[0]; \ | |
302 | k[6*(i)+ 7] = ss[6] ^= k[6*(i)+ 1]; \ | |
303 | ss[2] ^= ss[1]; \ | |
304 | k[6*(i)+ 8] = ss[6] ^= k[6*(i)+ 2]; \ | |
305 | ss[3] ^= ss[2]; \ | |
306 | k[6*(i)+ 9] = ss[6] ^= k[6*(i)+ 3]; \ | |
307 | ss[4] ^= ss[3]; \ | |
308 | k[6*(i)+10] = ss[6] ^= k[6*(i)+ 4]; \ | |
309 | ss[5] ^= ss[4]; \ | |
310 | k[6*(i)+11] = ss[6] ^= k[6*(i)+ 5]; \ | |
311 | } | |
312 | ||
313 | #define kdl6(k,i) \ | |
314 | { \ | |
315 | ss[0] ^= ls_box(ss[5],3) ^ rcon_tab[i]; \ | |
316 | k[6*(i)+ 6] = ss[0]; \ | |
317 | ss[1] ^= ss[0]; \ | |
318 | k[6*(i)+ 7] = ss[1]; \ | |
319 | ss[2] ^= ss[1]; \ | |
320 | k[6*(i)+ 8] = ss[2]; \ | |
321 | ss[3] ^= ss[2]; \ | |
322 | k[6*(i)+ 9] = ss[3]; \ | |
323 | } | |
324 | ||
325 | #define kdf8(k,i) \ | |
326 | { \ | |
327 | ss[0] ^= ls_box(ss[7],3) ^ rcon_tab[i]; \ | |
328 | k[8*(i)+ 8] = ff(ss[0]); \ | |
329 | ss[1] ^= ss[0]; \ | |
330 | k[8*(i)+ 9] = ff(ss[1]); \ | |
331 | ss[2] ^= ss[1]; \ | |
332 | k[8*(i)+10] = ff(ss[2]); \ | |
333 | ss[3] ^= ss[2]; \ | |
334 | k[8*(i)+11] = ff(ss[3]); \ | |
335 | ss[4] ^= ls_box(ss[3],0); \ | |
336 | k[8*(i)+12] = ff(ss[4]); \ | |
337 | ss[5] ^= ss[4]; \ | |
338 | k[8*(i)+13] = ff(ss[5]); \ | |
339 | ss[6] ^= ss[5]; \ | |
340 | k[8*(i)+14] = ff(ss[6]); \ | |
341 | ss[7] ^= ss[6]; \ | |
342 | k[8*(i)+15] = ff(ss[7]); \ | |
343 | } | |
344 | ||
345 | #define kd8(k,i) \ | |
346 | { \ | |
347 | u32 __g = ls_box(ss[7],3) ^ rcon_tab[i]; \ | |
348 | ss[0] ^= __g; \ | |
349 | __g = ff(__g); \ | |
350 | k[8*(i)+ 8] = __g ^= k[8*(i)]; \ | |
351 | ss[1] ^= ss[0]; \ | |
352 | k[8*(i)+ 9] = __g ^= k[8*(i)+ 1]; \ | |
353 | ss[2] ^= ss[1]; \ | |
354 | k[8*(i)+10] = __g ^= k[8*(i)+ 2]; \ | |
355 | ss[3] ^= ss[2]; \ | |
356 | k[8*(i)+11] = __g ^= k[8*(i)+ 3]; \ | |
357 | __g = ls_box(ss[3],0); \ | |
358 | ss[4] ^= __g; \ | |
359 | __g = ff(__g); \ | |
360 | k[8*(i)+12] = __g ^= k[8*(i)+ 4]; \ | |
361 | ss[5] ^= ss[4]; \ | |
362 | k[8*(i)+13] = __g ^= k[8*(i)+ 5]; \ | |
363 | ss[6] ^= ss[5]; \ | |
364 | k[8*(i)+14] = __g ^= k[8*(i)+ 6]; \ | |
365 | ss[7] ^= ss[6]; \ | |
366 | k[8*(i)+15] = __g ^= k[8*(i)+ 7]; \ | |
367 | } | |
368 | ||
369 | #define kdl8(k,i) \ | |
370 | { \ | |
371 | ss[0] ^= ls_box(ss[7],3) ^ rcon_tab[i]; \ | |
372 | k[8*(i)+ 8] = ss[0]; \ | |
373 | ss[1] ^= ss[0]; \ | |
374 | k[8*(i)+ 9] = ss[1]; \ | |
375 | ss[2] ^= ss[1]; \ | |
376 | k[8*(i)+10] = ss[2]; \ | |
377 | ss[3] ^= ss[2]; \ | |
378 | k[8*(i)+11] = ss[3]; \ | |
379 | } | |
380 | ||
6c2bb98b HX |
381 | static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key, |
382 | unsigned int key_len, u32 *flags) | |
1da177e4 LT |
383 | { |
384 | int i; | |
385 | u32 ss[8]; | |
6c2bb98b | 386 | struct aes_ctx *ctx = crypto_tfm_ctx(tfm); |
06ace7a9 | 387 | const __le32 *key = (const __le32 *)in_key; |
1da177e4 LT |
388 | |
389 | /* encryption schedule */ | |
390 | ||
06ace7a9 HX |
391 | ctx->ekey[0] = ss[0] = le32_to_cpu(key[0]); |
392 | ctx->ekey[1] = ss[1] = le32_to_cpu(key[1]); | |
393 | ctx->ekey[2] = ss[2] = le32_to_cpu(key[2]); | |
394 | ctx->ekey[3] = ss[3] = le32_to_cpu(key[3]); | |
1da177e4 LT |
395 | |
396 | switch(key_len) { | |
397 | case 16: | |
398 | for (i = 0; i < 9; i++) | |
399 | ke4(ctx->ekey, i); | |
400 | kel4(ctx->ekey, 9); | |
401 | ctx->rounds = 10; | |
402 | break; | |
403 | ||
404 | case 24: | |
06ace7a9 HX |
405 | ctx->ekey[4] = ss[4] = le32_to_cpu(key[4]); |
406 | ctx->ekey[5] = ss[5] = le32_to_cpu(key[5]); | |
1da177e4 LT |
407 | for (i = 0; i < 7; i++) |
408 | ke6(ctx->ekey, i); | |
409 | kel6(ctx->ekey, 7); | |
410 | ctx->rounds = 12; | |
411 | break; | |
412 | ||
413 | case 32: | |
06ace7a9 HX |
414 | ctx->ekey[4] = ss[4] = le32_to_cpu(key[4]); |
415 | ctx->ekey[5] = ss[5] = le32_to_cpu(key[5]); | |
416 | ctx->ekey[6] = ss[6] = le32_to_cpu(key[6]); | |
417 | ctx->ekey[7] = ss[7] = le32_to_cpu(key[7]); | |
1da177e4 LT |
418 | for (i = 0; i < 6; i++) |
419 | ke8(ctx->ekey, i); | |
420 | kel8(ctx->ekey, 6); | |
421 | ctx->rounds = 14; | |
422 | break; | |
423 | ||
424 | default: | |
425 | *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN; | |
426 | return -EINVAL; | |
427 | } | |
428 | ||
429 | /* decryption schedule */ | |
430 | ||
06ace7a9 HX |
431 | ctx->dkey[0] = ss[0] = le32_to_cpu(key[0]); |
432 | ctx->dkey[1] = ss[1] = le32_to_cpu(key[1]); | |
433 | ctx->dkey[2] = ss[2] = le32_to_cpu(key[2]); | |
434 | ctx->dkey[3] = ss[3] = le32_to_cpu(key[3]); | |
1da177e4 LT |
435 | |
436 | switch (key_len) { | |
437 | case 16: | |
438 | kdf4(ctx->dkey, 0); | |
439 | for (i = 1; i < 9; i++) | |
440 | kd4(ctx->dkey, i); | |
441 | kdl4(ctx->dkey, 9); | |
442 | break; | |
443 | ||
444 | case 24: | |
06ace7a9 HX |
445 | ctx->dkey[4] = ff(ss[4] = le32_to_cpu(key[4])); |
446 | ctx->dkey[5] = ff(ss[5] = le32_to_cpu(key[5])); | |
1da177e4 LT |
447 | kdf6(ctx->dkey, 0); |
448 | for (i = 1; i < 7; i++) | |
449 | kd6(ctx->dkey, i); | |
450 | kdl6(ctx->dkey, 7); | |
451 | break; | |
452 | ||
453 | case 32: | |
06ace7a9 HX |
454 | ctx->dkey[4] = ff(ss[4] = le32_to_cpu(key[4])); |
455 | ctx->dkey[5] = ff(ss[5] = le32_to_cpu(key[5])); | |
456 | ctx->dkey[6] = ff(ss[6] = le32_to_cpu(key[6])); | |
457 | ctx->dkey[7] = ff(ss[7] = le32_to_cpu(key[7])); | |
1da177e4 LT |
458 | kdf8(ctx->dkey, 0); |
459 | for (i = 1; i < 6; i++) | |
460 | kd8(ctx->dkey, i); | |
461 | kdl8(ctx->dkey, 6); | |
462 | break; | |
463 | } | |
464 | return 0; | |
465 | } | |
466 | ||
1da177e4 LT |
467 | static struct crypto_alg aes_alg = { |
468 | .cra_name = "aes", | |
c8a19c91 HX |
469 | .cra_driver_name = "aes-i586", |
470 | .cra_priority = 200, | |
1da177e4 LT |
471 | .cra_flags = CRYPTO_ALG_TYPE_CIPHER, |
472 | .cra_blocksize = AES_BLOCK_SIZE, | |
473 | .cra_ctxsize = sizeof(struct aes_ctx), | |
474 | .cra_module = THIS_MODULE, | |
475 | .cra_list = LIST_HEAD_INIT(aes_alg.cra_list), | |
476 | .cra_u = { | |
477 | .cipher = { | |
478 | .cia_min_keysize = AES_MIN_KEY_SIZE, | |
479 | .cia_max_keysize = AES_MAX_KEY_SIZE, | |
480 | .cia_setkey = aes_set_key, | |
8b55ba03 HX |
481 | .cia_encrypt = aes_enc_blk, |
482 | .cia_decrypt = aes_dec_blk | |
1da177e4 LT |
483 | } |
484 | } | |
485 | }; | |
486 | ||
487 | static int __init aes_init(void) | |
488 | { | |
489 | gen_tabs(); | |
490 | return crypto_register_alg(&aes_alg); | |
491 | } | |
492 | ||
493 | static void __exit aes_fini(void) | |
494 | { | |
495 | crypto_unregister_alg(&aes_alg); | |
496 | } | |
497 | ||
498 | module_init(aes_init); | |
499 | module_exit(aes_fini); | |
500 | ||
501 | MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm, i586 asm optimized"); | |
502 | MODULE_LICENSE("Dual BSD/GPL"); | |
503 | MODULE_AUTHOR("Fruhwirth Clemens, James Morris, Brian Gladman, Adam Richter"); | |
504 | MODULE_ALIAS("aes"); |