See ChangeLog: Sun Apr 18 10:11:28 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
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   if( getenv("GNUPG_ENABLE_TWOFISH") ) {
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   }
99     cipher_table[i].algo = CIPHER_ALGO_BLOWFISH;
100     cipher_table[i].name = blowfish_get_info( cipher_table[i].algo,
101                                          &cipher_table[i].keylen,
102                                          &cipher_table[i].blocksize,
103                                          &cipher_table[i].contextsize,
104                                          &cipher_table[i].setkey,
105                                          &cipher_table[i].encrypt,
106                                          &cipher_table[i].decrypt     );
107     if( !cipher_table[i].name )
108         BUG();
109     i++;
110     cipher_table[i].algo = CIPHER_ALGO_CAST5;
111     cipher_table[i].name = cast5_get_info( cipher_table[i].algo,
112                                          &cipher_table[i].keylen,
113                                          &cipher_table[i].blocksize,
114                                          &cipher_table[i].contextsize,
115                                          &cipher_table[i].setkey,
116                                          &cipher_table[i].encrypt,
117                                          &cipher_table[i].decrypt     );
118     if( !cipher_table[i].name )
119         BUG();
120     i++;
121     cipher_table[i].algo = CIPHER_ALGO_3DES;
122     cipher_table[i].name = des_get_info( cipher_table[i].algo,
123                                          &cipher_table[i].keylen,
124                                          &cipher_table[i].blocksize,
125                                          &cipher_table[i].contextsize,
126                                          &cipher_table[i].setkey,
127                                          &cipher_table[i].encrypt,
128                                          &cipher_table[i].decrypt     );
129     if( !cipher_table[i].name )
130         BUG();
131     i++;
132     cipher_table[i].algo = CIPHER_ALGO_DUMMY;
133     cipher_table[i].name = "DUMMY";
134     cipher_table[i].blocksize = 8;
135     cipher_table[i].keylen = 128;
136     cipher_table[i].contextsize = 0;
137     cipher_table[i].setkey = dummy_setkey;
138     cipher_table[i].encrypt = dummy_encrypt_block;
139     cipher_table[i].decrypt = dummy_decrypt_block;
140     i++;
141
142     for( ; i < TABLE_SIZE; i++ )
143         cipher_table[i].name = NULL;
144 }
145
146
147 /****************
148  * Try to load all modules and return true if new modules are available
149  */
150 static int
151 load_cipher_modules(void)
152 {
153     static int done = 0;
154     static int initialized = 0;
155     void *context = NULL;
156     struct cipher_table_s *ct;
157     int ct_idx;
158     int i;
159     const char *name;
160     int any = 0;
161
162     if( !initialized ) {
163         cipher_modules_constructor();
164         setup_cipher_table(); /* load static modules on the first call */
165         initialized = 1;
166         return 1;
167     }
168
169     if( done )
170         return 0;
171     done = 1;
172
173     for(ct_idx=0, ct = cipher_table; ct_idx < TABLE_SIZE; ct_idx++,ct++ ) {
174         if( !ct->name )
175             break;
176     }
177     if( ct_idx >= TABLE_SIZE-1 )
178         BUG(); /* table already full */
179     /* now load all extensions */
180     while( (name = enum_gnupgext_ciphers( &context, &ct->algo,
181                                 &ct->keylen, &ct->blocksize, &ct->contextsize,
182                                 &ct->setkey, &ct->encrypt, &ct->decrypt)) ) {
183         if( ct->blocksize != 8 && ct->blocksize != 16 ) {
184             log_info("skipping cipher %d: unsupported blocksize\n", ct->algo);
185             continue;
186         }
187         for(i=0; cipher_table[i].name; i++ )
188             if( cipher_table[i].algo == ct->algo )
189                 break;
190         if( cipher_table[i].name ) {
191             log_info("skipping cipher %d: already loaded\n", ct->algo );
192             continue;
193         }
194         /* put it into the table */
195         if( g10_opt_verbose > 1 )
196             log_info("loaded cipher %d (%s)\n", ct->algo, name);
197         ct->name = name;
198         ct_idx++;
199         ct++;
200         any = 1;
201         /* check whether there are more available table slots */
202         if( ct_idx >= TABLE_SIZE-1 ) {
203             log_info("cipher table full; ignoring other extensions\n");
204             break;
205         }
206     }
207     enum_gnupgext_ciphers( &context, NULL, NULL, NULL, NULL,
208                                            NULL, NULL, NULL );
209     return any;
210 }
211
212
213
214
215
216
217
218 /****************
219  * Map a string to the cipher algo
220  */
221 int
222 string_to_cipher_algo( const char *string )
223 {
224     int i;
225     const char *s;
226
227     do {
228         for(i=0; (s=cipher_table[i].name); i++ )
229             if( !stricmp( s, string ) )
230                 return cipher_table[i].algo;
231     } while( load_cipher_modules() );
232     return 0;
233 }
234
235 /****************
236  * Map a cipher algo to a string
237  */
238 const char *
239 cipher_algo_to_string( int algo )
240 {
241     int i;
242
243     do {
244         for(i=0; cipher_table[i].name; i++ )
245             if( cipher_table[i].algo == algo )
246                 return cipher_table[i].name;
247     } while( load_cipher_modules() );
248     return NULL;
249 }
250
251 /****************
252  * Return 0 if the cipher algo is available
253  */
254 int
255 check_cipher_algo( int algo )
256 {
257     int i;
258
259     do {
260        for(i=0; cipher_table[i].name; i++ )
261            if( cipher_table[i].algo == algo )
262                return 0; /* okay */
263     } while( load_cipher_modules() );
264     return G10ERR_CIPHER_ALGO;
265 }
266
267
268 unsigned
269 cipher_get_keylen( int algo )
270 {
271     int i;
272     unsigned len = 0;
273
274     do {
275         for(i=0; cipher_table[i].name; i++ ) {
276             if( cipher_table[i].algo == algo ) {
277                 len = cipher_table[i].keylen;
278                 if( !len )
279                     log_bug("cipher %d w/o key length\n", algo );
280                 return len;
281             }
282         }
283     } while( load_cipher_modules() );
284     log_bug("cipher %d not found\n", algo );
285     return 0;
286 }
287
288 unsigned
289 cipher_get_blocksize( 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].blocksize;
298                 if( !len )
299                     log_bug("cipher %d w/o blocksize\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
309 /****************
310  * Open a cipher handle for use with algorithm ALGO, in mode MODE
311  * and put it into secure memory if SECURE is true.
312  */
313 CIPHER_HANDLE
314 cipher_open( int algo, int mode, int secure )
315 {
316     CIPHER_HANDLE hd;
317     int i;
318
319     fast_random_poll();
320     do {
321         for(i=0; cipher_table[i].name; i++ )
322             if( cipher_table[i].algo == algo )
323                 break;
324     } while( !cipher_table[i].name && load_cipher_modules() );
325     if( !cipher_table[i].name ) {
326         log_fatal("cipher_open: algorithm %d not available\n", algo );
327         return NULL;
328     }
329
330     /* ? perform selftest here and mark this with a flag in cipher_table ? */
331
332     hd = secure ? m_alloc_secure_clear( sizeof *hd
333                                         + cipher_table[i].contextsize
334                                         - sizeof(PROPERLY_ALIGNED_TYPE) )
335                 : m_alloc_clear( sizeof *hd + cipher_table[i].contextsize
336                                            - sizeof(PROPERLY_ALIGNED_TYPE)  );
337     hd->algo = algo;
338     hd->blocksize = cipher_table[i].blocksize;
339     hd->setkey  = cipher_table[i].setkey;
340     hd->encrypt = cipher_table[i].encrypt;
341     hd->decrypt = cipher_table[i].decrypt;
342     if( algo == CIPHER_ALGO_DUMMY )
343         hd->mode = CIPHER_MODE_DUMMY;
344     else if( mode == CIPHER_MODE_AUTO_CFB ) {
345         if( algo >= 100 )
346             hd->mode = CIPHER_MODE_CFB;
347         else
348             hd->mode = CIPHER_MODE_PHILS_CFB;
349     }
350     else
351         hd->mode = mode;
352
353     return hd;
354 }
355
356
357 void
358 cipher_close( CIPHER_HANDLE c )
359 {
360     m_free(c);
361 }
362
363
364 int
365 cipher_setkey( CIPHER_HANDLE c, byte *key, unsigned keylen )
366 {
367     return (*c->setkey)( &c->context.c, key, keylen );
368 }
369
370
371
372 void
373 cipher_setiv( CIPHER_HANDLE c, const byte *iv, unsigned ivlen )
374 {
375     memset( c->iv, 0, c->blocksize );
376     if( iv ) {
377         if( ivlen != c->blocksize )
378             log_info("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
379                                              ivlen, c->blocksize );
380         if( ivlen > c->blocksize )
381             ivlen = c->blocksize;
382         memcpy( c->iv, iv, ivlen );
383     }
384     c->unused = 0;
385 }
386
387
388
389 static void
390 do_ecb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
391 {
392     unsigned n;
393
394     for(n=0; n < nblocks; n++ ) {
395         (*c->encrypt)( &c->context.c, outbuf, inbuf );
396         inbuf  += c->blocksize;
397         outbuf += c->blocksize;
398     }
399 }
400
401 static void
402 do_ecb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
403 {
404     unsigned n;
405
406     for(n=0; n < nblocks; n++ ) {
407         (*c->decrypt)( &c->context.c, outbuf, inbuf );
408         inbuf  += c->blocksize;
409         outbuf += c->blocksize;
410     }
411 }
412
413
414 static void
415 do_cfb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
416 {
417     byte *ivp;
418     size_t blocksize = c->blocksize;
419
420     if( nbytes <= c->unused ) {
421         /* short enough to be encoded by the remaining XOR mask */
422         /* XOR the input with the IV and store input into IV */
423         for(ivp=c->iv+c->blocksize - c->unused; nbytes; nbytes--, c->unused-- )
424             *outbuf++ = (*ivp++ ^= *inbuf++);
425         return;
426     }
427
428     if( c->unused ) {
429         /* XOR the input with the IV and store input into IV */
430         nbytes -= c->unused;
431         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- )
432             *outbuf++ = (*ivp++ ^= *inbuf++);
433     }
434
435     /* now we can process complete blocks */
436     while( nbytes >= blocksize ) {
437         int i;
438         /* encrypt the IV (and save the current one) */
439         memcpy( c->lastiv, c->iv, blocksize );
440         (*c->encrypt)( &c->context.c, c->iv, c->iv );
441         /* XOR the input with the IV and store input into IV */
442         for(ivp=c->iv,i=0; i < blocksize; i++ )
443             *outbuf++ = (*ivp++ ^= *inbuf++);
444         nbytes -= blocksize;
445     }
446     if( nbytes ) { /* process the remaining bytes */
447         /* encrypt the IV (and save the current one) */
448         memcpy( c->lastiv, c->iv, blocksize );
449         (*c->encrypt)( &c->context.c, c->iv, c->iv );
450         c->unused = blocksize;
451         /* and apply the xor */
452         c->unused -= nbytes;
453         for(ivp=c->iv; nbytes; nbytes-- )
454             *outbuf++ = (*ivp++ ^= *inbuf++);
455     }
456 }
457
458 static void
459 do_cfb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
460 {
461     byte *ivp;
462     ulong temp;
463     size_t blocksize = c->blocksize;
464
465     if( nbytes <= c->unused ) {
466         /* short enough to be encoded by the remaining XOR mask */
467         /* XOR the input with the IV and store input into IV */
468         for(ivp=c->iv+blocksize - c->unused; nbytes; nbytes--,c->unused--){
469             temp = *inbuf++;
470             *outbuf++ = *ivp ^ temp;
471             *ivp++ = temp;
472         }
473         return;
474     }
475
476     if( c->unused ) {
477         /* XOR the input with the IV and store input into IV */
478         nbytes -= c->unused;
479         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- ) {
480             temp = *inbuf++;
481             *outbuf++ = *ivp ^ temp;
482             *ivp++ = temp;
483         }
484     }
485
486     /* now we can process complete blocks */
487     while( nbytes >= blocksize ) {
488         int i;
489         /* encrypt the IV (and save the current one) */
490         memcpy( c->lastiv, c->iv, blocksize );
491         (*c->encrypt)( &c->context.c, c->iv, c->iv );
492         /* XOR the input with the IV and store input into IV */
493         for(ivp=c->iv,i=0; i < blocksize; i++ ) {
494             temp = *inbuf++;
495             *outbuf++ = *ivp ^ temp;
496             *ivp++ = temp;
497         }
498         nbytes -= blocksize;
499     }
500     if( nbytes ) { /* process the remaining bytes */
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         c->unused = blocksize;
505         /* and apply the xor */
506         c->unused -= nbytes;
507         for(ivp=c->iv; nbytes; nbytes-- ) {
508             temp = *inbuf++;
509             *outbuf++ = *ivp ^ temp;
510             *ivp++ = temp;
511         }
512     }
513 }
514
515
516 /****************
517  * Encrypt INBUF to OUTBUF with the mode selected at open.
518  * inbuf and outbuf may overlap or be the same.
519  * Depending on the mode some some contraints apply to NBYTES.
520  */
521 void
522 cipher_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
523 {
524     switch( c->mode ) {
525       case CIPHER_MODE_ECB:
526         assert(!(nbytes%8));
527         do_ecb_encrypt(c, outbuf, inbuf, nbytes/8 );
528         break;
529       case CIPHER_MODE_CFB:
530       case CIPHER_MODE_PHILS_CFB:
531         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
532         break;
533       case CIPHER_MODE_DUMMY:
534         if( inbuf != outbuf )
535             memmove( outbuf, inbuf, nbytes );
536         break;
537       default: log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
538     }
539 }
540
541
542 /****************
543  * Decrypt INBUF to OUTBUF with the mode selected at open.
544  * inbuf and outbuf may overlap or be the same.
545  * Depending on the mode some some contraints apply to NBYTES.
546  */
547 void
548 cipher_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
549 {
550     switch( c->mode ) {
551       case CIPHER_MODE_ECB:
552         assert(!(nbytes%8));
553         do_ecb_decrypt(c, outbuf, inbuf, nbytes/8 );
554         break;
555       case CIPHER_MODE_CFB:
556       case CIPHER_MODE_PHILS_CFB:
557         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
558         break;
559       case CIPHER_MODE_DUMMY:
560         if( inbuf != outbuf )
561             memmove( outbuf, inbuf, nbytes );
562         break;
563       default: log_fatal("cipher_decrypt: invalid mode %d\n", c->mode );
564     }
565 }
566
567
568
569 /****************
570  * Used for PGP's somewhat strange CFB mode. Only works if
571  * the handle is in PHILS_CFB mode
572  */
573 void
574 cipher_sync( CIPHER_HANDLE c )
575 {
576     if( c->mode == CIPHER_MODE_PHILS_CFB && c->unused ) {
577         memmove(c->iv + c->unused, c->iv, c->blocksize - c->unused );
578         memcpy(c->iv, c->lastiv + c->blocksize - c->unused, c->unused);
579         c->unused = 0;
580     }
581 }
582