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