Added some missing ChangeLog entries.
[libgcrypt.git] / cipher / cipher.c
1 /* cipher.c  -  cipher dispatcher
2  * Copyright (C) 1998,1999,2000,2001,2002,2003 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser general Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt 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 Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License 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
28 #include "g10lib.h"
29 #include "cipher.h"
30 #include "des.h"
31 #include "blowfish.h"
32 #include "cast5.h"
33 #include "arcfour.h"
34 #include "dynload.h"
35
36 #define MAX_BLOCKSIZE 16
37 #define TABLE_SIZE 14
38 #define CTX_MAGIC_NORMAL 0x24091964
39 #define CTX_MAGIC_SECURE 0x46919042
40
41 static struct {
42   const char *oidstring;
43   int algo;
44   int mode;
45 } oid_table[] = {
46   { "1.2.840.113549.3.7",      GCRY_CIPHER_3DES,   GCRY_CIPHER_MODE_CBC },
47
48   /* OIDs from NIST. See http://csrc.nist.gov.csor/ */
49   { "2.16.840.1.101.3.4.1.1",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_ECB },
50   { "2.16.840.1.101.3.4.1.2",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CBC },
51   { "2.16.840.1.101.3.4.1.3",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_OFB },
52   { "2.16.840.1.101.3.4.1.4",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CFB },
53   { "2.16.840.1.101.3.4.1.21", GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_ECB },
54   { "2.16.840.1.101.3.4.1.22", GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC },
55   { "2.16.840.1.101.3.4.1.23", GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_OFB },
56   { "2.16.840.1.101.3.4.1.24", GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CFB },
57   { "2.16.840.1.101.3.4.1.41", GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_ECB },
58   { "2.16.840.1.101.3.4.1.42", GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC },
59   { "2.16.840.1.101.3.4.1.43", GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_OFB },
60   { "2.16.840.1.101.3.4.1.44", GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB },
61
62   /* Teletrust specific OID for 3DES. */
63   { "1.3.36.3.1.3.2.1",        GCRY_CIPHER_3DES,   GCRY_CIPHER_MODE_CBC },
64
65   {NULL}
66 };
67
68
69 struct cipher_table_s {
70     const char *name;
71     int algo;
72     size_t blocksize;
73     size_t keylen;
74     size_t contextsize; /* allocate this amount of context */
75     int  (*setkey)( void *c, byte *key, unsigned keylen );
76     void (*encrypt)( void *c, byte *outbuf, byte *inbuf );
77     void (*decrypt)( void *c, byte *outbuf, byte *inbuf );
78     void (*stencrypt)( void *c, byte *outbuf, byte *inbuf, unsigned int n );
79     void (*stdecrypt)( void *c, byte *outbuf, byte *inbuf, unsigned int n );
80 };
81
82 static struct cipher_table_s cipher_table[TABLE_SIZE];
83 static int disabled_algos[TABLE_SIZE];
84
85 struct gcry_cipher_handle {
86     int magic;
87     int  algo;
88     int  mode;
89     unsigned int flags;
90     int algo_index;
91     size_t blocksize;
92     byte iv[MAX_BLOCKSIZE];     /* (this should be ulong aligned) */
93     byte lastiv[MAX_BLOCKSIZE];
94     int  unused;  /* in IV */
95     int  (*setkey)( void *c, byte *key, unsigned keylen );
96     void (*encrypt)( void *c, byte *outbuf, byte *inbuf );
97     void (*decrypt)( void *c, byte *outbuf, byte *inbuf );
98     void (*stencrypt)( void *c, byte *outbuf, byte *inbuf, unsigned int n );
99     void (*stdecrypt)( void *c, byte *outbuf, byte *inbuf, unsigned int n );
100     PROPERLY_ALIGNED_TYPE context;
101 };
102
103
104 static int
105 dummy_setkey( void *c, byte *key, unsigned keylen ) { return 0; }
106 static void
107 dummy_encrypt_block( void *c, byte *outbuf, byte *inbuf ) { BUG(); }
108 static void
109 dummy_decrypt_block( void *c, byte *outbuf, byte *inbuf ) { BUG(); }
110 static void
111 dummy_encrypt_stream( void *c, byte *outbuf, byte *inbuf, unsigned int n )
112 { BUG(); }
113 static void
114 dummy_decrypt_stream( void *c, byte *outbuf, byte *inbuf, unsigned int n )
115 { BUG(); }
116
117
118
119 /****************
120  * Put the static entries into the table.
121  */
122 static void
123 setup_cipher_table(void)
124 {
125     int i;
126
127     for (i=0; i < TABLE_SIZE; i++ ) {
128         cipher_table[i].encrypt = dummy_encrypt_block;
129         cipher_table[i].decrypt = dummy_decrypt_block;
130         cipher_table[i].stencrypt = dummy_encrypt_stream;
131         cipher_table[i].stdecrypt = dummy_decrypt_stream;
132     }
133     
134     i = 0;
135     cipher_table[i].algo = GCRY_CIPHER_RIJNDAEL;
136     cipher_table[i].name = _gcry_rijndael_get_info( cipher_table[i].algo,
137                                          &cipher_table[i].keylen,
138                                          &cipher_table[i].blocksize,
139                                          &cipher_table[i].contextsize,
140                                          &cipher_table[i].setkey,
141                                          &cipher_table[i].encrypt,
142                                          &cipher_table[i].decrypt     );
143     if( !cipher_table[i].name )
144         BUG();
145     i++;
146     cipher_table[i].algo = GCRY_CIPHER_RIJNDAEL192;
147     cipher_table[i].name = _gcry_rijndael_get_info( cipher_table[i].algo,
148                                          &cipher_table[i].keylen,
149                                          &cipher_table[i].blocksize,
150                                          &cipher_table[i].contextsize,
151                                          &cipher_table[i].setkey,
152                                          &cipher_table[i].encrypt,
153                                          &cipher_table[i].decrypt     );
154     if( !cipher_table[i].name )
155         BUG();
156     i++;
157     cipher_table[i].algo = GCRY_CIPHER_RIJNDAEL256;
158     cipher_table[i].name = _gcry_rijndael_get_info( cipher_table[i].algo,
159                                          &cipher_table[i].keylen,
160                                          &cipher_table[i].blocksize,
161                                          &cipher_table[i].contextsize,
162                                          &cipher_table[i].setkey,
163                                          &cipher_table[i].encrypt,
164                                          &cipher_table[i].decrypt     );
165     if( !cipher_table[i].name )
166         BUG();
167     i++;
168     cipher_table[i].algo = GCRY_CIPHER_TWOFISH;
169     cipher_table[i].name = _gcry_twofish_get_info( cipher_table[i].algo,
170                                          &cipher_table[i].keylen,
171                                          &cipher_table[i].blocksize,
172                                          &cipher_table[i].contextsize,
173                                          &cipher_table[i].setkey,
174                                          &cipher_table[i].encrypt,
175                                          &cipher_table[i].decrypt     );
176     if( !cipher_table[i].name )
177         BUG();
178     i++;
179     cipher_table[i].algo = GCRY_CIPHER_BLOWFISH;
180     cipher_table[i].name = _gcry_blowfish_get_info( cipher_table[i].algo,
181                                          &cipher_table[i].keylen,
182                                          &cipher_table[i].blocksize,
183                                          &cipher_table[i].contextsize,
184                                          &cipher_table[i].setkey,
185                                          &cipher_table[i].encrypt,
186                                          &cipher_table[i].decrypt     );
187     if( !cipher_table[i].name )
188         BUG();
189     i++;
190     cipher_table[i].algo = GCRY_CIPHER_CAST5;
191     cipher_table[i].name = _gcry_cast5_get_info( cipher_table[i].algo,
192                                          &cipher_table[i].keylen,
193                                          &cipher_table[i].blocksize,
194                                          &cipher_table[i].contextsize,
195                                          &cipher_table[i].setkey,
196                                          &cipher_table[i].encrypt,
197                                          &cipher_table[i].decrypt     );
198     if( !cipher_table[i].name )
199         BUG();
200     i++;
201     cipher_table[i].algo = GCRY_CIPHER_3DES;
202     cipher_table[i].name = _gcry_des_get_info( cipher_table[i].algo,
203                                          &cipher_table[i].keylen,
204                                          &cipher_table[i].blocksize,
205                                          &cipher_table[i].contextsize,
206                                          &cipher_table[i].setkey,
207                                          &cipher_table[i].encrypt,
208                                          &cipher_table[i].decrypt     );
209     if( !cipher_table[i].name )
210         BUG();
211     i++;
212     cipher_table[i].algo = GCRY_CIPHER_ARCFOUR;
213     cipher_table[i].name = _gcry_arcfour_get_info( cipher_table[i].algo,
214                                          &cipher_table[i].keylen,
215                                          &cipher_table[i].blocksize,
216                                          &cipher_table[i].contextsize,
217                                          &cipher_table[i].setkey,
218                                          &cipher_table[i].stencrypt,
219                                          &cipher_table[i].stdecrypt   );
220     if( !cipher_table[i].name )
221         BUG();
222     i++;
223     cipher_table[i].algo = GCRY_CIPHER_DES;
224     cipher_table[i].name = _gcry_des_get_info( cipher_table[i].algo,
225                                          &cipher_table[i].keylen,
226                                          &cipher_table[i].blocksize,
227                                          &cipher_table[i].contextsize,
228                                          &cipher_table[i].setkey,
229                                          &cipher_table[i].encrypt,
230                                          &cipher_table[i].decrypt     );
231     if( !cipher_table[i].name )
232         BUG();
233     i++;
234
235     cipher_table[i].algo = CIPHER_ALGO_DUMMY;
236     cipher_table[i].name = "DUMMY";
237     cipher_table[i].blocksize = 8;
238     cipher_table[i].keylen = 128;
239     cipher_table[i].contextsize = 0;
240     cipher_table[i].setkey = dummy_setkey;
241     i++;
242
243     for( ; i < TABLE_SIZE; i++ )
244         cipher_table[i].name = NULL;
245 }
246
247
248 /****************
249  * Try to load all modules and return true if new modules are available
250  */
251 static int
252 load_cipher_modules(void)
253 {
254     static int done = 0;
255     static int initialized = 0;
256     void *context = NULL;
257     struct cipher_table_s *ct;
258     int ct_idx;
259     int i;
260     const char *name;
261     int any = 0;
262
263     if( !initialized ) {
264         _gcry_cipher_modules_constructor();
265         setup_cipher_table(); /* load static modules on the first call */
266         initialized = 1;
267         return 1;
268     }
269
270     if( done )
271         return 0;
272     done = 1;
273
274     for(ct_idx=0, ct = cipher_table; ct_idx < TABLE_SIZE; ct_idx++,ct++ ) {
275         if( !ct->name )
276             break;
277     }
278     if( ct_idx >= TABLE_SIZE-1 )
279         BUG(); /* table already full */
280     /* now load all extensions */
281     while( (name = _gcry_enum_gnupgext_ciphers( &context, &ct->algo,
282                                 &ct->keylen, &ct->blocksize, &ct->contextsize,
283                                 &ct->setkey, &ct->encrypt, &ct->decrypt)) ) {
284         if( ct->blocksize != 8 && ct->blocksize != 16 ) {
285             log_info("skipping cipher %d: unsupported blocksize\n", ct->algo);
286             continue;
287         }
288         for(i=0; cipher_table[i].name; i++ )
289             if( cipher_table[i].algo == ct->algo )
290                 break;
291         if( cipher_table[i].name ) {
292             log_info("skipping cipher %d: already loaded\n", ct->algo );
293             continue;
294         }
295         /* put it into the table */
296         if( _gcry_log_verbosity( 2 ) )
297             log_info("loaded cipher %d (%s)\n", ct->algo, name);
298         ct->name = name;
299         ct_idx++;
300         ct++;
301         any = 1;
302         /* check whether there are more available table slots */
303         if( ct_idx >= TABLE_SIZE-1 ) {
304             log_info("cipher table full; ignoring other extensions\n");
305             break;
306         }
307     }
308     _gcry_enum_gnupgext_ciphers( &context, NULL, NULL, NULL, NULL,
309                                            NULL, NULL, NULL );
310     return any;
311 }
312
313 /* locate the OID in the oid table and return the index or -1 when not
314    found */
315 static int 
316 search_oid (const char *string)
317 {
318   int i;
319   const char *s;
320
321   if (string && (digitp (string)
322                  || !strncmp (string, "oid.", 4) 
323                  || !strncmp (string, "OID.", 4) ))
324     {
325       s =  digitp(string)? string : (string+4);
326
327       for (i=0; oid_table[i].oidstring; i++)
328         {
329           if (!strcmp (s, oid_table[i].oidstring))
330             return i;
331         }
332     }
333   return -1;
334 }
335
336 /****************
337  * Map a string to the cipher algo.
338  * Returns: The algo ID of the cipher for the gioven name or
339  *          0 if the name is not known.
340  */
341 int
342 gcry_cipher_map_name( const char *string )
343 {
344   int i;
345   const char *s;
346   
347   if (!string)
348     return 0;
349
350   /* kludge to alias RIJNDAEL to AES */
351   if ( *string == 'R' || *string == 'r')
352     {
353       if (!strcasecmp (string, "RIJNDAEL"))
354         string = "AES";
355       else if (!strcasecmp (string, "RIJNDAEL192"))
356         string = "AES192";
357       else if (!strcasecmp (string, "RIJNDAEL256"))
358         string = "AES256";
359     }
360
361   /* If the string starts with a digit (optionally prefixed with
362      either "OID." or "oid."), we first look into our table of ASN.1
363      object identifiers to figure out the algorithm */
364   i = search_oid (string);
365   if (i != -1)
366     return oid_table[i].algo;
367   
368   do 
369     {
370       for (i=0; (s=cipher_table[i].name); i++ )
371         if ( !stricmp( s, string ) )
372           return cipher_table[i].algo;
373     } 
374   while ( load_cipher_modules() );
375   return 0;
376 }
377
378 int
379 gcry_cipher_mode_from_oid (const char *string)
380 {
381   int i;
382
383   i = search_oid (string);
384   return i == -1? 0 : oid_table[i].mode;
385 }
386
387
388 /****************
389  * Map a cipher algo to a string
390  */
391 static const char *
392 cipher_algo_to_string( int algo )
393 {
394     int i;
395
396     do {
397         for(i=0; cipher_table[i].name; i++ )
398             if( cipher_table[i].algo == algo )
399                 return cipher_table[i].name;
400     } while( load_cipher_modules() );
401     return NULL;
402 }
403
404 /****************
405  * This function simply returns the name of the algorithm or some constant
406  * string when there is no algo.  It will never return NULL.
407  */
408 const char *
409 gcry_cipher_algo_name( int algo )
410 {
411     const char *s = cipher_algo_to_string( algo );
412     return s? s: "";
413 }
414
415
416
417 static void
418 disable_cipher_algo( int algo )
419 {
420     int i;
421
422     for(i=0; i < DIM(disabled_algos); i++ ) {
423         if( !disabled_algos[i] || disabled_algos[i] == algo ) {
424             disabled_algos[i] = algo;
425             return;
426         }
427     }
428     /* fixme: we should use a linked list */
429     log_fatal("can't disable cipher algo %d: table full\n", algo );
430 }
431
432 /****************
433  * Return 0 if the cipher algo is available
434  */
435 static int
436 check_cipher_algo( int algo )
437 {
438     int i;
439
440     do {
441        for(i=0; cipher_table[i].name; i++ )
442            if( cipher_table[i].algo == algo ) {
443                 for(i=0; i < DIM(disabled_algos); i++ ) {
444                    if( disabled_algos[i] == algo )
445                        return GCRYERR_INV_CIPHER_ALGO;
446                 }
447                 return 0; /* okay */
448            }
449     } while( load_cipher_modules() );
450     return GCRYERR_INV_CIPHER_ALGO;
451 }
452
453
454 static unsigned
455 cipher_get_keylen( int algo )
456 {
457     int i;
458     unsigned len = 0;
459
460     do {
461         for(i=0; cipher_table[i].name; i++ ) {
462             if( cipher_table[i].algo == algo ) {
463                 len = cipher_table[i].keylen;
464                 if( !len )
465                     log_bug("cipher %d w/o key length\n", algo );
466                 return len;
467             }
468         }
469     } while( load_cipher_modules() );
470     log_bug("cipher %d not found\n", algo );
471     return 0;
472 }
473
474 static unsigned
475 cipher_get_blocksize( int algo )
476 {
477     int i;
478     unsigned len = 0;
479
480     do {
481         for(i=0; cipher_table[i].name; i++ ) {
482             if( cipher_table[i].algo == algo ) {
483                 len = cipher_table[i].blocksize;
484                 if( !len )
485                     log_bug("cipher %d w/o blocksize\n", algo );
486                 return len;
487             }
488         }
489     } while( load_cipher_modules() );
490     log_bug("cipher %d not found\n", algo );
491     return 0;
492 }
493
494
495 /****************
496  * Open a cipher handle for use with algorithm ALGO, in mode MODE
497  * and return the handle.  Return NULL and set the internal error variable
498  * if something goes wrong.
499  */
500
501 GCRY_CIPHER_HD
502 gcry_cipher_open( int algo, int mode, unsigned int flags )
503 {
504     GCRY_CIPHER_HD h;
505     int idx;
506     int secure = (flags & GCRY_CIPHER_SECURE);
507
508     fast_random_poll();
509
510     /* check whether the algo is available */
511     if( check_cipher_algo( algo ) ) {
512         set_lasterr( GCRYERR_INV_CIPHER_ALGO );
513         return NULL;
514     }
515
516     /* check flags */
517     if( (flags & ~(GCRY_CIPHER_SECURE|
518                    GCRY_CIPHER_ENABLE_SYNC|
519                    GCRY_CIPHER_CBC_CTS|
520                    GCRY_CIPHER_CBC_MAC)) ||
521         (flags & GCRY_CIPHER_CBC_CTS & GCRY_CIPHER_CBC_MAC)) {
522         set_lasterr( GCRYERR_INV_CIPHER_ALGO );
523         return NULL;
524     }
525
526     /* get the table index of the algo */
527     for(idx=0; cipher_table[idx].name; idx++ )
528         if( cipher_table[idx].algo == algo )
529             break;
530     if( !cipher_table[idx].name )
531         BUG(); /* check_cipher_algo() should have loaded the algo */
532
533     if( algo == CIPHER_ALGO_DUMMY )
534         mode = GCRY_CIPHER_MODE_NONE;  /* force this mode for dummy algo */
535
536     /* check that a valid mode has been requested */
537     switch( mode ) {
538       case GCRY_CIPHER_MODE_ECB:
539       case GCRY_CIPHER_MODE_CBC:
540       case GCRY_CIPHER_MODE_CFB:
541         if ( cipher_table[idx].encrypt == dummy_encrypt_block
542              || cipher_table[idx].decrypt == dummy_decrypt_block ) {
543             set_lasterr( GCRYERR_INV_CIPHER_MODE );
544             return NULL;
545         }
546         break;
547       case GCRY_CIPHER_MODE_STREAM:
548         if ( cipher_table[idx].stencrypt == dummy_encrypt_stream
549              || cipher_table[idx].stdecrypt == dummy_decrypt_stream ) {
550             set_lasterr( GCRYERR_INV_CIPHER_MODE );
551             return NULL;
552         }
553         break;
554       case GCRY_CIPHER_MODE_NONE:
555         /* FIXME: issue a warning when this mode is used */
556         break;
557       default:
558         set_lasterr( GCRYERR_INV_CIPHER_MODE );
559         return NULL;
560     }
561
562     /* ? perform selftest here and mark this with a flag in cipher_table ? */
563
564     h = secure ? gcry_calloc_secure( 1,
565                                      sizeof *h
566                                      + 2 * cipher_table[idx].contextsize
567                                      - sizeof (PROPERLY_ALIGNED_TYPE) )
568                : gcry_calloc( 1,
569                               sizeof *h
570                               + 2 * cipher_table[idx].contextsize
571                               - sizeof (PROPERLY_ALIGNED_TYPE) );
572     if( !h ) {
573         set_lasterr( GCRYERR_NO_MEM );
574         return NULL;
575     }
576     h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
577     h->algo = algo;
578     h->mode = mode;
579     h->flags = flags;
580     h->algo_index = idx;
581     h->blocksize = cipher_table[idx].blocksize;
582     h->setkey  = cipher_table[idx].setkey;
583     h->encrypt = cipher_table[idx].encrypt;
584     h->decrypt = cipher_table[idx].decrypt;
585     h->stencrypt = cipher_table[idx].stencrypt;
586     h->stdecrypt = cipher_table[idx].stdecrypt;
587
588     return h;
589 }
590
591
592 void
593 gcry_cipher_close( GCRY_CIPHER_HD h )
594 {
595     if( !h )
596         return;
597     if( h->magic != CTX_MAGIC_SECURE && h->magic != CTX_MAGIC_NORMAL )
598         _gcry_fatal_error(GCRYERR_INTERNAL,
599                         "gcry_cipher_close: already closed/invalid handle");
600     h->magic = 0;
601     gcry_free(h);
602 }
603
604
605 static int
606 cipher_setkey( GCRY_CIPHER_HD c, byte *key, unsigned keylen )
607 {
608     int ret;
609
610     ret = (*c->setkey)( &c->context.c, key, keylen );
611     if (! ret)
612       memcpy ((void *) ((char *) &c->context.c
613                         + cipher_table[c->algo_index].contextsize),
614               (void *) &c->context.c,
615               cipher_table[c->algo_index].contextsize);
616     return ret;
617 }
618
619
620 static void
621 cipher_setiv( GCRY_CIPHER_HD c, const byte *iv, unsigned ivlen )
622 {
623     memset( c->iv, 0, c->blocksize );
624     if( iv ) {
625         if( ivlen != c->blocksize )
626             log_info("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
627                                              ivlen, (unsigned)c->blocksize );
628         if( ivlen > c->blocksize )
629             ivlen = c->blocksize;
630         memcpy( c->iv, iv, ivlen );
631     }
632     c->unused = 0;
633 }
634
635
636 static void
637 cipher_reset (GCRY_CIPHER_HD c)
638 {
639   memcpy ((void *) &c->context.c,
640           (void *) ((char *) &c->context.c
641                     + cipher_table[c->algo_index].contextsize),
642           cipher_table[c->algo_index].contextsize);
643   memset (c->iv, 0, c->blocksize);
644   memset (c->lastiv, 0, c->blocksize);
645 }
646
647
648 static void
649 do_ecb_encrypt( GCRY_CIPHER_HD c, byte *outbuf, const byte *inbuf, unsigned nblocks )
650 {
651     unsigned n;
652
653     for(n=0; n < nblocks; n++ ) {
654         (*c->encrypt)( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
655         inbuf  += c->blocksize;
656         outbuf += c->blocksize;
657     }
658 }
659
660 static void
661 do_ecb_decrypt( GCRY_CIPHER_HD c, byte *outbuf, const byte *inbuf, unsigned nblocks )
662 {
663     unsigned n;
664
665     for(n=0; n < nblocks; n++ ) {
666         (*c->decrypt)( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
667         inbuf  += c->blocksize;
668         outbuf += c->blocksize;
669     }
670 }
671
672 static void
673 do_cbc_encrypt( GCRY_CIPHER_HD c, byte *outbuf, const byte *inbuf, unsigned nbytes )
674 {
675     unsigned int n;
676     byte *ivp;
677     int i;
678     size_t blocksize = c->blocksize;
679     unsigned nblocks = nbytes / blocksize;
680
681     if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) {
682       if ((nbytes % blocksize) == 0)
683         nblocks--;
684     }
685
686     for(n=0; n < nblocks; n++ ) {
687         /* fixme: the xor should works on words and not on
688          * bytes.  Maybe it is a good idea to enhance the cipher backend
689          * API to allow for CBC handling in the backend */
690         for(ivp=c->iv,i=0; i < blocksize; i++ )
691             outbuf[i] = inbuf[i] ^ *ivp++;
692         (*c->encrypt)( &c->context.c, outbuf, outbuf );
693         memcpy(c->iv, outbuf, blocksize );
694         inbuf  += c->blocksize;
695         if (!(c->flags & GCRY_CIPHER_CBC_MAC))
696           outbuf += c->blocksize;
697     }
698
699     if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize)
700       {
701         int restbytes;
702
703         if ((nbytes % blocksize) == 0)
704           restbytes = blocksize;
705         else
706           restbytes = nbytes % blocksize;
707
708         memcpy(outbuf, outbuf - c->blocksize, restbytes);
709         outbuf -= c->blocksize;
710
711         for(ivp=c->iv,i=0; i < restbytes; i++ )
712             outbuf[i] = inbuf[i] ^ *ivp++;
713         for(; i < blocksize; i++ )
714             outbuf[i] = 0 ^ *ivp++;
715
716         (*c->encrypt)( &c->context.c, outbuf, outbuf );
717         memcpy(c->iv, outbuf, blocksize );
718       }
719 }
720
721 static void
722 do_cbc_decrypt( GCRY_CIPHER_HD c, byte *outbuf, const byte *inbuf, unsigned nbytes )
723 {
724     unsigned int n;
725     byte *ivp;
726     int i;
727     size_t blocksize = c->blocksize;
728     unsigned nblocks = nbytes / blocksize;
729
730     if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) {
731       nblocks--;
732       if ((nbytes % blocksize) == 0)
733         nblocks--;
734       memcpy(c->lastiv, c->iv, blocksize );
735     }
736
737     for(n=0; n < nblocks; n++ ) {
738         /* because outbuf and inbuf might be the same, we have
739          * to save the original ciphertext block.  We use lastiv
740          * for this here because it is not used otherwise */
741         memcpy(c->lastiv, inbuf, blocksize );
742         (*c->decrypt)( &c->context.c, outbuf, (char*)/*argggg*/inbuf );
743         for(ivp=c->iv,i=0; i < blocksize; i++ )
744             outbuf[i] ^= *ivp++;
745         memcpy(c->iv, c->lastiv, blocksize );
746         inbuf  += c->blocksize;
747         outbuf += c->blocksize;
748     }
749
750     if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) {
751         int restbytes;
752
753         if ((nbytes % blocksize) == 0)
754           restbytes = blocksize;
755         else
756           restbytes = nbytes % blocksize;
757
758         memcpy(c->lastiv, c->iv, blocksize ); /* save Cn-2 */
759         memcpy(c->iv, inbuf + blocksize, restbytes ); /* save Cn */
760
761         (*c->decrypt)( &c->context.c, outbuf, (char*)/*argggg*/inbuf );
762         for(ivp=c->iv,i=0; i < restbytes; i++ )
763             outbuf[i] ^= *ivp++;
764
765         memcpy(outbuf + blocksize, outbuf, restbytes);
766         for(i=restbytes; i < blocksize; i++)
767           c->iv[i] = outbuf[i];
768         (*c->decrypt)( &c->context.c, outbuf, c->iv );
769         for(ivp=c->lastiv,i=0; i < blocksize; i++ )
770             outbuf[i] ^= *ivp++;
771         /* c->lastiv is now really lastlastiv, does this matter? */
772     }
773 }
774
775
776 static void
777 do_cfb_encrypt( GCRY_CIPHER_HD c,
778                 byte *outbuf, const byte *inbuf, unsigned nbytes )
779 {
780     byte *ivp;
781     size_t blocksize = c->blocksize;
782
783     if( nbytes <= c->unused ) {
784         /* short enough to be encoded by the remaining XOR mask */
785         /* XOR the input with the IV and store input into IV */
786         for(ivp=c->iv+c->blocksize - c->unused; nbytes; nbytes--, c->unused-- )
787             *outbuf++ = (*ivp++ ^= *inbuf++);
788         return;
789     }
790
791     if( c->unused ) {
792         /* XOR the input with the IV and store input into IV */
793         nbytes -= c->unused;
794         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- )
795             *outbuf++ = (*ivp++ ^= *inbuf++);
796     }
797
798     /* now we can process complete blocks */
799     while( nbytes >= blocksize ) {
800         int i;
801         /* encrypt the IV (and save the current one) */
802         memcpy( c->lastiv, c->iv, blocksize );
803         (*c->encrypt)( &c->context.c, c->iv, c->iv );
804         /* XOR the input with the IV and store input into IV */
805         for(ivp=c->iv,i=0; i < blocksize; i++ )
806             *outbuf++ = (*ivp++ ^= *inbuf++);
807         nbytes -= blocksize;
808     }
809     if( nbytes ) { /* process the remaining bytes */
810         /* encrypt the IV (and save the current one) */
811         memcpy( c->lastiv, c->iv, blocksize );
812         (*c->encrypt)( &c->context.c, c->iv, c->iv );
813         c->unused = blocksize;
814         /* and apply the xor */
815         c->unused -= nbytes;
816         for(ivp=c->iv; nbytes; nbytes-- )
817             *outbuf++ = (*ivp++ ^= *inbuf++);
818     }
819 }
820
821 static void
822 do_cfb_decrypt( GCRY_CIPHER_HD c,
823                 byte *outbuf, const byte *inbuf, unsigned nbytes )
824 {
825     byte *ivp;
826     ulong temp;
827     size_t blocksize = c->blocksize;
828
829     if( nbytes <= c->unused ) {
830         /* short enough to be encoded by the remaining XOR mask */
831         /* XOR the input with the IV and store input into IV */
832         for(ivp=c->iv+blocksize - c->unused; nbytes; nbytes--,c->unused--){
833             temp = *inbuf++;
834             *outbuf++ = *ivp ^ temp;
835             *ivp++ = temp;
836         }
837         return;
838     }
839
840     if( c->unused ) {
841         /* XOR the input with the IV and store input into IV */
842         nbytes -= c->unused;
843         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- ) {
844             temp = *inbuf++;
845             *outbuf++ = *ivp ^ temp;
846             *ivp++ = temp;
847         }
848     }
849
850     /* now we can process complete blocks */
851     while( nbytes >= blocksize ) {
852         int i;
853         /* encrypt the IV (and save the current one) */
854         memcpy( c->lastiv, c->iv, blocksize );
855         (*c->encrypt)( &c->context.c, c->iv, c->iv );
856         /* XOR the input with the IV and store input into IV */
857         for(ivp=c->iv,i=0; i < blocksize; i++ ) {
858             temp = *inbuf++;
859             *outbuf++ = *ivp ^ temp;
860             *ivp++ = temp;
861         }
862         nbytes -= blocksize;
863     }
864     if( nbytes ) { /* process the remaining bytes */
865         /* encrypt the IV (and save the current one) */
866         memcpy( c->lastiv, c->iv, blocksize );
867         (*c->encrypt)( &c->context.c, c->iv, c->iv );
868         c->unused = blocksize;
869         /* and apply the xor */
870         c->unused -= nbytes;
871         for(ivp=c->iv; nbytes; nbytes-- ) {
872             temp = *inbuf++;
873             *outbuf++ = *ivp ^ temp;
874             *ivp++ = temp;
875         }
876     }
877 }
878
879
880
881
882 /****************
883  * Encrypt INBUF to OUTBUF with the mode selected at open.
884  * inbuf and outbuf may overlap or be the same.
885  * Depending on the mode some contraints apply to NBYTES.
886  */
887 static int
888 cipher_encrypt( GCRY_CIPHER_HD c, byte *outbuf,
889                                   const byte *inbuf, unsigned int nbytes )
890 {
891     int rc = 0;
892
893     switch( c->mode ) {
894       case GCRY_CIPHER_MODE_ECB:
895         if (!(nbytes%c->blocksize))
896             do_ecb_encrypt(c, outbuf, inbuf, nbytes/c->blocksize );
897         else 
898             rc = GCRYERR_INV_ARG;
899         break;
900       case GCRY_CIPHER_MODE_CBC:
901         if (!(nbytes%c->blocksize) || (nbytes > c->blocksize && 
902                                        (c->flags & GCRY_CIPHER_CBC_CTS)))
903             do_cbc_encrypt(c, outbuf, inbuf, nbytes );
904         else 
905             rc = GCRYERR_INV_ARG;
906         break;
907       case GCRY_CIPHER_MODE_CFB:
908         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
909         break;
910       case GCRY_CIPHER_MODE_STREAM:
911         (*c->stencrypt)( &c->context.c,
912                          outbuf, (byte*)/*arggg*/inbuf, nbytes );
913         break;
914       case GCRY_CIPHER_MODE_NONE:
915         if( inbuf != outbuf )
916             memmove( outbuf, inbuf, nbytes );
917         break;
918       default:
919         log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
920         rc = GCRYERR_INV_CIPHER_MODE;
921         break;
922     }
923     return rc;
924 }
925
926
927 /****************
928  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
929  * been requested,
930  */
931 int
932 gcry_cipher_encrypt (GcryCipherHd h, byte *out, size_t outsize,
933                      const byte  *in, size_t inlen )
934 {
935   int rc;
936
937   if (!in)
938     {
939       /* caller requested in-place encryption */
940       /* actullay cipher_encrypt() does not need to know about it, but
941        * we may change this to get better performace */
942       rc = cipher_encrypt ( h, out, out, outsize );
943     }
944   else
945     {
946       if ( outsize < ((h->flags & GCRY_CIPHER_CBC_MAC) ? h->blocksize : inlen))
947         rc = GCRYERR_TOO_SHORT;
948       else if ((h->mode == GCRY_CIPHER_MODE_ECB
949                 || (h->mode == GCRY_CIPHER_MODE_CBC
950                     && !((h->flags & GCRY_CIPHER_CBC_CTS)
951                          && (inlen > h->blocksize))
952                     )
953                 )  
954                && (inlen % h->blocksize))
955         rc = GCRYERR_INV_ARG;
956       else
957         rc = cipher_encrypt (h, out, in, inlen);
958     }
959
960   if (rc && out)
961     memset (out, 0x42, outsize); /* Failsafe: Make sure that the
962                                     plaintext will never make it into
963                                     OUT. */
964
965   return rc? set_lasterr (rc):0;
966 }
967
968
969
970 /****************
971  * Decrypt INBUF to OUTBUF with the mode selected at open.
972  * inbuf and outbuf may overlap or be the same.
973  * Depending on the mode some some contraints apply to NBYTES.
974  */
975 static int
976 cipher_decrypt( GCRY_CIPHER_HD c, byte *outbuf, const byte *inbuf,
977                                                         unsigned nbytes )
978 {
979     int rc = 0;
980
981     switch( c->mode ) {
982       case GCRY_CIPHER_MODE_ECB:
983         if (!(nbytes%c->blocksize))
984             do_ecb_decrypt(c, outbuf, inbuf, nbytes/c->blocksize );
985         else 
986             rc = GCRYERR_INV_ARG;
987         break;
988       case GCRY_CIPHER_MODE_CBC:
989         if (!(nbytes%c->blocksize) || (nbytes > c->blocksize && 
990                                        (c->flags & GCRY_CIPHER_CBC_CTS)))
991             do_cbc_decrypt(c, outbuf, inbuf, nbytes );
992         else 
993             rc = GCRYERR_INV_ARG;
994         break;
995       case GCRY_CIPHER_MODE_CFB:
996         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
997         break;
998       case GCRY_CIPHER_MODE_STREAM:
999         (*c->stdecrypt)( &c->context.c,
1000                          outbuf, (byte*)/*arggg*/inbuf, nbytes );
1001         break;
1002       case GCRY_CIPHER_MODE_NONE:
1003         if( inbuf != outbuf )
1004             memmove( outbuf, inbuf, nbytes );
1005         break;
1006       default:
1007         log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1008         rc = GCRYERR_INV_CIPHER_MODE;
1009         break;
1010     }
1011     return rc;
1012 }
1013
1014
1015 int
1016 gcry_cipher_decrypt( GCRY_CIPHER_HD h, byte *out, size_t outsize,
1017                                  const byte  *in, size_t inlen )
1018 {
1019     int rc;
1020
1021     if( !in ) {
1022         /* caller requested in-place encryption */
1023         /* actullay cipher_encrypt() does not need to know about it, but
1024          * we may chnage this to get better performace */
1025         rc = cipher_decrypt( h, out, out, outsize );
1026     }
1027     else {
1028         if( outsize < inlen )
1029             return set_lasterr( GCRYERR_TOO_SHORT );
1030         if ( ( h->mode == GCRY_CIPHER_MODE_ECB ||
1031                (h->mode == GCRY_CIPHER_MODE_CBC && 
1032                 !((h->flags & GCRY_CIPHER_CBC_CTS) &&
1033                   (inlen > h->blocksize)))) &&
1034              (inlen % h->blocksize) != 0 )
1035             return set_lasterr( GCRYERR_INV_ARG );
1036
1037         rc = cipher_decrypt( h, out, in, inlen );
1038     }
1039     return rc? set_lasterr (rc):0;
1040 }
1041
1042
1043
1044 /****************
1045  * Used for PGP's somewhat strange CFB mode. Only works if
1046  * the corresponding flag is set.
1047  */
1048 static void
1049 cipher_sync( GCRY_CIPHER_HD c )
1050 {
1051     if( (c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused ) {
1052         memmove(c->iv + c->unused, c->iv, c->blocksize - c->unused );
1053         memcpy(c->iv, c->lastiv + c->blocksize - c->unused, c->unused);
1054         c->unused = 0;
1055     }
1056 }
1057
1058
1059 int
1060 gcry_cipher_ctl( GCRY_CIPHER_HD h, int cmd, void *buffer, size_t buflen)
1061 {
1062   int rc = 0;
1063
1064   switch (cmd)
1065     {
1066     case GCRYCTL_SET_KEY:
1067       rc = cipher_setkey( h, buffer, buflen );
1068       break;
1069     case GCRYCTL_SET_IV:
1070       cipher_setiv( h, buffer, buflen );
1071       break;
1072     case GCRYCTL_RESET:
1073       cipher_reset (h);
1074       break;
1075     case GCRYCTL_CFB_SYNC:
1076       cipher_sync( h );
1077       break;
1078     case GCRYCTL_SET_CBC_CTS:
1079       if (buflen)
1080         if (h->flags & GCRY_CIPHER_CBC_MAC)
1081           rc = GCRYERR_INV_FLAG;
1082         else
1083           h->flags |= GCRY_CIPHER_CBC_CTS;
1084       else
1085         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1086       break;
1087     case GCRYCTL_SET_CBC_MAC:
1088       if (buflen)
1089         if (h->flags & GCRY_CIPHER_CBC_CTS)
1090           rc = GCRYERR_INV_FLAG;
1091         else
1092           h->flags |= GCRY_CIPHER_CBC_MAC;
1093       else
1094         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1095       break;
1096     case GCRYCTL_DISABLE_ALGO:
1097       /* this one expects a NULL handle and buffer pointing to an
1098        * integer with the algo number.
1099        */
1100       if( h || !buffer || buflen != sizeof(int) )
1101         return set_lasterr( GCRYERR_INV_CIPHER_ALGO );
1102       disable_cipher_algo( *(int*)buffer );
1103       break;
1104
1105     default:
1106       rc = GCRYERR_INV_OP;
1107     }
1108   return set_lasterr (rc);
1109 }
1110
1111
1112 /****************
1113  * Return information about the cipher handle.
1114  * -1 is returned on error and gcry_errno() may be used to get more information
1115  * about the error.
1116  */
1117 int
1118 gcry_cipher_info( GCRY_CIPHER_HD h, int cmd, void *buffer, size_t *nbytes)
1119 {
1120     switch( cmd ) {
1121       default:
1122         set_lasterr( GCRYERR_INV_OP );
1123         return -1;
1124     }
1125     return 0;
1126 }
1127
1128 /****************
1129  * Return information about the given cipher algorithm
1130  * WHAT select the kind of information returned:
1131  *  GCRYCTL_GET_KEYLEN:
1132  *      Return the length of the key, if the algorithm
1133  *      supports multiple key length, the maximum supported value
1134  *      is returnd.  The length is return as number of octets.
1135  *      buffer and nbytes must be zero.
1136  *      The keylength is returned in _bytes_.
1137  *  GCRYCTL_GET_BLKLEN:
1138  *      Return the blocklength of the algorithm counted in octets.
1139  *      buffer and nbytes must be zero.
1140  *  GCRYCTL_TEST_ALGO:
1141  *      Returns 0 when the specified algorithm is available for use.
1142  *      buffer and nbytes must be zero.
1143  *
1144  * On error the value -1 is returned and the error reason may be
1145  * retrieved by gcry_errno().
1146  * Note:  Because this function is in most cases used to return an
1147  * integer value, we can make it easier for the caller to just look at
1148  * the return value.  The caller will in all cases consult the value
1149  * and thereby detecting whether a error occured or not (i.e. while checking
1150  * the block size)
1151  */
1152 int
1153 gcry_cipher_algo_info( int algo, int what, void *buffer, size_t *nbytes)
1154 {
1155     unsigned int ui;
1156
1157     switch( what ) {
1158       case GCRYCTL_GET_KEYLEN:
1159         if( buffer || nbytes ) {
1160             set_lasterr( GCRYERR_INV_CIPHER_ALGO );
1161             break;
1162         }
1163         ui = cipher_get_keylen( algo );
1164         if( ui > 0 && ui <= 512 )
1165             return (int)ui/8;
1166         /* the only reason is an invalid algo or a strange blocksize */
1167         set_lasterr( GCRYERR_INV_CIPHER_ALGO );
1168         break;
1169
1170       case GCRYCTL_GET_BLKLEN:
1171         if( buffer || nbytes ) {
1172             set_lasterr( GCRYERR_INV_CIPHER_ALGO );
1173             break;
1174         }
1175         ui = cipher_get_blocksize( algo );
1176         if( ui > 0 && ui < 10000 )
1177             return (int)ui;
1178         /* the only reason is an invalid algo or a strange blocksize */
1179         set_lasterr( GCRYERR_INV_CIPHER_ALGO );
1180         break;
1181
1182       case GCRYCTL_TEST_ALGO:
1183         if( buffer || nbytes ) {
1184             set_lasterr( GCRYERR_INV_ARG );
1185             break;
1186         }
1187         if( check_cipher_algo( algo ) ) {
1188             set_lasterr( GCRYERR_INV_CIPHER_ALGO );
1189             break;
1190         }
1191         return 0;
1192
1193       default:
1194         set_lasterr( GCRYERR_INV_OP );
1195     }
1196     return -1;
1197 }
1198
1199
1200