Merge master.kernel.org:/home/rmk/linux-2.6-serial
[linux-2.6] / drivers / crypto / padlock-aes.c
1 /* 
2  * Cryptographic API.
3  *
4  * Support for VIA PadLock hardware crypto engine.
5  *
6  * Copyright (c) 2004  Michal Ludvig <michal@logix.cz>
7  *
8  * Key expansion routine taken from crypto/aes.c
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * ---------------------------------------------------------------------------
16  * Copyright (c) 2002, Dr Brian Gladman <brg@gladman.me.uk>, Worcester, UK.
17  * All rights reserved.
18  *
19  * LICENSE TERMS
20  *
21  * The free distribution and use of this software in both source and binary
22  * form is allowed (with or without changes) provided that:
23  *
24  *   1. distributions of this source code include the above copyright
25  *      notice, this list of conditions and the following disclaimer;
26  *
27  *   2. distributions in binary form include the above copyright
28  *      notice, this list of conditions and the following disclaimer
29  *      in the documentation and/or other associated materials;
30  *
31  *   3. the copyright holder's name is not used to endorse products
32  *      built using this software without specific written permission.
33  *
34  * ALTERNATIVELY, provided that this notice is retained in full, this product
35  * may be distributed under the terms of the GNU General Public License (GPL),
36  * in which case the provisions of the GPL apply INSTEAD OF those given above.
37  *
38  * DISCLAIMER
39  *
40  * This software is provided 'as is' with no explicit or implied warranties
41  * in respect of its properties, including, but not limited to, correctness
42  * and/or fitness for purpose.
43  * ---------------------------------------------------------------------------
44  */
45
46 #include <linux/module.h>
47 #include <linux/init.h>
48 #include <linux/types.h>
49 #include <linux/errno.h>
50 #include <linux/crypto.h>
51 #include <linux/interrupt.h>
52 #include <linux/kernel.h>
53 #include <asm/byteorder.h>
54 #include "padlock.h"
55
56 #define AES_MIN_KEY_SIZE        16      /* in uint8_t units */
57 #define AES_MAX_KEY_SIZE        32      /* ditto */
58 #define AES_BLOCK_SIZE          16      /* ditto */
59 #define AES_EXTENDED_KEY_SIZE   64      /* in uint32_t units */
60 #define AES_EXTENDED_KEY_SIZE_B (AES_EXTENDED_KEY_SIZE * sizeof(uint32_t))
61
62 struct aes_ctx {
63         uint32_t e_data[AES_EXTENDED_KEY_SIZE];
64         uint32_t d_data[AES_EXTENDED_KEY_SIZE];
65         struct {
66                 struct cword encrypt;
67                 struct cword decrypt;
68         } cword;
69         uint32_t *E;
70         uint32_t *D;
71         int key_length;
72 };
73
74 /* ====== Key management routines ====== */
75
76 static inline uint32_t
77 generic_rotr32 (const uint32_t x, const unsigned bits)
78 {
79         const unsigned n = bits % 32;
80         return (x >> n) | (x << (32 - n));
81 }
82
83 static inline uint32_t
84 generic_rotl32 (const uint32_t x, const unsigned bits)
85 {
86         const unsigned n = bits % 32;
87         return (x << n) | (x >> (32 - n));
88 }
89
90 #define rotl generic_rotl32
91 #define rotr generic_rotr32
92
93 /*
94  * #define byte(x, nr) ((unsigned char)((x) >> (nr*8))) 
95  */
96 static inline uint8_t
97 byte(const uint32_t x, const unsigned n)
98 {
99         return x >> (n << 3);
100 }
101
102 #define E_KEY ctx->E
103 #define D_KEY ctx->D
104
105 static uint8_t pow_tab[256];
106 static uint8_t log_tab[256];
107 static uint8_t sbx_tab[256];
108 static uint8_t isb_tab[256];
109 static uint32_t rco_tab[10];
110 static uint32_t ft_tab[4][256];
111 static uint32_t it_tab[4][256];
112
113 static uint32_t fl_tab[4][256];
114 static uint32_t il_tab[4][256];
115
116 static inline uint8_t
117 f_mult (uint8_t a, uint8_t b)
118 {
119         uint8_t aa = log_tab[a], cc = aa + log_tab[b];
120
121         return pow_tab[cc + (cc < aa ? 1 : 0)];
122 }
123
124 #define ff_mult(a,b)    (a && b ? f_mult(a, b) : 0)
125
126 #define f_rn(bo, bi, n, k)                                      \
127     bo[n] =  ft_tab[0][byte(bi[n],0)] ^                         \
128              ft_tab[1][byte(bi[(n + 1) & 3],1)] ^               \
129              ft_tab[2][byte(bi[(n + 2) & 3],2)] ^               \
130              ft_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n)
131
132 #define i_rn(bo, bi, n, k)                                      \
133     bo[n] =  it_tab[0][byte(bi[n],0)] ^                         \
134              it_tab[1][byte(bi[(n + 3) & 3],1)] ^               \
135              it_tab[2][byte(bi[(n + 2) & 3],2)] ^               \
136              it_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n)
137
138 #define ls_box(x)                               \
139     ( fl_tab[0][byte(x, 0)] ^                   \
140       fl_tab[1][byte(x, 1)] ^                   \
141       fl_tab[2][byte(x, 2)] ^                   \
142       fl_tab[3][byte(x, 3)] )
143
144 #define f_rl(bo, bi, n, k)                                      \
145     bo[n] =  fl_tab[0][byte(bi[n],0)] ^                         \
146              fl_tab[1][byte(bi[(n + 1) & 3],1)] ^               \
147              fl_tab[2][byte(bi[(n + 2) & 3],2)] ^               \
148              fl_tab[3][byte(bi[(n + 3) & 3],3)] ^ *(k + n)
149
150 #define i_rl(bo, bi, n, k)                                      \
151     bo[n] =  il_tab[0][byte(bi[n],0)] ^                         \
152              il_tab[1][byte(bi[(n + 3) & 3],1)] ^               \
153              il_tab[2][byte(bi[(n + 2) & 3],2)] ^               \
154              il_tab[3][byte(bi[(n + 1) & 3],3)] ^ *(k + n)
155
156 static void
157 gen_tabs (void)
158 {
159         uint32_t i, t;
160         uint8_t p, q;
161
162         /* log and power tables for GF(2**8) finite field with
163            0x011b as modular polynomial - the simplest prmitive
164            root is 0x03, used here to generate the tables */
165
166         for (i = 0, p = 1; i < 256; ++i) {
167                 pow_tab[i] = (uint8_t) p;
168                 log_tab[p] = (uint8_t) i;
169
170                 p ^= (p << 1) ^ (p & 0x80 ? 0x01b : 0);
171         }
172
173         log_tab[1] = 0;
174
175         for (i = 0, p = 1; i < 10; ++i) {
176                 rco_tab[i] = p;
177
178                 p = (p << 1) ^ (p & 0x80 ? 0x01b : 0);
179         }
180
181         for (i = 0; i < 256; ++i) {
182                 p = (i ? pow_tab[255 - log_tab[i]] : 0);
183                 q = ((p >> 7) | (p << 1)) ^ ((p >> 6) | (p << 2));
184                 p ^= 0x63 ^ q ^ ((q >> 6) | (q << 2));
185                 sbx_tab[i] = p;
186                 isb_tab[p] = (uint8_t) i;
187         }
188
189         for (i = 0; i < 256; ++i) {
190                 p = sbx_tab[i];
191
192                 t = p;
193                 fl_tab[0][i] = t;
194                 fl_tab[1][i] = rotl (t, 8);
195                 fl_tab[2][i] = rotl (t, 16);
196                 fl_tab[3][i] = rotl (t, 24);
197
198                 t = ((uint32_t) ff_mult (2, p)) |
199                     ((uint32_t) p << 8) |
200                     ((uint32_t) p << 16) | ((uint32_t) ff_mult (3, p) << 24);
201
202                 ft_tab[0][i] = t;
203                 ft_tab[1][i] = rotl (t, 8);
204                 ft_tab[2][i] = rotl (t, 16);
205                 ft_tab[3][i] = rotl (t, 24);
206
207                 p = isb_tab[i];
208
209                 t = p;
210                 il_tab[0][i] = t;
211                 il_tab[1][i] = rotl (t, 8);
212                 il_tab[2][i] = rotl (t, 16);
213                 il_tab[3][i] = rotl (t, 24);
214
215                 t = ((uint32_t) ff_mult (14, p)) |
216                     ((uint32_t) ff_mult (9, p) << 8) |
217                     ((uint32_t) ff_mult (13, p) << 16) |
218                     ((uint32_t) ff_mult (11, p) << 24);
219
220                 it_tab[0][i] = t;
221                 it_tab[1][i] = rotl (t, 8);
222                 it_tab[2][i] = rotl (t, 16);
223                 it_tab[3][i] = rotl (t, 24);
224         }
225 }
226
227 #define star_x(x) (((x) & 0x7f7f7f7f) << 1) ^ ((((x) & 0x80808080) >> 7) * 0x1b)
228
229 #define imix_col(y,x)       \
230     u   = star_x(x);        \
231     v   = star_x(u);        \
232     w   = star_x(v);        \
233     t   = w ^ (x);          \
234    (y)  = u ^ v ^ w;        \
235    (y) ^= rotr(u ^ t,  8) ^ \
236           rotr(v ^ t, 16) ^ \
237           rotr(t,24)
238
239 /* initialise the key schedule from the user supplied key */
240
241 #define loop4(i)                                    \
242 {   t = rotr(t,  8); t = ls_box(t) ^ rco_tab[i];    \
243     t ^= E_KEY[4 * i];     E_KEY[4 * i + 4] = t;    \
244     t ^= E_KEY[4 * i + 1]; E_KEY[4 * i + 5] = t;    \
245     t ^= E_KEY[4 * i + 2]; E_KEY[4 * i + 6] = t;    \
246     t ^= E_KEY[4 * i + 3]; E_KEY[4 * i + 7] = t;    \
247 }
248
249 #define loop6(i)                                    \
250 {   t = rotr(t,  8); t = ls_box(t) ^ rco_tab[i];    \
251     t ^= E_KEY[6 * i];     E_KEY[6 * i + 6] = t;    \
252     t ^= E_KEY[6 * i + 1]; E_KEY[6 * i + 7] = t;    \
253     t ^= E_KEY[6 * i + 2]; E_KEY[6 * i + 8] = t;    \
254     t ^= E_KEY[6 * i + 3]; E_KEY[6 * i + 9] = t;    \
255     t ^= E_KEY[6 * i + 4]; E_KEY[6 * i + 10] = t;   \
256     t ^= E_KEY[6 * i + 5]; E_KEY[6 * i + 11] = t;   \
257 }
258
259 #define loop8(i)                                    \
260 {   t = rotr(t,  8); ; t = ls_box(t) ^ rco_tab[i];  \
261     t ^= E_KEY[8 * i];     E_KEY[8 * i + 8] = t;    \
262     t ^= E_KEY[8 * i + 1]; E_KEY[8 * i + 9] = t;    \
263     t ^= E_KEY[8 * i + 2]; E_KEY[8 * i + 10] = t;   \
264     t ^= E_KEY[8 * i + 3]; E_KEY[8 * i + 11] = t;   \
265     t  = E_KEY[8 * i + 4] ^ ls_box(t);    \
266     E_KEY[8 * i + 12] = t;                \
267     t ^= E_KEY[8 * i + 5]; E_KEY[8 * i + 13] = t;   \
268     t ^= E_KEY[8 * i + 6]; E_KEY[8 * i + 14] = t;   \
269     t ^= E_KEY[8 * i + 7]; E_KEY[8 * i + 15] = t;   \
270 }
271
272 /* Tells whether the ACE is capable to generate
273    the extended key for a given key_len. */
274 static inline int
275 aes_hw_extkey_available(uint8_t key_len)
276 {
277         /* TODO: We should check the actual CPU model/stepping
278                  as it's possible that the capability will be
279                  added in the next CPU revisions. */
280         if (key_len == 16)
281                 return 1;
282         return 0;
283 }
284
285 static inline struct aes_ctx *aes_ctx(void *ctx)
286 {
287         unsigned long align = PADLOCK_ALIGNMENT;
288
289         if (align <= crypto_tfm_ctx_alignment())
290                 align = 1;
291         return (struct aes_ctx *)ALIGN((unsigned long)ctx, align);
292 }
293
294 static int
295 aes_set_key(void *ctx_arg, const uint8_t *in_key, unsigned int key_len, uint32_t *flags)
296 {
297         struct aes_ctx *ctx = aes_ctx(ctx_arg);
298         const __le32 *key = (const __le32 *)in_key;
299         uint32_t i, t, u, v, w;
300         uint32_t P[AES_EXTENDED_KEY_SIZE];
301         uint32_t rounds;
302
303         if (key_len != 16 && key_len != 24 && key_len != 32) {
304                 *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
305                 return -EINVAL;
306         }
307
308         ctx->key_length = key_len;
309
310         /*
311          * If the hardware is capable of generating the extended key
312          * itself we must supply the plain key for both encryption
313          * and decryption.
314          */
315         ctx->E = ctx->e_data;
316         ctx->D = ctx->e_data;
317
318         E_KEY[0] = le32_to_cpu(key[0]);
319         E_KEY[1] = le32_to_cpu(key[1]);
320         E_KEY[2] = le32_to_cpu(key[2]);
321         E_KEY[3] = le32_to_cpu(key[3]);
322
323         /* Prepare control words. */
324         memset(&ctx->cword, 0, sizeof(ctx->cword));
325
326         ctx->cword.decrypt.encdec = 1;
327         ctx->cword.encrypt.rounds = 10 + (key_len - 16) / 4;
328         ctx->cword.decrypt.rounds = ctx->cword.encrypt.rounds;
329         ctx->cword.encrypt.ksize = (key_len - 16) / 8;
330         ctx->cword.decrypt.ksize = ctx->cword.encrypt.ksize;
331
332         /* Don't generate extended keys if the hardware can do it. */
333         if (aes_hw_extkey_available(key_len))
334                 return 0;
335
336         ctx->D = ctx->d_data;
337         ctx->cword.encrypt.keygen = 1;
338         ctx->cword.decrypt.keygen = 1;
339
340         switch (key_len) {
341         case 16:
342                 t = E_KEY[3];
343                 for (i = 0; i < 10; ++i)
344                         loop4 (i);
345                 break;
346
347         case 24:
348                 E_KEY[4] = le32_to_cpu(key[4]);
349                 t = E_KEY[5] = le32_to_cpu(key[5]);
350                 for (i = 0; i < 8; ++i)
351                         loop6 (i);
352                 break;
353
354         case 32:
355                 E_KEY[4] = le32_to_cpu(key[4]);
356                 E_KEY[5] = le32_to_cpu(key[5]);
357                 E_KEY[6] = le32_to_cpu(key[6]);
358                 t = E_KEY[7] = le32_to_cpu(key[7]);
359                 for (i = 0; i < 7; ++i)
360                         loop8 (i);
361                 break;
362         }
363
364         D_KEY[0] = E_KEY[0];
365         D_KEY[1] = E_KEY[1];
366         D_KEY[2] = E_KEY[2];
367         D_KEY[3] = E_KEY[3];
368
369         for (i = 4; i < key_len + 24; ++i) {
370                 imix_col (D_KEY[i], E_KEY[i]);
371         }
372
373         /* PadLock needs a different format of the decryption key. */
374         rounds = 10 + (key_len - 16) / 4;
375
376         for (i = 0; i < rounds; i++) {
377                 P[((i + 1) * 4) + 0] = D_KEY[((rounds - i - 1) * 4) + 0];
378                 P[((i + 1) * 4) + 1] = D_KEY[((rounds - i - 1) * 4) + 1];
379                 P[((i + 1) * 4) + 2] = D_KEY[((rounds - i - 1) * 4) + 2];
380                 P[((i + 1) * 4) + 3] = D_KEY[((rounds - i - 1) * 4) + 3];
381         }
382
383         P[0] = E_KEY[(rounds * 4) + 0];
384         P[1] = E_KEY[(rounds * 4) + 1];
385         P[2] = E_KEY[(rounds * 4) + 2];
386         P[3] = E_KEY[(rounds * 4) + 3];
387
388         memcpy(D_KEY, P, AES_EXTENDED_KEY_SIZE_B);
389
390         return 0;
391 }
392
393 /* ====== Encryption/decryption routines ====== */
394
395 /* These are the real call to PadLock. */
396 static inline void padlock_xcrypt_ecb(const u8 *input, u8 *output, void *key,
397                                       void *control_word, u32 count)
398 {
399         asm volatile ("pushfl; popfl");         /* enforce key reload. */
400         asm volatile (".byte 0xf3,0x0f,0xa7,0xc8"       /* rep xcryptecb */
401                       : "+S"(input), "+D"(output)
402                       : "d"(control_word), "b"(key), "c"(count));
403 }
404
405 static inline u8 *padlock_xcrypt_cbc(const u8 *input, u8 *output, void *key,
406                                      u8 *iv, void *control_word, u32 count)
407 {
408         /* Enforce key reload. */
409         asm volatile ("pushfl; popfl");
410         /* rep xcryptcbc */
411         asm volatile (".byte 0xf3,0x0f,0xa7,0xd0"
412                       : "+S" (input), "+D" (output), "+a" (iv)
413                       : "d" (control_word), "b" (key), "c" (count));
414         return iv;
415 }
416
417 static void
418 aes_encrypt(void *ctx_arg, uint8_t *out, const uint8_t *in)
419 {
420         struct aes_ctx *ctx = aes_ctx(ctx_arg);
421         padlock_xcrypt_ecb(in, out, ctx->E, &ctx->cword.encrypt, 1);
422 }
423
424 static void
425 aes_decrypt(void *ctx_arg, uint8_t *out, const uint8_t *in)
426 {
427         struct aes_ctx *ctx = aes_ctx(ctx_arg);
428         padlock_xcrypt_ecb(in, out, ctx->D, &ctx->cword.decrypt, 1);
429 }
430
431 static unsigned int aes_encrypt_ecb(const struct cipher_desc *desc, u8 *out,
432                                     const u8 *in, unsigned int nbytes)
433 {
434         struct aes_ctx *ctx = aes_ctx(crypto_tfm_ctx(desc->tfm));
435         padlock_xcrypt_ecb(in, out, ctx->E, &ctx->cword.encrypt,
436                            nbytes / AES_BLOCK_SIZE);
437         return nbytes & ~(AES_BLOCK_SIZE - 1);
438 }
439
440 static unsigned int aes_decrypt_ecb(const struct cipher_desc *desc, u8 *out,
441                                     const u8 *in, unsigned int nbytes)
442 {
443         struct aes_ctx *ctx = aes_ctx(crypto_tfm_ctx(desc->tfm));
444         padlock_xcrypt_ecb(in, out, ctx->D, &ctx->cword.decrypt,
445                            nbytes / AES_BLOCK_SIZE);
446         return nbytes & ~(AES_BLOCK_SIZE - 1);
447 }
448
449 static unsigned int aes_encrypt_cbc(const struct cipher_desc *desc, u8 *out,
450                                     const u8 *in, unsigned int nbytes)
451 {
452         struct aes_ctx *ctx = aes_ctx(crypto_tfm_ctx(desc->tfm));
453         u8 *iv;
454
455         iv = padlock_xcrypt_cbc(in, out, ctx->E, desc->info,
456                                 &ctx->cword.encrypt, nbytes / AES_BLOCK_SIZE);
457         memcpy(desc->info, iv, AES_BLOCK_SIZE);
458
459         return nbytes & ~(AES_BLOCK_SIZE - 1);
460 }
461
462 static unsigned int aes_decrypt_cbc(const struct cipher_desc *desc, u8 *out,
463                                     const u8 *in, unsigned int nbytes)
464 {
465         struct aes_ctx *ctx = aes_ctx(crypto_tfm_ctx(desc->tfm));
466         padlock_xcrypt_cbc(in, out, ctx->D, desc->info, &ctx->cword.decrypt,
467                            nbytes / AES_BLOCK_SIZE);
468         return nbytes & ~(AES_BLOCK_SIZE - 1);
469 }
470
471 static struct crypto_alg aes_alg = {
472         .cra_name               =       "aes",
473         .cra_driver_name        =       "aes-padlock",
474         .cra_priority           =       300,
475         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
476         .cra_blocksize          =       AES_BLOCK_SIZE,
477         .cra_ctxsize            =       sizeof(struct aes_ctx),
478         .cra_alignmask          =       PADLOCK_ALIGNMENT - 1,
479         .cra_module             =       THIS_MODULE,
480         .cra_list               =       LIST_HEAD_INIT(aes_alg.cra_list),
481         .cra_u                  =       {
482                 .cipher = {
483                         .cia_min_keysize        =       AES_MIN_KEY_SIZE,
484                         .cia_max_keysize        =       AES_MAX_KEY_SIZE,
485                         .cia_setkey             =       aes_set_key,
486                         .cia_encrypt            =       aes_encrypt,
487                         .cia_decrypt            =       aes_decrypt,
488                         .cia_encrypt_ecb        =       aes_encrypt_ecb,
489                         .cia_decrypt_ecb        =       aes_decrypt_ecb,
490                         .cia_encrypt_cbc        =       aes_encrypt_cbc,
491                         .cia_decrypt_cbc        =       aes_decrypt_cbc,
492                 }
493         }
494 };
495
496 int __init padlock_init_aes(void)
497 {
498         printk(KERN_NOTICE PFX "Using VIA PadLock ACE for AES algorithm.\n");
499
500         gen_tabs();
501         return crypto_register_alg(&aes_alg);
502 }
503
504 void __exit padlock_fini_aes(void)
505 {
506         crypto_unregister_alg(&aes_alg);
507 }