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