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