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