* random.c: Fix prototype of the fast random gatherer. Noted by Joe
[gnupg.git] / cipher / cipher.c
1 /* cipher.c  -  cipher dispatcher
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <assert.h>
28 #include "util.h"
29 #include "errors.h"
30 #include "cipher.h"
31 #include "algorithms.h"
32
33 /* We have support for a DUMMY encryption cipher which comes handy to
34    debug MDCs and similar things.  Because this is a bit dangerous it
35    is not enabled. */
36 /*#define ALLOW_DUMMY 1 */
37
38 #define MAX_BLOCKSIZE 16
39 #define TABLE_SIZE 14
40
41 struct cipher_table_s {
42     const char *name;
43     int algo;
44     size_t blocksize;
45     size_t keylen;
46     size_t contextsize; /* allocate this amount of context */
47     int  (*setkey)( void *c, const byte *key, unsigned keylen );
48     void (*encrypt)( void *c, byte *outbuf, const byte *inbuf );
49     void (*decrypt)( void *c, byte *outbuf, const byte *inbuf );
50 };
51
52 static struct cipher_table_s cipher_table[TABLE_SIZE];
53 static int disabled_algos[TABLE_SIZE];
54
55
56 struct cipher_handle_s {
57     int  algo;
58     int  mode;
59     size_t blocksize;
60     byte iv[MAX_BLOCKSIZE];     /* (this should be ulong aligned) */
61     byte lastiv[MAX_BLOCKSIZE];
62     int  unused;  /* in IV */
63     int  (*setkey)( void *c, const byte *key, unsigned keylen );
64     void (*encrypt)( void *c, byte *outbuf, const byte *inbuf );
65     void (*decrypt)( void *c, byte *outbuf, const byte *inbuf );
66     PROPERLY_ALIGNED_TYPE context;
67 };
68
69
70 #ifdef ALLOW_DUMMY
71 static int
72 dummy_setkey( void *c, byte *key, unsigned keylen ) { return 0; }
73 static void
74 dummy_encrypt_block( void *c, byte *outbuf, byte *inbuf ) { BUG(); }
75 static void
76 dummy_decrypt_block( void *c, byte *outbuf, byte *inbuf ) { BUG(); }
77 #ifdef __GNUC__
78 # warning DUMMY cipher module is enabled
79 #endif
80 #endif
81
82
83 /****************
84  * Put the static entries into the table.
85  */
86 static void
87 setup_cipher_table(void)
88 {
89     int i=0;
90
91 #ifdef USE_AES
92     cipher_table[i].algo = CIPHER_ALGO_AES;
93     cipher_table[i].name = rijndael_get_info( cipher_table[i].algo,
94                                          &cipher_table[i].keylen,
95                                          &cipher_table[i].blocksize,
96                                          &cipher_table[i].contextsize,
97                                          &cipher_table[i].setkey,
98                                          &cipher_table[i].encrypt,
99                                          &cipher_table[i].decrypt     );
100     if( !cipher_table[i].name )
101         BUG();
102     i++;
103     cipher_table[i].algo = CIPHER_ALGO_AES192;
104     cipher_table[i].name = rijndael_get_info( cipher_table[i].algo,
105                                          &cipher_table[i].keylen,
106                                          &cipher_table[i].blocksize,
107                                          &cipher_table[i].contextsize,
108                                          &cipher_table[i].setkey,
109                                          &cipher_table[i].encrypt,
110                                          &cipher_table[i].decrypt     );
111     if( !cipher_table[i].name )
112         BUG();
113     i++;
114     cipher_table[i].algo = CIPHER_ALGO_AES256;
115     cipher_table[i].name = rijndael_get_info( cipher_table[i].algo,
116                                          &cipher_table[i].keylen,
117                                          &cipher_table[i].blocksize,
118                                          &cipher_table[i].contextsize,
119                                          &cipher_table[i].setkey,
120                                          &cipher_table[i].encrypt,
121                                          &cipher_table[i].decrypt     );
122     if( !cipher_table[i].name )
123         BUG();
124     i++;
125 #endif
126
127 #ifdef USE_TWOFISH
128     cipher_table[i].algo = CIPHER_ALGO_TWOFISH;
129     cipher_table[i].name = twofish_get_info( cipher_table[i].algo,
130                                          &cipher_table[i].keylen,
131                                          &cipher_table[i].blocksize,
132                                          &cipher_table[i].contextsize,
133                                          &cipher_table[i].setkey,
134                                          &cipher_table[i].encrypt,
135                                          &cipher_table[i].decrypt     );
136     if( !cipher_table[i].name )
137         BUG();
138     i++;
139 #endif
140
141 #ifdef USE_BLOWFISH
142     cipher_table[i].algo = CIPHER_ALGO_BLOWFISH;
143     cipher_table[i].name = blowfish_get_info( cipher_table[i].algo,
144                                          &cipher_table[i].keylen,
145                                          &cipher_table[i].blocksize,
146                                          &cipher_table[i].contextsize,
147                                          &cipher_table[i].setkey,
148                                          &cipher_table[i].encrypt,
149                                          &cipher_table[i].decrypt     );
150     if( !cipher_table[i].name )
151         BUG();
152     i++;
153 #endif
154
155 #ifdef USE_CAST5
156     cipher_table[i].algo = CIPHER_ALGO_CAST5;
157     cipher_table[i].name = cast5_get_info( cipher_table[i].algo,
158                                          &cipher_table[i].keylen,
159                                          &cipher_table[i].blocksize,
160                                          &cipher_table[i].contextsize,
161                                          &cipher_table[i].setkey,
162                                          &cipher_table[i].encrypt,
163                                          &cipher_table[i].decrypt     );
164     if( !cipher_table[i].name )
165         BUG();
166     i++;
167 #endif
168
169     cipher_table[i].algo = CIPHER_ALGO_3DES;
170     cipher_table[i].name = des_get_info( cipher_table[i].algo,
171                                          &cipher_table[i].keylen,
172                                          &cipher_table[i].blocksize,
173                                          &cipher_table[i].contextsize,
174                                          &cipher_table[i].setkey,
175                                          &cipher_table[i].encrypt,
176                                          &cipher_table[i].decrypt     );
177     if( !cipher_table[i].name )
178         BUG();
179     i++;
180
181 #ifdef USE_IDEA
182     cipher_table[i].algo = CIPHER_ALGO_IDEA;
183     cipher_table[i].name = idea_get_info( cipher_table[i].algo,
184                                           &cipher_table[i].keylen,
185                                           &cipher_table[i].blocksize,
186                                           &cipher_table[i].contextsize,
187                                           &cipher_table[i].setkey,
188                                           &cipher_table[i].encrypt,
189                                           &cipher_table[i].decrypt     );
190     if (cipher_table[i].name)
191       i++;  /* Note that the loadable IDEA module may not be
192                available. */
193 #endif
194
195 #ifdef ALLOW_DUMMY
196     cipher_table[i].algo = CIPHER_ALGO_DUMMY;
197     cipher_table[i].name = "DUMMY";
198     cipher_table[i].blocksize = 8;
199     cipher_table[i].keylen = 128;
200     cipher_table[i].contextsize = 0;
201     cipher_table[i].setkey = dummy_setkey;
202     cipher_table[i].encrypt = dummy_encrypt_block;
203     cipher_table[i].decrypt = dummy_decrypt_block;
204     i++;
205 #endif
206
207     for( ; i < TABLE_SIZE; i++ )
208         cipher_table[i].name = NULL;
209 }
210
211
212 /****************
213  * Try to load all modules and return true if new modules are available
214  */
215 static int
216 load_cipher_modules(void)
217 {
218   static int initialized = 0;
219
220   if (!initialized ) 
221     {
222       setup_cipher_table(); /* load static modules on the first call */
223       initialized = 1;
224       return 1;
225     }
226   return 0;
227 }
228
229 /****************
230  * Map a string to the cipher algo
231  */
232 int
233 string_to_cipher_algo( const char *string )
234 {
235   int i;
236   const char *s;
237
238   /* kludge to alias RIJNDAEL to AES */
239   if ( *string == 'R' || *string == 'r')
240     {
241       if (!ascii_strcasecmp (string, "RIJNDAEL"))
242         string = "AES";
243       else if (!ascii_strcasecmp (string, "RIJNDAEL192"))
244         string = "AES192";
245       else if (!ascii_strcasecmp (string, "RIJNDAEL256"))
246         string = "AES256";
247     }
248
249   do
250     {
251       for(i=0; (s=cipher_table[i].name); i++ ) 
252         {
253           if( !ascii_strcasecmp( s, string ) )
254             return cipher_table[i].algo;
255         }
256     } while( load_cipher_modules() );
257
258     /* Didn't find it, so try the Sx format */
259     if(string[0]=='S' || string[0]=='s')
260       {
261         long val;
262         char *endptr;
263
264         string++;
265
266         val=strtol(string,&endptr,10);
267         if(*string!='\0' && *endptr=='\0' && check_cipher_algo(val)==0)
268           return val;
269       }
270
271   return 0;
272 }
273
274 /****************
275  * Map a cipher algo to a string
276  */
277 const char *
278 cipher_algo_to_string( int algo )
279 {
280     int i;
281
282     do {
283         for(i=0; cipher_table[i].name; i++ )
284             if( cipher_table[i].algo == algo )
285                 return cipher_table[i].name;
286     } while( load_cipher_modules() );
287     return NULL;
288 }
289
290
291 void
292 disable_cipher_algo( int algo )
293 {
294     int i;
295
296     for(i=0; i < DIM(disabled_algos); i++ ) {
297         if( !disabled_algos[i] || disabled_algos[i] == algo ) {
298             disabled_algos[i] = algo;
299             return;
300         }
301     }
302     /* fixme: we should use a linked list */
303     log_fatal("can't disable cipher algo %d: table full\n", algo );
304 }
305
306 /****************
307  * Return 0 if the cipher algo is available
308  */
309 int
310 check_cipher_algo( int algo )
311 {
312     int i;
313
314     do {
315        for(i=0; cipher_table[i].name; i++ )
316            if( cipher_table[i].algo == algo ) {
317                 for(i=0; i < DIM(disabled_algos); i++ ) {
318                    if( disabled_algos[i] == algo )
319                        return G10ERR_CIPHER_ALGO;
320                 }
321                 return 0; /* okay */
322            }
323     } while( load_cipher_modules() );
324     return G10ERR_CIPHER_ALGO;
325 }
326
327
328 unsigned
329 cipher_get_keylen( int algo )
330 {
331     int i;
332     unsigned len = 0;
333
334     do {
335         for(i=0; cipher_table[i].name; i++ ) {
336             if( cipher_table[i].algo == algo ) {
337                 len = cipher_table[i].keylen;
338                 if( !len )
339                     log_bug("cipher %d w/o key length\n", algo );
340                 return len;
341             }
342         }
343     } while( load_cipher_modules() );
344     log_bug("cipher %d not found\n", algo );
345     return 0;
346 }
347
348 unsigned
349 cipher_get_blocksize( int algo )
350 {
351     int i;
352     unsigned len = 0;
353
354     do {
355         for(i=0; cipher_table[i].name; i++ ) {
356             if( cipher_table[i].algo == algo ) {
357                 len = cipher_table[i].blocksize;
358                 if( !len )
359                     log_bug("cipher %d w/o blocksize\n", algo );
360                 return len;
361             }
362         }
363     } while( load_cipher_modules() );
364     log_bug("cipher %d not found\n", algo );
365     return 0;
366 }
367
368
369 /****************
370  * Open a cipher handle for use with algorithm ALGO, in mode MODE
371  * and put it into secure memory if SECURE is true.
372  */
373 CIPHER_HANDLE
374 cipher_open( int algo, int mode, int secure )
375 {
376     CIPHER_HANDLE hd;
377     int i;
378
379     fast_random_poll();
380     do {
381         for(i=0; cipher_table[i].name; i++ )
382             if( cipher_table[i].algo == algo )
383                 break;
384     } while( !cipher_table[i].name && load_cipher_modules() );
385     if( !cipher_table[i].name ) {
386         log_fatal("cipher_open: algorithm %d not available\n", algo );
387         return NULL;
388     }
389
390     /* ? perform selftest here and mark this with a flag in cipher_table ? */
391
392     hd = secure ? m_alloc_secure_clear( sizeof *hd
393                                         + cipher_table[i].contextsize
394                                         - sizeof(PROPERLY_ALIGNED_TYPE) )
395                 : m_alloc_clear( sizeof *hd + cipher_table[i].contextsize
396                                            - sizeof(PROPERLY_ALIGNED_TYPE)  );
397     hd->algo = algo;
398     hd->blocksize = cipher_table[i].blocksize;
399     hd->setkey  = cipher_table[i].setkey;
400     hd->encrypt = cipher_table[i].encrypt;
401     hd->decrypt = cipher_table[i].decrypt;
402
403     if( mode == CIPHER_MODE_AUTO_CFB ) {
404         if( algo >= 100 )
405             hd->mode = CIPHER_MODE_CFB;
406         else
407             hd->mode = CIPHER_MODE_PHILS_CFB;
408     }
409     else
410         hd->mode = mode;
411
412 #ifdef ALLOW_DUMMY
413     if( algo == CIPHER_ALGO_DUMMY )
414         hd->mode = CIPHER_MODE_DUMMY;
415 #endif
416
417     return hd;
418 }
419
420
421 void
422 cipher_close( CIPHER_HANDLE c )
423 {
424     m_free(c);
425 }
426
427
428 int
429 cipher_setkey( CIPHER_HANDLE c, byte *key, unsigned keylen )
430 {
431     return (*c->setkey)( &c->context.c, key, keylen );
432 }
433
434
435 void
436 cipher_setiv( CIPHER_HANDLE c, const byte *iv, unsigned ivlen )
437 {
438     memset( c->iv, 0, c->blocksize );
439     if( iv ) {
440         if( ivlen != c->blocksize )
441             log_info("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
442                                              ivlen, (unsigned)c->blocksize );
443         if( ivlen > c->blocksize )
444             ivlen = c->blocksize;
445         memcpy( c->iv, iv, ivlen );
446     }
447     c->unused = 0;
448 }
449
450 static void
451 do_ecb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
452 {
453     unsigned n;
454
455     for(n=0; n < nblocks; n++ ) {
456         (*c->encrypt)( &c->context.c, outbuf, inbuf );
457         inbuf  += c->blocksize;
458         outbuf += c->blocksize;
459     }
460 }
461
462 static void
463 do_ecb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
464 {
465     unsigned n;
466
467     for(n=0; n < nblocks; n++ ) {
468         (*c->decrypt)( &c->context.c, outbuf, inbuf );
469         inbuf  += c->blocksize;
470         outbuf += c->blocksize;
471     }
472 }
473
474 static void
475 do_cbc_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
476 {
477     unsigned int n;
478     byte *ivp;
479     int i;
480     size_t blocksize = c->blocksize;
481
482     for(n=0; n < nblocks; n++ ) {
483         /* fixme: the xor should works on words and not on
484          * bytes.  Maybe it is a good idea to enhance the cipher backend
485          * API to allow for CBC handling in the backend */
486         for(ivp=c->iv,i=0; i < blocksize; i++ )
487             outbuf[i] = inbuf[i] ^ *ivp++;
488         (*c->encrypt)( &c->context.c, outbuf, outbuf );
489         memcpy(c->iv, outbuf, blocksize );
490         inbuf  += c->blocksize;
491         outbuf += c->blocksize;
492     }
493 }
494
495 static void
496 do_cbc_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
497 {
498     unsigned int n;
499     byte *ivp;
500     int i;
501     size_t blocksize = c->blocksize;
502
503     for(n=0; n < nblocks; n++ ) {
504         /* because outbuf and inbuf might be the same, we have
505          * to save the original ciphertext block.  We use lastiv
506          * for this here because it is not used otherwise */
507         memcpy(c->lastiv, inbuf, blocksize );
508         (*c->decrypt)( &c->context.c, outbuf, inbuf );
509         for(ivp=c->iv,i=0; i < blocksize; i++ )
510             outbuf[i] ^= *ivp++;
511         memcpy(c->iv, c->lastiv, blocksize );
512         inbuf  += c->blocksize;
513         outbuf += c->blocksize;
514     }
515 }
516
517
518 static void
519 do_cfb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
520 {
521     byte *ivp;
522     size_t blocksize = c->blocksize;
523
524     if( nbytes <= c->unused ) {
525         /* short enough to be encoded by the remaining XOR mask */
526         /* XOR the input with the IV and store input into IV */
527         for(ivp=c->iv+c->blocksize - c->unused; nbytes; nbytes--, c->unused-- )
528             *outbuf++ = (*ivp++ ^= *inbuf++);
529         return;
530     }
531
532     if( c->unused ) {
533         /* XOR the input with the IV and store input into IV */
534         nbytes -= c->unused;
535         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- )
536             *outbuf++ = (*ivp++ ^= *inbuf++);
537     }
538
539     /* now we can process complete blocks */
540     while( nbytes >= blocksize ) {
541         int i;
542         /* encrypt the IV (and save the current one) */
543         memcpy( c->lastiv, c->iv, blocksize );
544         (*c->encrypt)( &c->context.c, c->iv, c->iv );
545         /* XOR the input with the IV and store input into IV */
546         for(ivp=c->iv,i=0; i < blocksize; i++ )
547             *outbuf++ = (*ivp++ ^= *inbuf++);
548         nbytes -= blocksize;
549     }
550     if( nbytes ) { /* process the remaining bytes */
551         /* encrypt the IV (and save the current one) */
552         memcpy( c->lastiv, c->iv, blocksize );
553         (*c->encrypt)( &c->context.c, c->iv, c->iv );
554         c->unused = blocksize;
555         /* and apply the xor */
556         c->unused -= nbytes;
557         for(ivp=c->iv; nbytes; nbytes-- )
558             *outbuf++ = (*ivp++ ^= *inbuf++);
559     }
560 }
561
562 static void
563 do_cfb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
564 {
565     byte *ivp;
566     ulong temp;
567     size_t blocksize = c->blocksize;
568
569     if( nbytes <= c->unused ) {
570         /* short enough to be encoded by the remaining XOR mask */
571         /* XOR the input with the IV and store input into IV */
572         for(ivp=c->iv+blocksize - c->unused; nbytes; nbytes--,c->unused--){
573             temp = *inbuf++;
574             *outbuf++ = *ivp ^ temp;
575             *ivp++ = temp;
576         }
577         return;
578     }
579
580     if( c->unused ) {
581         /* XOR the input with the IV and store input into IV */
582         nbytes -= c->unused;
583         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- ) {
584             temp = *inbuf++;
585             *outbuf++ = *ivp ^ temp;
586             *ivp++ = temp;
587         }
588     }
589
590     /* now we can process complete blocks */
591     while( nbytes >= blocksize ) {
592         int i;
593         /* encrypt the IV (and save the current one) */
594         memcpy( c->lastiv, c->iv, blocksize );
595         (*c->encrypt)( &c->context.c, c->iv, c->iv );
596         /* XOR the input with the IV and store input into IV */
597         for(ivp=c->iv,i=0; i < blocksize; i++ ) {
598             temp = *inbuf++;
599             *outbuf++ = *ivp ^ temp;
600             *ivp++ = temp;
601         }
602         nbytes -= blocksize;
603     }
604     if( nbytes ) { /* process the remaining bytes */
605         /* encrypt the IV (and save the current one) */
606         memcpy( c->lastiv, c->iv, blocksize );
607         (*c->encrypt)( &c->context.c, c->iv, c->iv );
608         c->unused = blocksize;
609         /* and apply the xor */
610         c->unused -= nbytes;
611         for(ivp=c->iv; nbytes; nbytes-- ) {
612             temp = *inbuf++;
613             *outbuf++ = *ivp ^ temp;
614             *ivp++ = temp;
615         }
616     }
617 }
618
619
620 /****************
621  * Encrypt INBUF to OUTBUF with the mode selected at open.
622  * inbuf and outbuf may overlap or be the same.
623  * Depending on the mode some some contraints apply to NBYTES.
624  */
625 void
626 cipher_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
627 {
628     switch( c->mode ) {
629       case CIPHER_MODE_ECB:
630         assert(!(nbytes%c->blocksize));
631         do_ecb_encrypt(c, outbuf, inbuf, nbytes/c->blocksize );
632         break;
633       case CIPHER_MODE_CBC:
634         assert(!(nbytes%c->blocksize));  
635         do_cbc_encrypt(c, outbuf, inbuf, nbytes/c->blocksize );
636         break;
637       case CIPHER_MODE_CFB:
638       case CIPHER_MODE_PHILS_CFB:
639         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
640         break;
641 #ifdef ALLOW_DUMMY
642       case CIPHER_MODE_DUMMY:
643         if( inbuf != outbuf )
644             memmove( outbuf, inbuf, nbytes );
645         break;
646 #endif
647       default: log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
648     }
649 }
650
651
652 /****************
653  * Decrypt INBUF to OUTBUF with the mode selected at open.
654  * inbuf and outbuf may overlap or be the same.
655  * Depending on the mode some some contraints apply to NBYTES.
656  */
657 void
658 cipher_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
659 {
660     switch( c->mode ) {
661       case CIPHER_MODE_ECB:
662         assert(!(nbytes%c->blocksize));
663         do_ecb_decrypt(c, outbuf, inbuf, nbytes/c->blocksize );
664         break;
665       case CIPHER_MODE_CBC:
666         assert(!(nbytes%c->blocksize));
667         do_cbc_decrypt(c, outbuf, inbuf, nbytes/c->blocksize );
668         break;
669       case CIPHER_MODE_CFB:
670       case CIPHER_MODE_PHILS_CFB:
671         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
672         break;
673 #ifdef ALLOW_DUMMY
674       case CIPHER_MODE_DUMMY:
675         if( inbuf != outbuf )
676             memmove( outbuf, inbuf, nbytes );
677         break;
678 #endif
679       default: log_fatal("cipher_decrypt: invalid mode %d\n", c->mode );
680     }
681 }
682
683
684
685 /****************
686  * Used for PGP's somewhat strange CFB mode. Only works if
687  * the handle is in PHILS_CFB mode
688  */
689 void
690 cipher_sync( CIPHER_HANDLE c )
691 {
692     if( c->mode == CIPHER_MODE_PHILS_CFB && c->unused ) {
693         memmove(c->iv + c->unused, c->iv, c->blocksize - c->unused );
694         memcpy(c->iv, c->lastiv + c->blocksize - c->unused, c->unused);
695         c->unused = 0;
696     }
697 }