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