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