* http.h: Add HTTP_FLAG_TRY_SRV.
[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, byte *key, unsigned keylen );
47     void (*encrypt)( void *c, byte *outbuf, byte *inbuf );
48     void (*decrypt)( void *c, byte *outbuf, 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, byte *key, unsigned keylen );
63     void (*encrypt)( void *c, byte *outbuf, byte *inbuf );
64     void (*decrypt)( void *c, byte *outbuf, 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_RIJNDAEL;
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_RIJNDAEL192;
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_RIJNDAEL256;
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     cipher_table[i].algo = CIPHER_ALGO_IDEA;
180     cipher_table[i].name = idea_get_info( cipher_table[i].algo,
181                                          &cipher_table[i].keylen,
182                                          &cipher_table[i].blocksize,
183                                          &cipher_table[i].contextsize,
184                                          &cipher_table[i].setkey,
185                                          &cipher_table[i].encrypt,
186                                          &cipher_table[i].decrypt     );
187     if (cipher_table[i].name)
188       i++;  /* Note that IDEA is usually not available. */
189
190 #ifdef ALLOW_DUMMY
191     cipher_table[i].algo = CIPHER_ALGO_DUMMY;
192     cipher_table[i].name = "DUMMY";
193     cipher_table[i].blocksize = 8;
194     cipher_table[i].keylen = 128;
195     cipher_table[i].contextsize = 0;
196     cipher_table[i].setkey = dummy_setkey;
197     cipher_table[i].encrypt = dummy_encrypt_block;
198     cipher_table[i].decrypt = dummy_decrypt_block;
199     i++;
200 #endif
201
202     for( ; i < TABLE_SIZE; i++ )
203         cipher_table[i].name = NULL;
204 }
205
206
207 /****************
208  * Try to load all modules and return true if new modules are available
209  */
210 static int
211 load_cipher_modules(void)
212 {
213   static int initialized = 0;
214
215   if (!initialized ) 
216     {
217       setup_cipher_table(); /* load static modules on the first call */
218       initialized = 1;
219       return 1;
220     }
221   return 0;
222 }
223
224 /****************
225  * Map a string to the cipher algo
226  */
227 int
228 string_to_cipher_algo( const char *string )
229 {
230   int i;
231   const char *s;
232
233   /* kludge to alias RIJNDAEL to AES */
234   if ( *string == 'R' || *string == 'r')
235     {
236       if (!ascii_strcasecmp (string, "RIJNDAEL"))
237         string = "AES";
238       else if (!ascii_strcasecmp (string, "RIJNDAEL192"))
239         string = "AES192";
240       else if (!ascii_strcasecmp (string, "RIJNDAEL256"))
241         string = "AES256";
242     }
243
244   do
245     {
246       for(i=0; (s=cipher_table[i].name); i++ ) 
247         {
248           if( !ascii_strcasecmp( s, string ) )
249             return cipher_table[i].algo;
250         }
251     } while( load_cipher_modules() );
252
253     /* Didn't find it, so try the Sx format */
254     if(string[0]=='S' || string[0]=='s')
255       {
256         long val;
257         char *endptr;
258
259         string++;
260
261         val=strtol(string,&endptr,10);
262         if(*string!='\0' && *endptr=='\0' && check_cipher_algo(val)==0)
263           return val;
264       }
265
266   return 0;
267 }
268
269 /****************
270  * Map a cipher algo to a string
271  */
272 const char *
273 cipher_algo_to_string( int algo )
274 {
275     int i;
276
277     do {
278         for(i=0; cipher_table[i].name; i++ )
279             if( cipher_table[i].algo == algo )
280                 return cipher_table[i].name;
281     } while( load_cipher_modules() );
282     return NULL;
283 }
284
285
286 void
287 disable_cipher_algo( int algo )
288 {
289     int i;
290
291     for(i=0; i < DIM(disabled_algos); i++ ) {
292         if( !disabled_algos[i] || disabled_algos[i] == algo ) {
293             disabled_algos[i] = algo;
294             return;
295         }
296     }
297     /* fixme: we should use a linked list */
298     log_fatal("can't disable cipher algo %d: table full\n", algo );
299 }
300
301 /****************
302  * Return 0 if the cipher algo is available
303  */
304 int
305 check_cipher_algo( int algo )
306 {
307     int i;
308
309     do {
310        for(i=0; cipher_table[i].name; i++ )
311            if( cipher_table[i].algo == algo ) {
312                 for(i=0; i < DIM(disabled_algos); i++ ) {
313                    if( disabled_algos[i] == algo )
314                        return G10ERR_CIPHER_ALGO;
315                 }
316                 return 0; /* okay */
317            }
318     } while( load_cipher_modules() );
319     return G10ERR_CIPHER_ALGO;
320 }
321
322
323 unsigned
324 cipher_get_keylen( int algo )
325 {
326     int i;
327     unsigned len = 0;
328
329     do {
330         for(i=0; cipher_table[i].name; i++ ) {
331             if( cipher_table[i].algo == algo ) {
332                 len = cipher_table[i].keylen;
333                 if( !len )
334                     log_bug("cipher %d w/o key length\n", algo );
335                 return len;
336             }
337         }
338     } while( load_cipher_modules() );
339     log_bug("cipher %d not found\n", algo );
340     return 0;
341 }
342
343 unsigned
344 cipher_get_blocksize( int algo )
345 {
346     int i;
347     unsigned len = 0;
348
349     do {
350         for(i=0; cipher_table[i].name; i++ ) {
351             if( cipher_table[i].algo == algo ) {
352                 len = cipher_table[i].blocksize;
353                 if( !len )
354                     log_bug("cipher %d w/o blocksize\n", algo );
355                 return len;
356             }
357         }
358     } while( load_cipher_modules() );
359     log_bug("cipher %d not found\n", algo );
360     return 0;
361 }
362
363
364 /****************
365  * Open a cipher handle for use with algorithm ALGO, in mode MODE
366  * and put it into secure memory if SECURE is true.
367  */
368 CIPHER_HANDLE
369 cipher_open( int algo, int mode, int secure )
370 {
371     CIPHER_HANDLE hd;
372     int i;
373
374     fast_random_poll();
375     do {
376         for(i=0; cipher_table[i].name; i++ )
377             if( cipher_table[i].algo == algo )
378                 break;
379     } while( !cipher_table[i].name && load_cipher_modules() );
380     if( !cipher_table[i].name ) {
381         log_fatal("cipher_open: algorithm %d not available\n", algo );
382         return NULL;
383     }
384
385     /* ? perform selftest here and mark this with a flag in cipher_table ? */
386
387     hd = secure ? m_alloc_secure_clear( sizeof *hd
388                                         + cipher_table[i].contextsize
389                                         - sizeof(PROPERLY_ALIGNED_TYPE) )
390                 : m_alloc_clear( sizeof *hd + cipher_table[i].contextsize
391                                            - sizeof(PROPERLY_ALIGNED_TYPE)  );
392     hd->algo = algo;
393     hd->blocksize = cipher_table[i].blocksize;
394     hd->setkey  = cipher_table[i].setkey;
395     hd->encrypt = cipher_table[i].encrypt;
396     hd->decrypt = cipher_table[i].decrypt;
397
398     if( mode == CIPHER_MODE_AUTO_CFB ) {
399         if( algo >= 100 )
400             hd->mode = CIPHER_MODE_CFB;
401         else
402             hd->mode = CIPHER_MODE_PHILS_CFB;
403     }
404     else
405         hd->mode = mode;
406
407 #ifdef ALLOW_DUMMY
408     if( algo == CIPHER_ALGO_DUMMY )
409         hd->mode = CIPHER_MODE_DUMMY;
410 #endif
411
412     return hd;
413 }
414
415
416 void
417 cipher_close( CIPHER_HANDLE c )
418 {
419     m_free(c);
420 }
421
422
423 int
424 cipher_setkey( CIPHER_HANDLE c, byte *key, unsigned keylen )
425 {
426     return (*c->setkey)( &c->context.c, key, keylen );
427 }
428
429
430
431 void
432 cipher_setiv( CIPHER_HANDLE c, const byte *iv, unsigned ivlen )
433 {
434     memset( c->iv, 0, c->blocksize );
435     if( iv ) {
436         if( ivlen != c->blocksize )
437             log_info("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
438                                              ivlen, (unsigned)c->blocksize );
439         if( ivlen > c->blocksize )
440             ivlen = c->blocksize;
441         memcpy( c->iv, iv, ivlen );
442     }
443     c->unused = 0;
444 }
445
446
447
448 static void
449 do_ecb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
450 {
451     unsigned n;
452
453     for(n=0; n < nblocks; n++ ) {
454         (*c->encrypt)( &c->context.c, outbuf, inbuf );
455         inbuf  += c->blocksize;
456         outbuf += c->blocksize;
457     }
458 }
459
460 static void
461 do_ecb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
462 {
463     unsigned n;
464
465     for(n=0; n < nblocks; n++ ) {
466         (*c->decrypt)( &c->context.c, outbuf, inbuf );
467         inbuf  += c->blocksize;
468         outbuf += c->blocksize;
469     }
470 }
471
472 static void
473 do_cbc_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
474 {
475     unsigned int n;
476     byte *ivp;
477     int i;
478     size_t blocksize = c->blocksize;
479
480     for(n=0; n < nblocks; n++ ) {
481         /* fixme: the xor should works on words and not on
482          * bytes.  Maybe it is a good idea to enhance the cipher backend
483          * API to allow for CBC handling in the backend */
484         for(ivp=c->iv,i=0; i < blocksize; i++ )
485             outbuf[i] = inbuf[i] ^ *ivp++;
486         (*c->encrypt)( &c->context.c, outbuf, outbuf );
487         memcpy(c->iv, outbuf, blocksize );
488         inbuf  += c->blocksize;
489         outbuf += c->blocksize;
490     }
491 }
492
493 static void
494 do_cbc_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
495 {
496     unsigned int n;
497     byte *ivp;
498     int i;
499     size_t blocksize = c->blocksize;
500
501     for(n=0; n < nblocks; n++ ) {
502         /* because outbuf and inbuf might be the same, we have
503          * to save the original ciphertext block.  We use lastiv
504          * for this here because it is not used otherwise */
505         memcpy(c->lastiv, inbuf, blocksize );
506         (*c->decrypt)( &c->context.c, outbuf, inbuf );
507         for(ivp=c->iv,i=0; i < blocksize; i++ )
508             outbuf[i] ^= *ivp++;
509         memcpy(c->iv, c->lastiv, blocksize );
510         inbuf  += c->blocksize;
511         outbuf += c->blocksize;
512     }
513 }
514
515
516 static void
517 do_cfb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
518 {
519     byte *ivp;
520     size_t blocksize = c->blocksize;
521
522     if( nbytes <= c->unused ) {
523         /* short enough to be encoded by the remaining XOR mask */
524         /* XOR the input with the IV and store input into IV */
525         for(ivp=c->iv+c->blocksize - c->unused; nbytes; nbytes--, c->unused-- )
526             *outbuf++ = (*ivp++ ^= *inbuf++);
527         return;
528     }
529
530     if( c->unused ) {
531         /* XOR the input with the IV and store input into IV */
532         nbytes -= c->unused;
533         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- )
534             *outbuf++ = (*ivp++ ^= *inbuf++);
535     }
536
537     /* now we can process complete blocks */
538     while( nbytes >= blocksize ) {
539         int i;
540         /* encrypt the IV (and save the current one) */
541         memcpy( c->lastiv, c->iv, blocksize );
542         (*c->encrypt)( &c->context.c, c->iv, c->iv );
543         /* XOR the input with the IV and store input into IV */
544         for(ivp=c->iv,i=0; i < blocksize; i++ )
545             *outbuf++ = (*ivp++ ^= *inbuf++);
546         nbytes -= blocksize;
547     }
548     if( nbytes ) { /* process the remaining bytes */
549         /* encrypt the IV (and save the current one) */
550         memcpy( c->lastiv, c->iv, blocksize );
551         (*c->encrypt)( &c->context.c, c->iv, c->iv );
552         c->unused = blocksize;
553         /* and apply the xor */
554         c->unused -= nbytes;
555         for(ivp=c->iv; nbytes; nbytes-- )
556             *outbuf++ = (*ivp++ ^= *inbuf++);
557     }
558 }
559
560 static void
561 do_cfb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
562 {
563     byte *ivp;
564     ulong temp;
565     size_t blocksize = c->blocksize;
566
567     if( nbytes <= c->unused ) {
568         /* short enough to be encoded by the remaining XOR mask */
569         /* XOR the input with the IV and store input into IV */
570         for(ivp=c->iv+blocksize - c->unused; nbytes; nbytes--,c->unused--){
571             temp = *inbuf++;
572             *outbuf++ = *ivp ^ temp;
573             *ivp++ = temp;
574         }
575         return;
576     }
577
578     if( c->unused ) {
579         /* XOR the input with the IV and store input into IV */
580         nbytes -= c->unused;
581         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- ) {
582             temp = *inbuf++;
583             *outbuf++ = *ivp ^ temp;
584             *ivp++ = temp;
585         }
586     }
587
588     /* now we can process complete blocks */
589     while( nbytes >= blocksize ) {
590         int i;
591         /* encrypt the IV (and save the current one) */
592         memcpy( c->lastiv, c->iv, blocksize );
593         (*c->encrypt)( &c->context.c, c->iv, c->iv );
594         /* XOR the input with the IV and store input into IV */
595         for(ivp=c->iv,i=0; i < blocksize; i++ ) {
596             temp = *inbuf++;
597             *outbuf++ = *ivp ^ temp;
598             *ivp++ = temp;
599         }
600         nbytes -= blocksize;
601     }
602     if( nbytes ) { /* process the remaining bytes */
603         /* encrypt the IV (and save the current one) */
604         memcpy( c->lastiv, c->iv, blocksize );
605         (*c->encrypt)( &c->context.c, c->iv, c->iv );
606         c->unused = blocksize;
607         /* and apply the xor */
608         c->unused -= nbytes;
609         for(ivp=c->iv; nbytes; nbytes-- ) {
610             temp = *inbuf++;
611             *outbuf++ = *ivp ^ temp;
612             *ivp++ = temp;
613         }
614     }
615 }
616
617
618 /****************
619  * Encrypt INBUF to OUTBUF with the mode selected at open.
620  * inbuf and outbuf may overlap or be the same.
621  * Depending on the mode some some contraints apply to NBYTES.
622  */
623 void
624 cipher_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
625 {
626     switch( c->mode ) {
627       case CIPHER_MODE_ECB:
628         assert(!(nbytes%c->blocksize));
629         do_ecb_encrypt(c, outbuf, inbuf, nbytes/c->blocksize );
630         break;
631       case CIPHER_MODE_CBC:
632         assert(!(nbytes%c->blocksize));  
633         do_cbc_encrypt(c, outbuf, inbuf, nbytes/c->blocksize );
634         break;
635       case CIPHER_MODE_CFB:
636       case CIPHER_MODE_PHILS_CFB:
637         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
638         break;
639 #ifdef ALLOW_DUMMY
640       case CIPHER_MODE_DUMMY:
641         if( inbuf != outbuf )
642             memmove( outbuf, inbuf, nbytes );
643         break;
644 #endif
645       default: log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
646     }
647 }
648
649
650 /****************
651  * Decrypt INBUF to OUTBUF with the mode selected at open.
652  * inbuf and outbuf may overlap or be the same.
653  * Depending on the mode some some contraints apply to NBYTES.
654  */
655 void
656 cipher_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
657 {
658     switch( c->mode ) {
659       case CIPHER_MODE_ECB:
660         assert(!(nbytes%c->blocksize));
661         do_ecb_decrypt(c, outbuf, inbuf, nbytes/c->blocksize );
662         break;
663       case CIPHER_MODE_CBC:
664         assert(!(nbytes%c->blocksize));
665         do_cbc_decrypt(c, outbuf, inbuf, nbytes/c->blocksize );
666         break;
667       case CIPHER_MODE_CFB:
668       case CIPHER_MODE_PHILS_CFB:
669         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
670         break;
671 #ifdef ALLOW_DUMMY
672       case CIPHER_MODE_DUMMY:
673         if( inbuf != outbuf )
674             memmove( outbuf, inbuf, nbytes );
675         break;
676 #endif
677       default: log_fatal("cipher_decrypt: invalid mode %d\n", c->mode );
678     }
679 }
680
681
682
683 /****************
684  * Used for PGP's somewhat strange CFB mode. Only works if
685  * the handle is in PHILS_CFB mode
686  */
687 void
688 cipher_sync( CIPHER_HANDLE c )
689 {
690     if( c->mode == CIPHER_MODE_PHILS_CFB && c->unused ) {
691         memmove(c->iv + c->unused, c->iv, c->blocksize - c->unused );
692         memcpy(c->iv, c->lastiv + c->blocksize - c->unused, c->unused);
693         c->unused = 0;
694     }
695 }