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