See ChangeLog: Thu Dec 10 20:15:36 CET 1998 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 #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 "des.h"
33 #include "blowfish.h"
34 #include "cast5.h"
35 #include "dynload.h"
36
37
38 #define MAX_BLOCKSIZE 16
39 #define TABLE_SIZE 10
40
41 struct cipher_table_s {
42     const char *name;
43     int algo;
44     size_t blocksize;
45     size_t keylen;
46     size_t contextsize; /* allocate this amount of context */
47     int  (*setkey)( void *c, byte *key, unsigned keylen );
48     void (*encrypt)( void *c, byte *outbuf, byte *inbuf );
49     void (*decrypt)( void *c, byte *outbuf, byte *inbuf );
50 };
51
52 static struct cipher_table_s cipher_table[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     byte context[1];
66 };
67
68
69 static int
70 dummy_setkey( void *c, byte *key, unsigned keylen ) { return 0; }
71 static void
72 dummy_encrypt_block( void *c, byte *outbuf, byte *inbuf ) { BUG(); }
73 static void
74 dummy_decrypt_block( void *c, byte *outbuf, byte *inbuf ) { BUG(); }
75
76
77
78 /****************
79  * Put the static entries into the table.
80  */
81 static void
82 setup_cipher_table()
83 {
84
85     int i;
86
87     i = 0;
88     cipher_table[i].algo = CIPHER_ALGO_BLOWFISH;
89     cipher_table[i].name = blowfish_get_info( cipher_table[i].algo,
90                                          &cipher_table[i].keylen,
91                                          &cipher_table[i].blocksize,
92                                          &cipher_table[i].contextsize,
93                                          &cipher_table[i].setkey,
94                                          &cipher_table[i].encrypt,
95                                          &cipher_table[i].decrypt     );
96     if( !cipher_table[i].name )
97         BUG();
98     i++;
99     cipher_table[i].algo = CIPHER_ALGO_CAST5;
100     cipher_table[i].name = cast5_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_3DES;
111     cipher_table[i].name = des_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_BLOWFISH160;
122     cipher_table[i].name = blowfish_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()
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         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  * Return 0 if the cipher algo is available
252  */
253 int
254 check_cipher_algo( int algo )
255 {
256     int i;
257
258     do {
259        for(i=0; cipher_table[i].name; i++ )
260            if( cipher_table[i].algo == algo )
261                return 0; /* okay */
262     } while( load_cipher_modules() );
263     return G10ERR_CIPHER_ALGO;
264 }
265
266
267 unsigned
268 cipher_get_keylen( int algo )
269 {
270     int i;
271     unsigned len = 0;
272
273     do {
274         for(i=0; cipher_table[i].name; i++ ) {
275             if( cipher_table[i].algo == algo ) {
276                 len = cipher_table[i].keylen;
277                 if( !len )
278                     log_bug("cipher %d w/o key length\n", algo );
279                 return len;
280             }
281         }
282     } while( load_cipher_modules() );
283     log_bug("cipher %d not found\n", algo );
284     return 0;
285 }
286
287 unsigned
288 cipher_get_blocksize( int algo )
289 {
290     int i;
291     unsigned len = 0;
292
293     do {
294         for(i=0; cipher_table[i].name; i++ ) {
295             if( cipher_table[i].algo == algo ) {
296                 len = cipher_table[i].blocksize;
297                 if( !len )
298                     log_bug("cipher %d w/o blocksize\n", algo );
299                 return len;
300             }
301         }
302     } while( load_cipher_modules() );
303     log_bug("cipher %d not found\n", algo );
304     return 0;
305 }
306
307
308 /****************
309  * Open a cipher handle for use with algorithm ALGO, in mode MODE
310  * and put it into secure memory if SECURE is true.
311  */
312 CIPHER_HANDLE
313 cipher_open( int algo, int mode, int secure )
314 {
315     CIPHER_HANDLE hd;
316     int i;
317
318     fast_random_poll();
319     do {
320         for(i=0; cipher_table[i].name; i++ )
321             if( cipher_table[i].algo == algo )
322                 break;
323     } while( !cipher_table[i].name && load_cipher_modules() );
324     if( !cipher_table[i].name ) {
325         log_fatal("cipher_open: algorithm %d not available\n", algo );
326         return NULL;
327     }
328
329     /* ? perform selftest here and mark this with a flag in cipher_table ? */
330
331     hd = secure ? m_alloc_secure_clear( sizeof *hd
332                                         + cipher_table[i].contextsize )
333                 : m_alloc_clear( sizeof *hd + cipher_table[i].contextsize );
334     hd->algo = algo;
335     hd->blocksize = cipher_table[i].blocksize;
336     hd->setkey  = cipher_table[i].setkey;
337     hd->encrypt = cipher_table[i].encrypt;
338     hd->decrypt = cipher_table[i].decrypt;
339     if( algo == CIPHER_ALGO_DUMMY )
340         hd->mode = CIPHER_MODE_DUMMY;
341     else if( mode == CIPHER_MODE_AUTO_CFB ) {
342         if( algo == CIPHER_ALGO_BLOWFISH160 || algo >= 100 )
343             hd->mode = CIPHER_MODE_CFB;
344         else
345             hd->mode = CIPHER_MODE_PHILS_CFB;
346     }
347     else
348         hd->mode = mode;
349
350     return hd;
351 }
352
353
354 void
355 cipher_close( CIPHER_HANDLE c )
356 {
357     m_free(c);
358 }
359
360
361 int
362 cipher_setkey( CIPHER_HANDLE c, byte *key, unsigned keylen )
363 {
364     return (*c->setkey)( &c->context, key, keylen );
365 }
366
367
368
369 void
370 cipher_setiv( CIPHER_HANDLE c, const byte *iv )
371 {
372     if( iv )
373         memcpy( c->iv, iv, c->blocksize );
374     else
375         memset( c->iv, 0, c->blocksize );
376     c->unused = 0;
377 }
378
379
380
381 static void
382 do_ecb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
383 {
384     unsigned n;
385
386     for(n=0; n < nblocks; n++ ) {
387         (*c->encrypt)( &c->context, outbuf, inbuf );
388         inbuf  += c->blocksize;
389         outbuf += c->blocksize;
390     }
391 }
392
393 static void
394 do_ecb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
395 {
396     unsigned n;
397
398     for(n=0; n < nblocks; n++ ) {
399         (*c->decrypt)( &c->context, outbuf, inbuf );
400         inbuf  += c->blocksize;
401         outbuf += c->blocksize;
402     }
403 }
404
405
406 static void
407 do_cfb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
408 {
409     byte *ivp;
410     size_t blocksize = c->blocksize;
411
412     if( nbytes <= c->unused ) {
413         /* short enough to be encoded by the remaining XOR mask */
414         /* XOR the input with the IV and store input into IV */
415         for(ivp=c->iv+c->blocksize - c->unused; nbytes; nbytes--, c->unused-- )
416             *outbuf++ = (*ivp++ ^= *inbuf++);
417         return;
418     }
419
420     if( c->unused ) {
421         /* XOR the input with the IV and store input into IV */
422         nbytes -= c->unused;
423         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- )
424             *outbuf++ = (*ivp++ ^= *inbuf++);
425     }
426
427     /* now we can process complete blocks */
428     while( nbytes >= blocksize ) {
429         int i;
430         /* encrypt the IV (and save the current one) */
431         memcpy( c->lastiv, c->iv, blocksize );
432         (*c->encrypt)( &c->context, c->iv, c->iv );
433         /* XOR the input with the IV and store input into IV */
434         for(ivp=c->iv,i=0; i < blocksize; i++ )
435             *outbuf++ = (*ivp++ ^= *inbuf++);
436         nbytes -= blocksize;
437     }
438     if( nbytes ) { /* process the remaining bytes */
439         /* encrypt the IV (and save the current one) */
440         memcpy( c->lastiv, c->iv, blocksize );
441         (*c->encrypt)( &c->context, c->iv, c->iv );
442         c->unused = blocksize;
443         /* and apply the xor */
444         c->unused -= nbytes;
445         for(ivp=c->iv; nbytes; nbytes-- )
446             *outbuf++ = (*ivp++ ^= *inbuf++);
447     }
448 }
449
450 static void
451 do_cfb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
452 {
453     byte *ivp;
454     ulong temp;
455     size_t blocksize = c->blocksize;
456
457     if( nbytes <= c->unused ) {
458         /* short enough to be encoded by the remaining XOR mask */
459         /* XOR the input with the IV and store input into IV */
460         for(ivp=c->iv+blocksize - c->unused; nbytes; nbytes--,c->unused--){
461             temp = *inbuf++;
462             *outbuf++ = *ivp ^ temp;
463             *ivp++ = temp;
464         }
465         return;
466     }
467
468     if( c->unused ) {
469         /* XOR the input with the IV and store input into IV */
470         nbytes -= c->unused;
471         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- ) {
472             temp = *inbuf++;
473             *outbuf++ = *ivp ^ temp;
474             *ivp++ = temp;
475         }
476     }
477
478     /* now we can process complete blocks */
479     while( nbytes >= blocksize ) {
480         int i;
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         /* XOR the input with the IV and store input into IV */
485         for(ivp=c->iv,i=0; i < blocksize; i++ ) {
486             temp = *inbuf++;
487             *outbuf++ = *ivp ^ temp;
488             *ivp++ = temp;
489         }
490         nbytes -= blocksize;
491     }
492     if( nbytes ) { /* process the remaining bytes */
493         /* encrypt the IV (and save the current one) */
494         memcpy( c->lastiv, c->iv, blocksize );
495         (*c->encrypt)( &c->context, c->iv, c->iv );
496         c->unused = blocksize;
497         /* and apply the xor */
498         c->unused -= nbytes;
499         for(ivp=c->iv; nbytes; nbytes-- ) {
500             temp = *inbuf++;
501             *outbuf++ = *ivp ^ temp;
502             *ivp++ = temp;
503         }
504     }
505 }
506
507
508 /****************
509  * Encrypt INBUF to OUTBUF with the mode selected at open.
510  * inbuf and outbuf may overlap or be the same.
511  * Depending on the mode some some contraints apply to NBYTES.
512  */
513 void
514 cipher_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
515 {
516     switch( c->mode ) {
517       case CIPHER_MODE_ECB:
518         assert(!(nbytes%8));
519         do_ecb_encrypt(c, outbuf, inbuf, nbytes/8 );
520         break;
521       case CIPHER_MODE_CFB:
522       case CIPHER_MODE_PHILS_CFB:
523         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
524         break;
525       case CIPHER_MODE_DUMMY:
526         if( inbuf != outbuf )
527             memmove( outbuf, inbuf, nbytes );
528         break;
529       default: log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
530     }
531 }
532
533
534 /****************
535  * Decrypt INBUF to OUTBUF with the mode selected at open.
536  * inbuf and outbuf may overlap or be the same.
537  * Depending on the mode some some contraints apply to NBYTES.
538  */
539 void
540 cipher_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
541 {
542     switch( c->mode ) {
543       case CIPHER_MODE_ECB:
544         assert(!(nbytes%8));
545         do_ecb_decrypt(c, outbuf, inbuf, nbytes/8 );
546         break;
547       case CIPHER_MODE_CFB:
548       case CIPHER_MODE_PHILS_CFB:
549         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
550         break;
551       case CIPHER_MODE_DUMMY:
552         if( inbuf != outbuf )
553             memmove( outbuf, inbuf, nbytes );
554         break;
555       default: log_fatal("cipher_decrypt: invalid mode %d\n", c->mode );
556     }
557 }
558
559
560
561 /****************
562  * Used for PGP's somewhat strange CFB mode. Only works if
563  * the handle is in PHILS_CFB mode
564  */
565 void
566 cipher_sync( CIPHER_HANDLE c )
567 {
568     if( c->mode == CIPHER_MODE_PHILS_CFB && c->unused ) {
569         memmove(c->iv + c->unused, c->iv, c->blocksize - c->unused );
570         memcpy(c->iv, c->lastiv + c->blocksize - c->unused, c->unused);
571         c->unused = 0;
572     }
573 }
574