See ChangeLog: Wed Apr 7 20:51:39 CEST 1999 Werner Koch
[gnupg.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
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 static int
68 dummy_setkey( void *c, byte *key, unsigned keylen ) { return 0; }
69 static void
70 dummy_encrypt_block( void *c, byte *outbuf, byte *inbuf ) { BUG(); }
71 static void
72 dummy_decrypt_block( void *c, byte *outbuf, byte *inbuf ) { BUG(); }
73
74
75
76 /****************
77  * Put the static entries into the table.
78  */
79 static void
80 setup_cipher_table(void)
81 {
82
83     int i;
84
85     i = 0;
86     cipher_table[i].algo = CIPHER_ALGO_TWOFISH;
87     cipher_table[i].name = twofish_get_info( cipher_table[i].algo,
88                                          &cipher_table[i].keylen,
89                                          &cipher_table[i].blocksize,
90                                          &cipher_table[i].contextsize,
91                                          &cipher_table[i].setkey,
92                                          &cipher_table[i].encrypt,
93                                          &cipher_table[i].decrypt     );
94     if( !cipher_table[i].name )
95         BUG();
96     i++;
97     cipher_table[i].algo = CIPHER_ALGO_BLOWFISH;
98     cipher_table[i].name = blowfish_get_info( cipher_table[i].algo,
99                                          &cipher_table[i].keylen,
100                                          &cipher_table[i].blocksize,
101                                          &cipher_table[i].contextsize,
102                                          &cipher_table[i].setkey,
103                                          &cipher_table[i].encrypt,
104                                          &cipher_table[i].decrypt     );
105     if( !cipher_table[i].name )
106         BUG();
107     i++;
108     cipher_table[i].algo = CIPHER_ALGO_CAST5;
109     cipher_table[i].name = cast5_get_info( cipher_table[i].algo,
110                                          &cipher_table[i].keylen,
111                                          &cipher_table[i].blocksize,
112                                          &cipher_table[i].contextsize,
113                                          &cipher_table[i].setkey,
114                                          &cipher_table[i].encrypt,
115                                          &cipher_table[i].decrypt     );
116     if( !cipher_table[i].name )
117         BUG();
118     i++;
119     cipher_table[i].algo = CIPHER_ALGO_3DES;
120     cipher_table[i].name = des_get_info( cipher_table[i].algo,
121                                          &cipher_table[i].keylen,
122                                          &cipher_table[i].blocksize,
123                                          &cipher_table[i].contextsize,
124                                          &cipher_table[i].setkey,
125                                          &cipher_table[i].encrypt,
126                                          &cipher_table[i].decrypt     );
127     if( !cipher_table[i].name )
128         BUG();
129     i++;
130     cipher_table[i].algo = CIPHER_ALGO_BLOWFISH160;
131     cipher_table[i].name = blowfish_get_info( cipher_table[i].algo,
132                                          &cipher_table[i].keylen,
133                                          &cipher_table[i].blocksize,
134                                          &cipher_table[i].contextsize,
135                                          &cipher_table[i].setkey,
136                                          &cipher_table[i].encrypt,
137                                          &cipher_table[i].decrypt     );
138     if( !cipher_table[i].name )
139         BUG();
140     i++;
141     cipher_table[i].algo = CIPHER_ALGO_TWOFISH_OLD;
142     cipher_table[i].name = twofish_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     cipher_table[i].algo = CIPHER_ALGO_DUMMY;
153     cipher_table[i].name = "DUMMY";
154     cipher_table[i].blocksize = 8;
155     cipher_table[i].keylen = 128;
156     cipher_table[i].contextsize = 0;
157     cipher_table[i].setkey = dummy_setkey;
158     cipher_table[i].encrypt = dummy_encrypt_block;
159     cipher_table[i].decrypt = dummy_decrypt_block;
160     i++;
161
162     for( ; i < TABLE_SIZE; i++ )
163         cipher_table[i].name = NULL;
164 }
165
166
167 /****************
168  * Try to load all modules and return true if new modules are available
169  */
170 static int
171 load_cipher_modules(void)
172 {
173     static int done = 0;
174     static int initialized = 0;
175     void *context = NULL;
176     struct cipher_table_s *ct;
177     int ct_idx;
178     int i;
179     const char *name;
180     int any = 0;
181
182     if( !initialized ) {
183         cipher_modules_constructor();
184         setup_cipher_table(); /* load static modules on the first call */
185         initialized = 1;
186         return 1;
187     }
188
189     if( done )
190         return 0;
191     done = 1;
192
193     for(ct_idx=0, ct = cipher_table; ct_idx < TABLE_SIZE; ct_idx++,ct++ ) {
194         if( !ct->name )
195             break;
196     }
197     if( ct_idx >= TABLE_SIZE-1 )
198         BUG(); /* table already full */
199     /* now load all extensions */
200     while( (name = enum_gnupgext_ciphers( &context, &ct->algo,
201                                 &ct->keylen, &ct->blocksize, &ct->contextsize,
202                                 &ct->setkey, &ct->encrypt, &ct->decrypt)) ) {
203         if( ct->blocksize != 8 && ct->blocksize != 16 ) {
204             log_info("skipping cipher %d: unsupported blocksize\n", ct->algo);
205             continue;
206         }
207         for(i=0; cipher_table[i].name; i++ )
208             if( cipher_table[i].algo == ct->algo )
209                 break;
210         if( cipher_table[i].name ) {
211             log_info("skipping cipher %d: already loaded\n", ct->algo );
212             continue;
213         }
214         /* put it into the table */
215         if( g10_opt_verbose > 1 )
216             log_info("loaded cipher %d (%s)\n", ct->algo, name);
217         ct->name = name;
218         ct_idx++;
219         ct++;
220         any = 1;
221         /* check whether there are more available table slots */
222         if( ct_idx >= TABLE_SIZE-1 ) {
223             log_info("cipher table full; ignoring other extensions\n");
224             break;
225         }
226     }
227     enum_gnupgext_ciphers( &context, NULL, NULL, NULL, NULL,
228                                            NULL, NULL, NULL );
229     return any;
230 }
231
232
233
234
235
236
237
238 /****************
239  * Map a string to the cipher algo
240  */
241 int
242 string_to_cipher_algo( const char *string )
243 {
244     int i;
245     const char *s;
246
247     do {
248         for(i=0; (s=cipher_table[i].name); i++ )
249             if( !stricmp( s, string ) )
250                 return cipher_table[i].algo;
251     } while( load_cipher_modules() );
252     return 0;
253 }
254
255 /****************
256  * Map a cipher algo to a string
257  */
258 const char *
259 cipher_algo_to_string( int algo )
260 {
261     int i;
262
263     do {
264         for(i=0; cipher_table[i].name; i++ )
265             if( cipher_table[i].algo == algo )
266                 return cipher_table[i].name;
267     } while( load_cipher_modules() );
268     return NULL;
269 }
270
271 /****************
272  * Return 0 if the cipher algo is available
273  */
274 int
275 check_cipher_algo( int algo )
276 {
277     int i;
278
279     do {
280        for(i=0; cipher_table[i].name; i++ )
281            if( cipher_table[i].algo == algo )
282                return 0; /* okay */
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( hd->blocksize > 8
366             || algo == CIPHER_ALGO_BLOWFISH160 || algo >= 100 )
367             hd->mode = CIPHER_MODE_CFB;
368         else
369             hd->mode = CIPHER_MODE_PHILS_CFB;
370     }
371     else
372         hd->mode = mode;
373
374     return hd;
375 }
376
377
378 void
379 cipher_close( CIPHER_HANDLE c )
380 {
381     m_free(c);
382 }
383
384
385 int
386 cipher_setkey( CIPHER_HANDLE c, byte *key, unsigned keylen )
387 {
388     return (*c->setkey)( &c->context.c, key, keylen );
389 }
390
391
392
393 void
394 cipher_setiv( CIPHER_HANDLE c, const byte *iv )
395 {
396     if( iv )
397         memcpy( c->iv, iv, c->blocksize );
398     else
399         memset( c->iv, 0, c->blocksize );
400     c->unused = 0;
401 }
402
403
404
405 static void
406 do_ecb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
407 {
408     unsigned n;
409
410     for(n=0; n < nblocks; n++ ) {
411         (*c->encrypt)( &c->context.c, outbuf, inbuf );
412         inbuf  += c->blocksize;
413         outbuf += c->blocksize;
414     }
415 }
416
417 static void
418 do_ecb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
419 {
420     unsigned n;
421
422     for(n=0; n < nblocks; n++ ) {
423         (*c->decrypt)( &c->context.c, outbuf, inbuf );
424         inbuf  += c->blocksize;
425         outbuf += c->blocksize;
426     }
427 }
428
429
430 static void
431 do_cfb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
432 {
433     byte *ivp;
434     size_t blocksize = c->blocksize;
435
436     if( nbytes <= c->unused ) {
437         /* short enough to be encoded by the remaining XOR mask */
438         /* XOR the input with the IV and store input into IV */
439         for(ivp=c->iv+c->blocksize - c->unused; nbytes; nbytes--, c->unused-- )
440             *outbuf++ = (*ivp++ ^= *inbuf++);
441         return;
442     }
443
444     if( c->unused ) {
445         /* XOR the input with the IV and store input into IV */
446         nbytes -= c->unused;
447         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- )
448             *outbuf++ = (*ivp++ ^= *inbuf++);
449     }
450
451     /* now we can process complete blocks */
452     while( nbytes >= blocksize ) {
453         int i;
454         /* encrypt the IV (and save the current one) */
455         memcpy( c->lastiv, c->iv, blocksize );
456         (*c->encrypt)( &c->context.c, c->iv, c->iv );
457         /* XOR the input with the IV and store input into IV */
458         for(ivp=c->iv,i=0; i < blocksize; i++ )
459             *outbuf++ = (*ivp++ ^= *inbuf++);
460         nbytes -= blocksize;
461     }
462     if( nbytes ) { /* process the remaining bytes */
463         /* encrypt the IV (and save the current one) */
464         memcpy( c->lastiv, c->iv, blocksize );
465         (*c->encrypt)( &c->context.c, c->iv, c->iv );
466         c->unused = blocksize;
467         /* and apply the xor */
468         c->unused -= nbytes;
469         for(ivp=c->iv; nbytes; nbytes-- )
470             *outbuf++ = (*ivp++ ^= *inbuf++);
471     }
472 }
473
474 static void
475 do_cfb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
476 {
477     byte *ivp;
478     ulong temp;
479     size_t blocksize = c->blocksize;
480
481     if( nbytes <= c->unused ) {
482         /* short enough to be encoded by the remaining XOR mask */
483         /* XOR the input with the IV and store input into IV */
484         for(ivp=c->iv+blocksize - c->unused; nbytes; nbytes--,c->unused--){
485             temp = *inbuf++;
486             *outbuf++ = *ivp ^ temp;
487             *ivp++ = temp;
488         }
489         return;
490     }
491
492     if( c->unused ) {
493         /* XOR the input with the IV and store input into IV */
494         nbytes -= c->unused;
495         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- ) {
496             temp = *inbuf++;
497             *outbuf++ = *ivp ^ temp;
498             *ivp++ = temp;
499         }
500     }
501
502     /* now we can process complete blocks */
503     while( nbytes >= blocksize ) {
504         int i;
505         /* encrypt the IV (and save the current one) */
506         memcpy( c->lastiv, c->iv, blocksize );
507         (*c->encrypt)( &c->context.c, c->iv, c->iv );
508         /* XOR the input with the IV and store input into IV */
509         for(ivp=c->iv,i=0; i < blocksize; i++ ) {
510             temp = *inbuf++;
511             *outbuf++ = *ivp ^ temp;
512             *ivp++ = temp;
513         }
514         nbytes -= blocksize;
515     }
516     if( nbytes ) { /* process the remaining bytes */
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         c->unused = blocksize;
521         /* and apply the xor */
522         c->unused -= nbytes;
523         for(ivp=c->iv; nbytes; nbytes-- ) {
524             temp = *inbuf++;
525             *outbuf++ = *ivp ^ temp;
526             *ivp++ = temp;
527         }
528     }
529 }
530
531
532 /****************
533  * Encrypt INBUF to OUTBUF with the mode selected at open.
534  * inbuf and outbuf may overlap or be the same.
535  * Depending on the mode some some contraints apply to NBYTES.
536  */
537 void
538 cipher_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
539 {
540     switch( c->mode ) {
541       case CIPHER_MODE_ECB:
542         assert(!(nbytes%8));
543         do_ecb_encrypt(c, outbuf, inbuf, nbytes/8 );
544         break;
545       case CIPHER_MODE_CFB:
546       case CIPHER_MODE_PHILS_CFB:
547         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
548         break;
549       case CIPHER_MODE_DUMMY:
550         if( inbuf != outbuf )
551             memmove( outbuf, inbuf, nbytes );
552         break;
553       default: log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
554     }
555 }
556
557
558 /****************
559  * Decrypt INBUF to OUTBUF with the mode selected at open.
560  * inbuf and outbuf may overlap or be the same.
561  * Depending on the mode some some contraints apply to NBYTES.
562  */
563 void
564 cipher_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
565 {
566     switch( c->mode ) {
567       case CIPHER_MODE_ECB:
568         assert(!(nbytes%8));
569         do_ecb_decrypt(c, outbuf, inbuf, nbytes/8 );
570         break;
571       case CIPHER_MODE_CFB:
572       case CIPHER_MODE_PHILS_CFB:
573         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
574         break;
575       case CIPHER_MODE_DUMMY:
576         if( inbuf != outbuf )
577             memmove( outbuf, inbuf, nbytes );
578         break;
579       default: log_fatal("cipher_decrypt: invalid mode %d\n", c->mode );
580     }
581 }
582
583
584
585 /****************
586  * Used for PGP's somewhat strange CFB mode. Only works if
587  * the handle is in PHILS_CFB mode
588  */
589 void
590 cipher_sync( CIPHER_HANDLE c )
591 {
592     if( c->mode == CIPHER_MODE_PHILS_CFB && c->unused ) {
593         memmove(c->iv + c->unused, c->iv, c->blocksize - c->unused );
594         memcpy(c->iv, c->lastiv + c->blocksize - c->unused, c->unused);
595         c->unused = 0;
596     }
597 }
598