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