* md.c (string_to_digest_algo): Enable read-write SHA-256 support.
[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
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
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
451
452 static void
453 do_ecb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
454 {
455     unsigned n;
456
457     for(n=0; n < nblocks; n++ ) {
458         (*c->encrypt)( &c->context.c, outbuf, inbuf );
459         inbuf  += c->blocksize;
460         outbuf += c->blocksize;
461     }
462 }
463
464 static void
465 do_ecb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
466 {
467     unsigned n;
468
469     for(n=0; n < nblocks; n++ ) {
470         (*c->decrypt)( &c->context.c, outbuf, inbuf );
471         inbuf  += c->blocksize;
472         outbuf += c->blocksize;
473     }
474 }
475
476 static void
477 do_cbc_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
478 {
479     unsigned int n;
480     byte *ivp;
481     int i;
482     size_t blocksize = c->blocksize;
483
484     for(n=0; n < nblocks; n++ ) {
485         /* fixme: the xor should works on words and not on
486          * bytes.  Maybe it is a good idea to enhance the cipher backend
487          * API to allow for CBC handling in the backend */
488         for(ivp=c->iv,i=0; i < blocksize; i++ )
489             outbuf[i] = inbuf[i] ^ *ivp++;
490         (*c->encrypt)( &c->context.c, outbuf, outbuf );
491         memcpy(c->iv, outbuf, blocksize );
492         inbuf  += c->blocksize;
493         outbuf += c->blocksize;
494     }
495 }
496
497 static void
498 do_cbc_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
499 {
500     unsigned int n;
501     byte *ivp;
502     int i;
503     size_t blocksize = c->blocksize;
504
505     for(n=0; n < nblocks; n++ ) {
506         /* because outbuf and inbuf might be the same, we have
507          * to save the original ciphertext block.  We use lastiv
508          * for this here because it is not used otherwise */
509         memcpy(c->lastiv, inbuf, blocksize );
510         (*c->decrypt)( &c->context.c, outbuf, inbuf );
511         for(ivp=c->iv,i=0; i < blocksize; i++ )
512             outbuf[i] ^= *ivp++;
513         memcpy(c->iv, c->lastiv, blocksize );
514         inbuf  += c->blocksize;
515         outbuf += c->blocksize;
516     }
517 }
518
519
520 static void
521 do_cfb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
522 {
523     byte *ivp;
524     size_t blocksize = c->blocksize;
525
526     if( nbytes <= c->unused ) {
527         /* short enough to be encoded by the remaining XOR mask */
528         /* XOR the input with the IV and store input into IV */
529         for(ivp=c->iv+c->blocksize - c->unused; nbytes; nbytes--, c->unused-- )
530             *outbuf++ = (*ivp++ ^= *inbuf++);
531         return;
532     }
533
534     if( c->unused ) {
535         /* XOR the input with the IV and store input into IV */
536         nbytes -= c->unused;
537         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- )
538             *outbuf++ = (*ivp++ ^= *inbuf++);
539     }
540
541     /* now we can process complete blocks */
542     while( nbytes >= blocksize ) {
543         int i;
544         /* encrypt the IV (and save the current one) */
545         memcpy( c->lastiv, c->iv, blocksize );
546         (*c->encrypt)( &c->context.c, c->iv, c->iv );
547         /* XOR the input with the IV and store input into IV */
548         for(ivp=c->iv,i=0; i < blocksize; i++ )
549             *outbuf++ = (*ivp++ ^= *inbuf++);
550         nbytes -= blocksize;
551     }
552     if( nbytes ) { /* process the remaining bytes */
553         /* encrypt the IV (and save the current one) */
554         memcpy( c->lastiv, c->iv, blocksize );
555         (*c->encrypt)( &c->context.c, c->iv, c->iv );
556         c->unused = blocksize;
557         /* and apply the xor */
558         c->unused -= nbytes;
559         for(ivp=c->iv; nbytes; nbytes-- )
560             *outbuf++ = (*ivp++ ^= *inbuf++);
561     }
562 }
563
564 static void
565 do_cfb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
566 {
567     byte *ivp;
568     ulong temp;
569     size_t blocksize = c->blocksize;
570
571     if( nbytes <= c->unused ) {
572         /* short enough to be encoded by the remaining XOR mask */
573         /* XOR the input with the IV and store input into IV */
574         for(ivp=c->iv+blocksize - c->unused; nbytes; nbytes--,c->unused--){
575             temp = *inbuf++;
576             *outbuf++ = *ivp ^ temp;
577             *ivp++ = temp;
578         }
579         return;
580     }
581
582     if( c->unused ) {
583         /* XOR the input with the IV and store input into IV */
584         nbytes -= c->unused;
585         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- ) {
586             temp = *inbuf++;
587             *outbuf++ = *ivp ^ temp;
588             *ivp++ = temp;
589         }
590     }
591
592     /* now we can process complete blocks */
593     while( nbytes >= blocksize ) {
594         int i;
595         /* encrypt the IV (and save the current one) */
596         memcpy( c->lastiv, c->iv, blocksize );
597         (*c->encrypt)( &c->context.c, c->iv, c->iv );
598         /* XOR the input with the IV and store input into IV */
599         for(ivp=c->iv,i=0; i < blocksize; i++ ) {
600             temp = *inbuf++;
601             *outbuf++ = *ivp ^ temp;
602             *ivp++ = temp;
603         }
604         nbytes -= blocksize;
605     }
606     if( nbytes ) { /* process the remaining bytes */
607         /* encrypt the IV (and save the current one) */
608         memcpy( c->lastiv, c->iv, blocksize );
609         (*c->encrypt)( &c->context.c, c->iv, c->iv );
610         c->unused = blocksize;
611         /* and apply the xor */
612         c->unused -= nbytes;
613         for(ivp=c->iv; nbytes; nbytes-- ) {
614             temp = *inbuf++;
615             *outbuf++ = *ivp ^ temp;
616             *ivp++ = temp;
617         }
618     }
619 }
620
621
622 /****************
623  * Encrypt INBUF to OUTBUF with the mode selected at open.
624  * inbuf and outbuf may overlap or be the same.
625  * Depending on the mode some some contraints apply to NBYTES.
626  */
627 void
628 cipher_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
629 {
630     switch( c->mode ) {
631       case CIPHER_MODE_ECB:
632         assert(!(nbytes%c->blocksize));
633         do_ecb_encrypt(c, outbuf, inbuf, nbytes/c->blocksize );
634         break;
635       case CIPHER_MODE_CBC:
636         assert(!(nbytes%c->blocksize));  
637         do_cbc_encrypt(c, outbuf, inbuf, nbytes/c->blocksize );
638         break;
639       case CIPHER_MODE_CFB:
640       case CIPHER_MODE_PHILS_CFB:
641         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
642         break;
643 #ifdef ALLOW_DUMMY
644       case CIPHER_MODE_DUMMY:
645         if( inbuf != outbuf )
646             memmove( outbuf, inbuf, nbytes );
647         break;
648 #endif
649       default: log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
650     }
651 }
652
653
654 /****************
655  * Decrypt INBUF to OUTBUF with the mode selected at open.
656  * inbuf and outbuf may overlap or be the same.
657  * Depending on the mode some some contraints apply to NBYTES.
658  */
659 void
660 cipher_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
661 {
662     switch( c->mode ) {
663       case CIPHER_MODE_ECB:
664         assert(!(nbytes%c->blocksize));
665         do_ecb_decrypt(c, outbuf, inbuf, nbytes/c->blocksize );
666         break;
667       case CIPHER_MODE_CBC:
668         assert(!(nbytes%c->blocksize));
669         do_cbc_decrypt(c, outbuf, inbuf, nbytes/c->blocksize );
670         break;
671       case CIPHER_MODE_CFB:
672       case CIPHER_MODE_PHILS_CFB:
673         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
674         break;
675 #ifdef ALLOW_DUMMY
676       case CIPHER_MODE_DUMMY:
677         if( inbuf != outbuf )
678             memmove( outbuf, inbuf, nbytes );
679         break;
680 #endif
681       default: log_fatal("cipher_decrypt: invalid mode %d\n", c->mode );
682     }
683 }
684
685
686
687 /****************
688  * Used for PGP's somewhat strange CFB mode. Only works if
689  * the handle is in PHILS_CFB mode
690  */
691 void
692 cipher_sync( CIPHER_HANDLE c )
693 {
694     if( c->mode == CIPHER_MODE_PHILS_CFB && c->unused ) {
695         memmove(c->iv + c->unused, c->iv, c->blocksize - c->unused );
696         memcpy(c->iv, c->lastiv + c->blocksize - c->unused, c->unused);
697         c->unused = 0;
698     }
699 }