[PATCH] GEODE-AES: Allow in-place operations [CVE-2007-2451]
[opensuse:kernel.git] / drivers / crypto / geode-aes.c
1  /* Copyright (C) 2004-2006, Advanced Micro Devices, Inc.
2  *
3  * This program is free software; you can redistribute it and/or modify
4  * it under the terms of the GNU General Public License as published by
5  * the Free Software Foundation; either version 2 of the License, or
6  * (at your option) any later version.
7  */
8
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <linux/pci.h>
12 #include <linux/pci_ids.h>
13 #include <linux/crypto.h>
14 #include <linux/spinlock.h>
15 #include <crypto/algapi.h>
16
17 #include <asm/io.h>
18 #include <asm/delay.h>
19
20 #include "geode-aes.h"
21
22 /* Register definitions */
23
24 #define AES_CTRLA_REG  0x0000
25
26 #define AES_CTRL_START     0x01
27 #define AES_CTRL_DECRYPT   0x00
28 #define AES_CTRL_ENCRYPT   0x02
29 #define AES_CTRL_WRKEY     0x04
30 #define AES_CTRL_DCA       0x08
31 #define AES_CTRL_SCA       0x10
32 #define AES_CTRL_CBC       0x20
33
34 #define AES_INTR_REG  0x0008
35
36 #define AES_INTRA_PENDING (1 << 16)
37 #define AES_INTRB_PENDING (1 << 17)
38
39 #define AES_INTR_PENDING  (AES_INTRA_PENDING | AES_INTRB_PENDING)
40 #define AES_INTR_MASK     0x07
41
42 #define AES_SOURCEA_REG   0x0010
43 #define AES_DSTA_REG      0x0014
44 #define AES_LENA_REG      0x0018
45 #define AES_WRITEKEY0_REG 0x0030
46 #define AES_WRITEIV0_REG  0x0040
47
48 /*  A very large counter that is used to gracefully bail out of an
49  *  operation in case of trouble
50  */
51
52 #define AES_OP_TIMEOUT    0x50000
53
54 /* Static structures */
55
56 static void __iomem * _iobase;
57 static spinlock_t lock;
58
59 /* Write a 128 bit field (either a writable key or IV) */
60 static inline void
61 _writefield(u32 offset, void *value)
62 {
63         int i;
64         for(i = 0; i < 4; i++)
65                 iowrite32(((u32 *) value)[i], _iobase + offset + (i * 4));
66 }
67
68 /* Read a 128 bit field (either a writable key or IV) */
69 static inline void
70 _readfield(u32 offset, void *value)
71 {
72         int i;
73         for(i = 0; i < 4; i++)
74                 ((u32 *) value)[i] = ioread32(_iobase + offset + (i * 4));
75 }
76
77 static int
78 do_crypt(void *src, void *dst, int len, u32 flags)
79 {
80         u32 status;
81         u32 counter = AES_OP_TIMEOUT;
82
83         iowrite32(virt_to_phys(src), _iobase + AES_SOURCEA_REG);
84         iowrite32(virt_to_phys(dst), _iobase + AES_DSTA_REG);
85         iowrite32(len,  _iobase + AES_LENA_REG);
86
87         /* Start the operation */
88         iowrite32(AES_CTRL_START | flags, _iobase + AES_CTRLA_REG);
89
90         do
91                 status = ioread32(_iobase + AES_INTR_REG);
92         while(!(status & AES_INTRA_PENDING) && --counter);
93
94         /* Clear the event */
95         iowrite32((status & 0xFF) | AES_INTRA_PENDING, _iobase + AES_INTR_REG);
96         return counter ? 0 : 1;
97 }
98
99 static unsigned int
100 geode_aes_crypt(struct geode_aes_op *op)
101 {
102         u32 flags = 0;
103         unsigned long iflags;
104
105         if (op->len == 0)
106                 return 0;
107
108         /* If the source and destination is the same, then
109          * we need to turn on the coherent flags, otherwise
110          * we don't need to worry
111          */
112
113         if (op->src == op->dst)
114                 flags |= (AES_CTRL_DCA | AES_CTRL_SCA);
115
116         if (op->dir == AES_DIR_ENCRYPT)
117                 flags |= AES_CTRL_ENCRYPT;
118
119         /* Start the critical section */
120
121         spin_lock_irqsave(&lock, iflags);
122
123         if (op->mode == AES_MODE_CBC) {
124                 flags |= AES_CTRL_CBC;
125                 _writefield(AES_WRITEIV0_REG, op->iv);
126         }
127
128         if (!(op->flags & AES_FLAGS_HIDDENKEY)) {
129                 flags |= AES_CTRL_WRKEY;
130                 _writefield(AES_WRITEKEY0_REG, op->key);
131         }
132
133         do_crypt(op->src, op->dst, op->len, flags);
134
135         if (op->mode == AES_MODE_CBC)
136                 _readfield(AES_WRITEIV0_REG, op->iv);
137
138         spin_unlock_irqrestore(&lock, iflags);
139
140         return op->len;
141 }
142
143 /* CRYPTO-API Functions */
144
145 static int
146 geode_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int len)
147 {
148         struct geode_aes_op *op = crypto_tfm_ctx(tfm);
149
150         if (len != AES_KEY_LENGTH) {
151                 tfm->crt_flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
152                 return -EINVAL;
153         }
154
155         memcpy(op->key, key, len);
156         return 0;
157 }
158
159 static void
160 geode_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
161 {
162         struct geode_aes_op *op = crypto_tfm_ctx(tfm);
163
164         if ((out == NULL) || (in == NULL))
165                 return;
166
167         op->src = (void *) in;
168         op->dst = (void *) out;
169         op->mode = AES_MODE_ECB;
170         op->flags = 0;
171         op->len = AES_MIN_BLOCK_SIZE;
172         op->dir = AES_DIR_ENCRYPT;
173
174         geode_aes_crypt(op);
175 }
176
177
178 static void
179 geode_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
180 {
181         struct geode_aes_op *op = crypto_tfm_ctx(tfm);
182
183         if ((out == NULL) || (in == NULL))
184                 return;
185
186         op->src = (void *) in;
187         op->dst = (void *) out;
188         op->mode = AES_MODE_ECB;
189         op->flags = 0;
190         op->len = AES_MIN_BLOCK_SIZE;
191         op->dir = AES_DIR_DECRYPT;
192
193         geode_aes_crypt(op);
194 }
195
196
197 static struct crypto_alg geode_alg = {
198         .cra_name               =       "aes",
199         .cra_driver_name        =       "geode-aes-128",
200         .cra_priority           =       300,
201         .cra_alignmask          =       15,
202         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
203         .cra_blocksize          =       AES_MIN_BLOCK_SIZE,
204         .cra_ctxsize            =       sizeof(struct geode_aes_op),
205         .cra_module             =       THIS_MODULE,
206         .cra_list               =       LIST_HEAD_INIT(geode_alg.cra_list),
207         .cra_u                  =       {
208                 .cipher = {
209                         .cia_min_keysize        =  AES_KEY_LENGTH,
210                         .cia_max_keysize        =  AES_KEY_LENGTH,
211                         .cia_setkey             =  geode_setkey,
212                         .cia_encrypt            =  geode_encrypt,
213                         .cia_decrypt            =  geode_decrypt
214                 }
215         }
216 };
217
218 static int
219 geode_cbc_decrypt(struct blkcipher_desc *desc,
220                   struct scatterlist *dst, struct scatterlist *src,
221                   unsigned int nbytes)
222 {
223         struct geode_aes_op *op = crypto_blkcipher_ctx(desc->tfm);
224         struct blkcipher_walk walk;
225         int err, ret;
226
227         blkcipher_walk_init(&walk, dst, src, nbytes);
228         err = blkcipher_walk_virt(desc, &walk);
229
230         while((nbytes = walk.nbytes)) {
231                 op->src = walk.src.virt.addr,
232                 op->dst = walk.dst.virt.addr;
233                 op->mode = AES_MODE_CBC;
234                 op->len = nbytes - (nbytes % AES_MIN_BLOCK_SIZE);
235                 op->dir = AES_DIR_DECRYPT;
236
237                 memcpy(op->iv, walk.iv, AES_IV_LENGTH);
238
239                 ret = geode_aes_crypt(op);
240
241                 memcpy(walk.iv, op->iv, AES_IV_LENGTH);
242                 nbytes -= ret;
243
244                 err = blkcipher_walk_done(desc, &walk, nbytes);
245         }
246
247         return err;
248 }
249
250 static int
251 geode_cbc_encrypt(struct blkcipher_desc *desc,
252                   struct scatterlist *dst, struct scatterlist *src,
253                   unsigned int nbytes)
254 {
255         struct geode_aes_op *op = crypto_blkcipher_ctx(desc->tfm);
256         struct blkcipher_walk walk;
257         int err, ret;
258
259         blkcipher_walk_init(&walk, dst, src, nbytes);
260         err = blkcipher_walk_virt(desc, &walk);
261
262         while((nbytes = walk.nbytes)) {
263                 op->src = walk.src.virt.addr,
264                 op->dst = walk.dst.virt.addr;
265                 op->mode = AES_MODE_CBC;
266                 op->len = nbytes - (nbytes % AES_MIN_BLOCK_SIZE);
267                 op->dir = AES_DIR_ENCRYPT;
268
269                 memcpy(op->iv, walk.iv, AES_IV_LENGTH);
270
271                 ret = geode_aes_crypt(op);
272                 nbytes -= ret;
273                 err = blkcipher_walk_done(desc, &walk, nbytes);
274         }
275
276         return err;
277 }
278
279 static struct crypto_alg geode_cbc_alg = {
280         .cra_name               =       "cbc(aes)",
281         .cra_driver_name        =       "cbc-aes-geode-128",
282         .cra_priority           =       400,
283         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
284         .cra_blocksize          =       AES_MIN_BLOCK_SIZE,
285         .cra_ctxsize            =       sizeof(struct geode_aes_op),
286         .cra_alignmask          =       15,
287         .cra_type               =       &crypto_blkcipher_type,
288         .cra_module             =       THIS_MODULE,
289         .cra_list               =       LIST_HEAD_INIT(geode_cbc_alg.cra_list),
290         .cra_u                  =       {
291                 .blkcipher = {
292                         .min_keysize            =       AES_KEY_LENGTH,
293                         .max_keysize            =       AES_KEY_LENGTH,
294                         .setkey                 =       geode_setkey,
295                         .encrypt                =       geode_cbc_encrypt,
296                         .decrypt                =       geode_cbc_decrypt,
297                         .ivsize                 =       AES_IV_LENGTH,
298                 }
299         }
300 };
301
302 static int
303 geode_ecb_decrypt(struct blkcipher_desc *desc,
304                   struct scatterlist *dst, struct scatterlist *src,
305                   unsigned int nbytes)
306 {
307         struct geode_aes_op *op = crypto_blkcipher_ctx(desc->tfm);
308         struct blkcipher_walk walk;
309         int err, ret;
310
311         blkcipher_walk_init(&walk, dst, src, nbytes);
312         err = blkcipher_walk_virt(desc, &walk);
313
314         while((nbytes = walk.nbytes)) {
315                 op->src = walk.src.virt.addr,
316                 op->dst = walk.dst.virt.addr;
317                 op->mode = AES_MODE_ECB;
318                 op->len = nbytes - (nbytes % AES_MIN_BLOCK_SIZE);
319                 op->dir = AES_DIR_DECRYPT;
320
321                 ret = geode_aes_crypt(op);
322                 nbytes -= ret;
323                 err = blkcipher_walk_done(desc, &walk, nbytes);
324         }
325
326         return err;
327 }
328
329 static int
330 geode_ecb_encrypt(struct blkcipher_desc *desc,
331                   struct scatterlist *dst, struct scatterlist *src,
332                   unsigned int nbytes)
333 {
334         struct geode_aes_op *op = crypto_blkcipher_ctx(desc->tfm);
335         struct blkcipher_walk walk;
336         int err, ret;
337
338         blkcipher_walk_init(&walk, dst, src, nbytes);
339         err = blkcipher_walk_virt(desc, &walk);
340
341         while((nbytes = walk.nbytes)) {
342                 op->src = walk.src.virt.addr,
343                 op->dst = walk.dst.virt.addr;
344                 op->mode = AES_MODE_ECB;
345                 op->len = nbytes - (nbytes % AES_MIN_BLOCK_SIZE);
346                 op->dir = AES_DIR_ENCRYPT;
347
348                 ret = geode_aes_crypt(op);
349                 nbytes -= ret;
350                 ret =  blkcipher_walk_done(desc, &walk, nbytes);
351         }
352
353         return err;
354 }
355
356 static struct crypto_alg geode_ecb_alg = {
357         .cra_name               =       "ecb(aes)",
358         .cra_driver_name        =       "ecb-aes-geode-128",
359         .cra_priority           =       400,
360         .cra_flags              =       CRYPTO_ALG_TYPE_BLKCIPHER,
361         .cra_blocksize          =       AES_MIN_BLOCK_SIZE,
362         .cra_ctxsize            =       sizeof(struct geode_aes_op),
363         .cra_alignmask          =       15,
364         .cra_type               =       &crypto_blkcipher_type,
365         .cra_module             =       THIS_MODULE,
366         .cra_list               =       LIST_HEAD_INIT(geode_ecb_alg.cra_list),
367         .cra_u                  =       {
368                 .blkcipher = {
369                         .min_keysize            =       AES_KEY_LENGTH,
370                         .max_keysize            =       AES_KEY_LENGTH,
371                         .setkey                 =       geode_setkey,
372                         .encrypt                =       geode_ecb_encrypt,
373                         .decrypt                =       geode_ecb_decrypt,
374                 }
375         }
376 };
377
378 static void
379 geode_aes_remove(struct pci_dev *dev)
380 {
381         crypto_unregister_alg(&geode_alg);
382         crypto_unregister_alg(&geode_ecb_alg);
383         crypto_unregister_alg(&geode_cbc_alg);
384
385         pci_iounmap(dev, _iobase);
386         _iobase = NULL;
387
388         pci_release_regions(dev);
389         pci_disable_device(dev);
390 }
391
392
393 static int
394 geode_aes_probe(struct pci_dev *dev, const struct pci_device_id *id)
395 {
396         int ret;
397
398         if ((ret = pci_enable_device(dev)))
399                 return ret;
400
401         if ((ret = pci_request_regions(dev, "geode-aes-128")))
402                 goto eenable;
403
404         _iobase = pci_iomap(dev, 0, 0);
405
406         if (_iobase == NULL) {
407                 ret = -ENOMEM;
408                 goto erequest;
409         }
410
411         spin_lock_init(&lock);
412
413         /* Clear any pending activity */
414         iowrite32(AES_INTR_PENDING | AES_INTR_MASK, _iobase + AES_INTR_REG);
415
416         if ((ret = crypto_register_alg(&geode_alg)))
417                 goto eiomap;
418
419         if ((ret = crypto_register_alg(&geode_ecb_alg)))
420                 goto ealg;
421
422         if ((ret = crypto_register_alg(&geode_cbc_alg)))
423                 goto eecb;
424
425         printk(KERN_NOTICE "geode-aes: GEODE AES engine enabled.\n");
426         return 0;
427
428  eecb:
429         crypto_unregister_alg(&geode_ecb_alg);
430
431  ealg:
432         crypto_unregister_alg(&geode_alg);
433
434  eiomap:
435         pci_iounmap(dev, _iobase);
436
437  erequest:
438         pci_release_regions(dev);
439
440  eenable:
441         pci_disable_device(dev);
442
443         printk(KERN_ERR "geode-aes:  GEODE AES initialization failed.\n");
444         return ret;
445 }
446
447 static struct pci_device_id geode_aes_tbl[] = {
448         { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_LX_AES, PCI_ANY_ID, PCI_ANY_ID} ,
449         { 0, }
450 };
451
452 MODULE_DEVICE_TABLE(pci, geode_aes_tbl);
453
454 static struct pci_driver geode_aes_driver = {
455         .name = "Geode LX AES",
456         .id_table = geode_aes_tbl,
457         .probe = geode_aes_probe,
458         .remove = __devexit_p(geode_aes_remove)
459 };
460
461 static int __init
462 geode_aes_init(void)
463 {
464         return pci_register_driver(&geode_aes_driver);
465 }
466
467 static void __exit
468 geode_aes_exit(void)
469 {
470         pci_unregister_driver(&geode_aes_driver);
471 }
472
473 MODULE_AUTHOR("Advanced Micro Devices, Inc.");
474 MODULE_DESCRIPTION("Geode LX Hardware AES driver");
475 MODULE_LICENSE("GPL");
476
477 module_init(geode_aes_init);
478 module_exit(geode_aes_exit);