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