6ac4682745c923158957cf142fb1ec9d3f6660a2
[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         log_info("loaded cipher %d (%s)\n", ct->algo, name);
182         ct->name = name;
183         ct_idx++;
184         ct++;
185         any = 1;
186         /* check whether there are more available table slots */
187         if( ct_idx >= TABLE_SIZE-1 ) {
188             log_info("cipher table full; ignoring other extensions\n");
189             break;
190         }
191     }
192     enum_gnupgext_ciphers( &context, NULL, NULL, NULL, NULL,
193                                            NULL, NULL, NULL );
194     return any;
195 }
196
197
198
199
200
201
202
203 /****************
204  * Map a string to the cipher algo
205  */
206 int
207 string_to_cipher_algo( const char *string )
208 {
209     int i;
210     const char *s;
211
212     setup_cipher_table();
213     do {
214         for(i=0; (s=cipher_table[i].name); i++ )
215             if( !stricmp( s, string ) )
216                 return cipher_table[i].algo;
217     } while( load_cipher_modules() );
218     return 0;
219 }
220
221 /****************
222  * Map a cipher algo to a string
223  */
224 const char *
225 cipher_algo_to_string( int algo )
226 {
227     int i;
228
229     setup_cipher_table();
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     setup_cipher_table();
247     do {
248        for(i=0; cipher_table[i].name; i++ )
249            if( cipher_table[i].algo == algo )
250                return 0; /* okay */
251     } while( load_cipher_modules() );
252     return G10ERR_CIPHER_ALGO;
253 }
254
255
256 unsigned
257 cipher_get_keylen( int algo )
258 {
259     int i;
260     unsigned len = 0;
261
262     setup_cipher_table();
263     do {
264         for(i=0; cipher_table[i].name; i++ ) {
265             if( cipher_table[i].algo == algo ) {
266                 len = cipher_table[i].keylen;
267                 if( !len )
268                     log_bug("cipher %d w/o key length\n", algo );
269                 return len;
270             }
271         }
272     } while( load_cipher_modules() );
273     log_bug("cipher %d not found\n", algo );
274     return 0;
275 }
276
277
278 /****************
279  * Open a cipher handle for use with algorithm ALGO, in mode MODE
280  * and put it into secure memory if SECURE is true.
281  */
282 CIPHER_HANDLE
283 cipher_open( int algo, int mode, int secure )
284 {
285     CIPHER_HANDLE hd;
286     int i;
287
288     setup_cipher_table();
289     fast_random_poll();
290     do {
291         for(i=0; cipher_table[i].name; i++ )
292             if( cipher_table[i].algo == algo )
293                 break;
294     } while( !cipher_table[i].name && load_cipher_modules() );
295     if( !cipher_table[i].name ) {
296         log_fatal("cipher_open: algorithm %d not available\n", algo );
297         return NULL;
298     }
299
300     /* ? perform selftest here and mark this with a flag in cipher_table ? */
301
302     hd = secure ? m_alloc_secure_clear( sizeof *hd
303                                         + cipher_table[i].contextsize )
304                 : m_alloc_clear( sizeof *hd + cipher_table[i].contextsize );
305     hd->algo = algo;
306     hd->setkey  = cipher_table[i].setkey;
307     hd->encrypt = cipher_table[i].encrypt;
308     hd->decrypt = cipher_table[i].decrypt;
309     if( algo == CIPHER_ALGO_DUMMY )
310         hd->mode = CIPHER_MODE_DUMMY;
311     else if( mode == CIPHER_MODE_AUTO_CFB ) {
312         if( algo != CIPHER_ALGO_BLOWFISH160 )
313             hd->mode = CIPHER_MODE_PHILS_CFB;
314         else
315             hd->mode = CIPHER_MODE_CFB;
316     }
317     else
318         hd->mode = mode;
319
320     return hd;
321 }
322
323
324 void
325 cipher_close( CIPHER_HANDLE c )
326 {
327     m_free(c);
328 }
329
330
331 void
332 cipher_setkey( CIPHER_HANDLE c, byte *key, unsigned keylen )
333 {
334     (*c->setkey)( &c->context, key, keylen );
335 }
336
337
338
339 void
340 cipher_setiv( CIPHER_HANDLE c, const byte *iv )
341 {
342     if( iv )
343         memcpy( c->iv, iv, STD_BLOCKSIZE );
344     else
345         memset( c->iv, 0, STD_BLOCKSIZE );
346     c->unused = 0;
347 }
348
349
350
351 static void
352 do_ecb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
353 {
354     unsigned n;
355
356     for(n=0; n < nblocks; n++ ) {
357         (*c->encrypt)( &c->context, outbuf, inbuf );
358         inbuf  += STD_BLOCKSIZE;;
359         outbuf += STD_BLOCKSIZE;
360     }
361 }
362
363 static void
364 do_ecb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
365 {
366     unsigned n;
367
368     for(n=0; n < nblocks; n++ ) {
369         (*c->decrypt)( &c->context, outbuf, inbuf );
370         inbuf  += STD_BLOCKSIZE;;
371         outbuf += STD_BLOCKSIZE;
372     }
373 }
374
375
376 static void
377 do_cfb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
378 {
379     byte *ivp;
380
381     if( nbytes <= c->unused ) {
382         /* short enough to be encoded by the remaining XOR mask */
383         /* XOR the input with the IV and store input into IV */
384         for(ivp=c->iv+STD_BLOCKSIZE - c->unused; nbytes; nbytes--, c->unused-- )
385             *outbuf++ = (*ivp++ ^= *inbuf++);
386         return;
387     }
388
389     if( c->unused ) {
390         /* XOR the input with the IV and store input into IV */
391         nbytes -= c->unused;
392         for(ivp=c->iv+STD_BLOCKSIZE - c->unused; c->unused; c->unused-- )
393             *outbuf++ = (*ivp++ ^= *inbuf++);
394     }
395
396     /* now we can process complete blocks */
397     while( nbytes >= STD_BLOCKSIZE ) {
398         int i;
399         /* encrypt the IV (and save the current one) */
400         memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
401         (*c->encrypt)( &c->context, c->iv, c->iv );
402         /* XOR the input with the IV and store input into IV */
403         for(ivp=c->iv,i=0; i < STD_BLOCKSIZE; i++ )
404             *outbuf++ = (*ivp++ ^= *inbuf++);
405         nbytes -= STD_BLOCKSIZE;
406     }
407     if( nbytes ) { /* process the remaining bytes */
408         /* encrypt the IV (and save the current one) */
409         memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
410         (*c->encrypt)( &c->context, c->iv, c->iv );
411         c->unused = STD_BLOCKSIZE;
412         /* and apply the xor */
413         c->unused -= nbytes;
414         for(ivp=c->iv; nbytes; nbytes-- )
415             *outbuf++ = (*ivp++ ^= *inbuf++);
416     }
417 }
418
419 static void
420 do_cfb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
421 {
422     byte *ivp;
423     ulong temp;
424
425     if( nbytes <= c->unused ) {
426         /* short enough to be encoded by the remaining XOR mask */
427         /* XOR the input with the IV and store input into IV */
428         for(ivp=c->iv+STD_BLOCKSIZE - c->unused; nbytes; nbytes--,c->unused--){
429             temp = *inbuf++;
430             *outbuf++ = *ivp ^ temp;
431             *ivp++ = temp;
432         }
433         return;
434     }
435
436     if( c->unused ) {
437         /* XOR the input with the IV and store input into IV */
438         nbytes -= c->unused;
439         for(ivp=c->iv+STD_BLOCKSIZE - c->unused; c->unused; c->unused-- ) {
440             temp = *inbuf++;
441             *outbuf++ = *ivp ^ temp;
442             *ivp++ = temp;
443         }
444     }
445
446     /* now we can process complete blocks */
447   #ifdef BIG_ENDIAN_HOST
448     /* This does only make sense for big endian hosts, due to ... ivp = temp*/
449     if( !((ulong)inbuf % SIZEOF_UNSIGNED_LONG) ) {
450         while( nbytes >= STD_BLOCKSIZE ) {
451             /* encrypt the IV (and save the current one) */
452             memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
453             (*c->encrypt)( &c->context, c->iv, c->iv );
454             ivp = c->iv;
455             /* XOR the input with the IV and store input into IV */
456           #if SIZEOF_UNSIGNED_LONG == STD_BLOCKSIZE
457             temp = *(ulong*)inbuf;
458             *(ulong*)outbuf = *(ulong*)c->iv ^ temp;
459             *(ulong*)ivp    = temp;
460           #elif (2*SIZEOF_UNSIGNED_LONG) == STD_BLOCKSIZE
461             temp = ((ulong*)inbuf)[0];
462             ((ulong*)outbuf)[0] = ((ulong*)c->iv)[0] ^ temp;
463             ((ulong*)ivp)[0] = temp;
464             temp = ((ulong*)inbuf)[1];
465             ((ulong*)outbuf)[1] = ((ulong*)c->iv)[1] ^ temp;
466             ((ulong*)ivp)[1] = temp;
467           #elif (4*SIZEOF_UNSIGNED_LONG) == STD_BLOCKSIZE
468             temp = ((ulong*)inbuf)[0];
469             ((ulong*)outbuf)[0] = ((ulong*)c->iv)[0] ^ temp;
470             ((ulong*)ivp)[0] = temp;
471             temp = ((ulong*)inbuf)[1];
472             ((ulong*)outbuf)[1] = ((ulong*)c->iv)[1] ^ temp;
473             ((ulong*)ivp)[1] = temp;
474             temp = ((ulong*)inbuf)[2];
475             ((ulong*)outbuf)[2] = ((ulong*)c->iv)[2] ^ temp;
476             ((ulong*)ivp)[2] = temp;
477             temp = ((ulong*)inbuf)[3];
478             ((ulong*)outbuf)[3] = ((ulong*)c->iv)[3] ^ temp;
479             ((ulong*)ivp)[3] = temp;
480           #else
481             #error Please disable the align test.
482           #endif
483             nbytes -= STD_BLOCKSIZE;
484             inbuf  += STD_BLOCKSIZE;
485             outbuf += STD_BLOCKSIZE;
486         }
487     }
488     else { /* non aligned version */
489   #endif /* BIG_ENDIAN_HOST */
490         while( nbytes >= STD_BLOCKSIZE ) {
491             int i;
492             /* encrypt the IV (and save the current one) */
493             memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
494             (*c->encrypt)( &c->context, c->iv, c->iv );
495             /* XOR the input with the IV and store input into IV */
496             for(ivp=c->iv,i=0; i < STD_BLOCKSIZE; i++ ) {
497                 temp = *inbuf++;
498                 *outbuf++ = *ivp ^ temp;
499                 *ivp++ = temp;
500             }
501             nbytes -= STD_BLOCKSIZE;
502         }
503    #ifdef BIG_ENDIAN_HOST
504     }
505    #endif
506     if( nbytes ) { /* process the remaining bytes */
507         /* encrypt the IV (and save the current one) */
508         memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
509         (*c->encrypt)( &c->context, c->iv, c->iv );
510         c->unused = STD_BLOCKSIZE;
511         /* and apply the xor */
512         c->unused -= nbytes;
513         for(ivp=c->iv; nbytes; nbytes-- ) {
514             temp = *inbuf++;
515             *outbuf++ = *ivp ^ temp;
516             *ivp++ = temp;
517         }
518     }
519 }
520
521
522 /****************
523  * Encrypt 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_encrypt( 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_encrypt(c, outbuf, inbuf, nbytes/8 );
534         break;
535       case CIPHER_MODE_CFB:
536       case CIPHER_MODE_PHILS_CFB:
537         do_cfb_encrypt(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_encrypt: invalid mode %d\n", c->mode );
544     }
545 }
546
547
548 /****************
549  * Decrypt INBUF to OUTBUF with the mode selected at open.
550  * inbuf and outbuf may overlap or be the same.
551  * Depending on the mode some some contraints apply to NBYTES.
552  */
553 void
554 cipher_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
555 {
556     switch( c->mode ) {
557       case CIPHER_MODE_ECB:
558         assert(!(nbytes%8));
559         do_ecb_decrypt(c, outbuf, inbuf, nbytes/8 );
560         break;
561       case CIPHER_MODE_CFB:
562       case CIPHER_MODE_PHILS_CFB:
563         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
564         break;
565       case CIPHER_MODE_DUMMY:
566         if( inbuf != outbuf )
567             memmove( outbuf, inbuf, nbytes );
568         break;
569       default: log_fatal("cipher_decrypt: invalid mode %d\n", c->mode );
570     }
571 }
572
573
574
575 /****************
576  * Used for PGP's somewhat strange CFB mode. Only works if
577  * the handle is in PHILS_CFB mode
578  */
579 void
580 cipher_sync( CIPHER_HANDLE c )
581 {
582     if( c->mode == CIPHER_MODE_PHILS_CFB && c->unused ) {
583         memmove(c->iv + c->unused, c->iv, STD_BLOCKSIZE - c->unused );
584         memcpy(c->iv, c->lastiv + STD_BLOCKSIZE - c->unused, c->unused);
585         c->unused = 0;
586     }
587 }
588