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