Change the license to the LGPL.
[libgcrypt.git] / cipher / cipher.c
1 /* cipher.c  -  cipher dispatcher
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002 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 #define digitp(p)   (*(p) >= 0 && *(p) <= '9')
42
43 static struct {
44   const char *oidstring;
45   int algo;
46   int mode;
47 } oid_table[] = {
48   { "1.2.840.113549.3.7",      GCRY_CIPHER_3DES,   GCRY_CIPHER_MODE_CBC },
49
50   /* OIDs from NIST. See http://csrc.nist.gov.csor/ */
51   { "2.16.840.1.101.3.4.1.1",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_ECB },
52   { "2.16.840.1.101.3.4.1.2",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CBC },
53   { "2.16.840.1.101.3.4.1.3",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_OFB },
54   { "2.16.840.1.101.3.4.1.4",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CFB },
55   { "2.16.840.1.101.3.4.1.21", GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_ECB },
56   { "2.16.840.1.101.3.4.1.22", GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC },
57   { "2.16.840.1.101.3.4.1.23", GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_OFB },
58   { "2.16.840.1.101.3.4.1.24", GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CFB },
59   { "2.16.840.1.101.3.4.1.41", GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_ECB },
60   { "2.16.840.1.101.3.4.1.42", GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC },
61   { "2.16.840.1.101.3.4.1.43", GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_OFB },
62   { "2.16.840.1.101.3.4.1.44", GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB },
63
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 = CIPHER_ALGO_DUMMY;
223     cipher_table[i].name = "DUMMY";
224     cipher_table[i].blocksize = 8;
225     cipher_table[i].keylen = 128;
226     cipher_table[i].contextsize = 0;
227     cipher_table[i].setkey = dummy_setkey;
228     i++;
229
230     for( ; i < TABLE_SIZE; i++ )
231         cipher_table[i].name = NULL;
232 }
233
234
235 /****************
236  * Try to load all modules and return true if new modules are available
237  */
238 static int
239 load_cipher_modules(void)
240 {
241     static int done = 0;
242     static int initialized = 0;
243     void *context = NULL;
244     struct cipher_table_s *ct;
245     int ct_idx;
246     int i;
247     const char *name;
248     int any = 0;
249
250     if( !initialized ) {
251         _gcry_cipher_modules_constructor();
252         setup_cipher_table(); /* load static modules on the first call */
253         initialized = 1;
254         return 1;
255     }
256
257     if( done )
258         return 0;
259     done = 1;
260
261     for(ct_idx=0, ct = cipher_table; ct_idx < TABLE_SIZE; ct_idx++,ct++ ) {
262         if( !ct->name )
263             break;
264     }
265     if( ct_idx >= TABLE_SIZE-1 )
266         BUG(); /* table already full */
267     /* now load all extensions */
268     while( (name = _gcry_enum_gnupgext_ciphers( &context, &ct->algo,
269                                 &ct->keylen, &ct->blocksize, &ct->contextsize,
270                                 &ct->setkey, &ct->encrypt, &ct->decrypt)) ) {
271         if( ct->blocksize != 8 && ct->blocksize != 16 ) {
272             log_info("skipping cipher %d: unsupported blocksize\n", ct->algo);
273             continue;
274         }
275         for(i=0; cipher_table[i].name; i++ )
276             if( cipher_table[i].algo == ct->algo )
277                 break;
278         if( cipher_table[i].name ) {
279             log_info("skipping cipher %d: already loaded\n", ct->algo );
280             continue;
281         }
282         /* put it into the table */
283         if( _gcry_log_verbosity( 2 ) )
284             log_info("loaded cipher %d (%s)\n", ct->algo, name);
285         ct->name = name;
286         ct_idx++;
287         ct++;
288         any = 1;
289         /* check whether there are more available table slots */
290         if( ct_idx >= TABLE_SIZE-1 ) {
291             log_info("cipher table full; ignoring other extensions\n");
292             break;
293         }
294     }
295     _gcry_enum_gnupgext_ciphers( &context, NULL, NULL, NULL, NULL,
296                                            NULL, NULL, NULL );
297     return any;
298 }
299
300 /* locate the OID in the oid table and return the index or -1 when not
301    found */
302 static int 
303 search_oid (const char *string)
304 {
305   int i;
306   const char *s;
307
308   if (string && (digitp (string)
309                  || !strncmp (string, "oid.", 4) 
310                  || !strncmp (string, "OID.", 4) ))
311     {
312       s =  digitp(string)? string : (string+4);
313
314       for (i=0; oid_table[i].oidstring; i++)
315         {
316           if (!strcmp (s, oid_table[i].oidstring))
317             return i;
318         }
319     }
320   return -1;
321 }
322
323 /****************
324  * Map a string to the cipher algo.
325  * Returns: The algo ID of the cipher for the gioven name or
326  *          0 if the name is not known.
327  */
328 int
329 gcry_cipher_map_name( const char *string )
330 {
331   int i;
332   const char *s;
333   
334   if (!string)
335     return 0;
336
337   /* kludge to alias RIJNDAEL to AES */
338   if ( *string == 'R' || *string == 'r')
339     {
340       if (!strcasecmp (string, "RIJNDAEL"))
341         string = "AES";
342       else if (!strcasecmp (string, "RIJNDAEL192"))
343         string = "AES192";
344       else if (!strcasecmp (string, "RIJNDAEL256"))
345         string = "AES256";
346     }
347
348   /* If the string starts with a digit (optionally prefixed with
349      either "OID." or "oid."), we first look into our table of ASN.1
350      object identifiers to figure out the algorithm */
351   i = search_oid (string);
352   if (i != -1)
353     return oid_table[i].algo;
354   
355   do 
356     {
357       for (i=0; (s=cipher_table[i].name); i++ )
358         if ( !stricmp( s, string ) )
359           return cipher_table[i].algo;
360     } 
361   while ( load_cipher_modules() );
362   return 0;
363 }
364
365 int
366 gcry_cipher_mode_from_oid (const char *string)
367 {
368   int i;
369
370   i = search_oid (string);
371   return i == -1? 0 : oid_table[i].mode;
372 }
373
374
375 /****************
376  * Map a cipher algo to a string
377  */
378 static const char *
379 cipher_algo_to_string( int algo )
380 {
381     int i;
382
383     do {
384         for(i=0; cipher_table[i].name; i++ )
385             if( cipher_table[i].algo == algo )
386                 return cipher_table[i].name;
387     } while( load_cipher_modules() );
388     return NULL;
389 }
390
391 /****************
392  * This function simply returns the name of the algorithm or some constant
393  * string when there is no algo.  It will never return NULL.
394  */
395 const char *
396 gcry_cipher_algo_name( int algo )
397 {
398     const char *s = cipher_algo_to_string( algo );
399     return s? s: "";
400 }
401
402
403
404 static void
405 disable_cipher_algo( int algo )
406 {
407     int i;
408
409     for(i=0; i < DIM(disabled_algos); i++ ) {
410         if( !disabled_algos[i] || disabled_algos[i] == algo ) {
411             disabled_algos[i] = algo;
412             return;
413         }
414     }
415     /* fixme: we should use a linked list */
416     log_fatal("can't disable cipher algo %d: table full\n", algo );
417 }
418
419 /****************
420  * Return 0 if the cipher algo is available
421  */
422 static int
423 check_cipher_algo( int algo )
424 {
425     int i;
426
427     do {
428        for(i=0; cipher_table[i].name; i++ )
429            if( cipher_table[i].algo == algo ) {
430                 for(i=0; i < DIM(disabled_algos); i++ ) {
431                    if( disabled_algos[i] == algo )
432                        return GCRYERR_INV_CIPHER_ALGO;
433                 }
434                 return 0; /* okay */
435            }
436     } while( load_cipher_modules() );
437     return GCRYERR_INV_CIPHER_ALGO;
438 }
439
440
441 static unsigned
442 cipher_get_keylen( int algo )
443 {
444     int i;
445     unsigned len = 0;
446
447     do {
448         for(i=0; cipher_table[i].name; i++ ) {
449             if( cipher_table[i].algo == algo ) {
450                 len = cipher_table[i].keylen;
451                 if( !len )
452                     log_bug("cipher %d w/o key length\n", algo );
453                 return len;
454             }
455         }
456     } while( load_cipher_modules() );
457     log_bug("cipher %d not found\n", algo );
458     return 0;
459 }
460
461 static unsigned
462 cipher_get_blocksize( int algo )
463 {
464     int i;
465     unsigned len = 0;
466
467     do {
468         for(i=0; cipher_table[i].name; i++ ) {
469             if( cipher_table[i].algo == algo ) {
470                 len = cipher_table[i].blocksize;
471                 if( !len )
472                     log_bug("cipher %d w/o blocksize\n", algo );
473                 return len;
474             }
475         }
476     } while( load_cipher_modules() );
477     log_bug("cipher %d not found\n", algo );
478     return 0;
479 }
480
481
482 /****************
483  * Open a cipher handle for use with algorithm ALGO, in mode MODE
484  * and return the handle.  Return NULL and set the internal error variable
485  * if something goes wrong.
486  */
487
488 GCRY_CIPHER_HD
489 gcry_cipher_open( int algo, int mode, unsigned int flags )
490 {
491     GCRY_CIPHER_HD h;
492     int idx;
493     int secure = (flags & GCRY_CIPHER_SECURE);
494
495     fast_random_poll();
496
497     /* check whether the algo is available */
498     if( check_cipher_algo( algo ) ) {
499         set_lasterr( GCRYERR_INV_CIPHER_ALGO );
500         return NULL;
501     }
502
503     /* check flags */
504     if( (flags & ~(GCRY_CIPHER_SECURE|GCRY_CIPHER_ENABLE_SYNC)) ) {
505         set_lasterr( GCRYERR_INV_CIPHER_ALGO );
506         return NULL;
507     }
508
509     /* get the table index of the algo */
510     for(idx=0; cipher_table[idx].name; idx++ )
511         if( cipher_table[idx].algo == algo )
512             break;
513     if( !cipher_table[idx].name )
514         BUG(); /* check_cipher_algo() should have loaded the algo */
515
516     if( algo == CIPHER_ALGO_DUMMY )
517         mode = GCRY_CIPHER_MODE_NONE;  /* force this mode for dummy algo */
518
519     /* check that a valid mode has been requested */
520     switch( mode ) {
521       case GCRY_CIPHER_MODE_ECB:
522       case GCRY_CIPHER_MODE_CBC:
523       case GCRY_CIPHER_MODE_CFB:
524         if ( cipher_table[idx].encrypt == dummy_encrypt_block
525              || cipher_table[idx].decrypt == dummy_decrypt_block ) {
526             set_lasterr( GCRYERR_INV_CIPHER_MODE );
527             return NULL;
528         }
529         break;
530       case GCRY_CIPHER_MODE_STREAM:
531         if ( cipher_table[idx].stencrypt == dummy_encrypt_stream
532              || cipher_table[idx].stdecrypt == dummy_decrypt_stream ) {
533             set_lasterr( GCRYERR_INV_CIPHER_MODE );
534             return NULL;
535         }
536         break;
537       case GCRY_CIPHER_MODE_NONE:
538         /* FIXME: issue a warning when this mode is used */
539         break;
540       default:
541         set_lasterr( GCRYERR_INV_CIPHER_MODE );
542         return NULL;
543     }
544
545     /* ? perform selftest here and mark this with a flag in cipher_table ? */
546
547     h = secure ? gcry_calloc_secure( 1, sizeof *h
548                                        + cipher_table[idx].contextsize
549                                        - sizeof(PROPERLY_ALIGNED_TYPE) )
550                : gcry_calloc( 1, sizeof *h + cipher_table[idx].contextsize
551                                        - sizeof(PROPERLY_ALIGNED_TYPE)  );
552     if( !h ) {
553         set_lasterr( GCRYERR_NO_MEM );
554         return NULL;
555     }
556     h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
557     h->algo = algo;
558     h->mode = mode;
559     h->flags = flags;
560     h->blocksize = cipher_table[idx].blocksize;
561     h->setkey  = cipher_table[idx].setkey;
562     h->encrypt = cipher_table[idx].encrypt;
563     h->decrypt = cipher_table[idx].decrypt;
564     h->stencrypt = cipher_table[idx].stencrypt;
565     h->stdecrypt = cipher_table[idx].stdecrypt;
566
567     return h;
568 }
569
570
571 void
572 gcry_cipher_close( GCRY_CIPHER_HD h )
573 {
574     if( !h )
575         return;
576     if( h->magic != CTX_MAGIC_SECURE && h->magic != CTX_MAGIC_NORMAL )
577         _gcry_fatal_error(GCRYERR_INTERNAL,
578                         "gcry_cipher_close: already closed/invalid handle");
579     h->magic = 0;
580     gcry_free(h);
581 }
582
583
584 static int
585 cipher_setkey( GCRY_CIPHER_HD c, byte *key, unsigned keylen )
586 {
587     return (*c->setkey)( &c->context.c, key, keylen );
588 }
589
590
591 static void
592 cipher_setiv( GCRY_CIPHER_HD c, const byte *iv, unsigned ivlen )
593 {
594     memset( c->iv, 0, c->blocksize );
595     if( iv ) {
596         if( ivlen != c->blocksize )
597             log_info("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
598                                              ivlen, (unsigned)c->blocksize );
599         if( ivlen > c->blocksize )
600             ivlen = c->blocksize;
601         memcpy( c->iv, iv, ivlen );
602     }
603     c->unused = 0;
604 }
605
606
607
608 static void
609 do_ecb_encrypt( GCRY_CIPHER_HD c, byte *outbuf, const byte *inbuf, unsigned nblocks )
610 {
611     unsigned n;
612
613     for(n=0; n < nblocks; n++ ) {
614         (*c->encrypt)( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
615         inbuf  += c->blocksize;
616         outbuf += c->blocksize;
617     }
618 }
619
620 static void
621 do_ecb_decrypt( GCRY_CIPHER_HD c, byte *outbuf, const byte *inbuf, unsigned nblocks )
622 {
623     unsigned n;
624
625     for(n=0; n < nblocks; n++ ) {
626         (*c->decrypt)( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
627         inbuf  += c->blocksize;
628         outbuf += c->blocksize;
629     }
630 }
631
632 static void
633 do_cbc_encrypt( GCRY_CIPHER_HD c, byte *outbuf, const byte *inbuf, unsigned nblocks )
634 {
635     unsigned int n;
636     byte *ivp;
637     int i;
638     size_t blocksize = c->blocksize;
639
640     for(n=0; n < nblocks; n++ ) {
641         /* fixme: the xor should works on words and not on
642          * bytes.  Maybe it is a good idea to enhance the cipher backend
643          * API to allow for CBC handling in the backend */
644         for(ivp=c->iv,i=0; i < blocksize; i++ )
645             outbuf[i] = inbuf[i] ^ *ivp++;
646         (*c->encrypt)( &c->context.c, outbuf, outbuf );
647         memcpy(c->iv, outbuf, blocksize );
648         inbuf  += c->blocksize;
649         outbuf += c->blocksize;
650     }
651 }
652
653 static void
654 do_cbc_decrypt( GCRY_CIPHER_HD c, byte *outbuf, const byte *inbuf, unsigned nblocks )
655 {
656     unsigned int n;
657     byte *ivp;
658     int i;
659     size_t blocksize = c->blocksize;
660
661     for(n=0; n < nblocks; n++ ) {
662         /* because outbuf and inbuf might be the same, we have
663          * to save the original ciphertext block.  We use lastiv
664          * for this here because it is not used otherwise */
665         memcpy(c->lastiv, inbuf, blocksize );
666         (*c->decrypt)( &c->context.c, outbuf, (char*)/*argggg*/inbuf );
667         for(ivp=c->iv,i=0; i < blocksize; i++ )
668             outbuf[i] ^= *ivp++;
669         memcpy(c->iv, c->lastiv, blocksize );
670         inbuf  += c->blocksize;
671         outbuf += c->blocksize;
672     }
673 }
674
675
676 static void
677 do_cfb_encrypt( GCRY_CIPHER_HD c,
678                 byte *outbuf, const byte *inbuf, unsigned nbytes )
679 {
680     byte *ivp;
681     size_t blocksize = c->blocksize;
682
683     if( nbytes <= c->unused ) {
684         /* short enough to be encoded by the remaining XOR mask */
685         /* XOR the input with the IV and store input into IV */
686         for(ivp=c->iv+c->blocksize - c->unused; nbytes; nbytes--, c->unused-- )
687             *outbuf++ = (*ivp++ ^= *inbuf++);
688         return;
689     }
690
691     if( c->unused ) {
692         /* XOR the input with the IV and store input into IV */
693         nbytes -= c->unused;
694         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- )
695             *outbuf++ = (*ivp++ ^= *inbuf++);
696     }
697
698     /* now we can process complete blocks */
699     while( nbytes >= blocksize ) {
700         int i;
701         /* encrypt the IV (and save the current one) */
702         memcpy( c->lastiv, c->iv, blocksize );
703         (*c->encrypt)( &c->context.c, c->iv, c->iv );
704         /* XOR the input with the IV and store input into IV */
705         for(ivp=c->iv,i=0; i < blocksize; i++ )
706             *outbuf++ = (*ivp++ ^= *inbuf++);
707         nbytes -= blocksize;
708     }
709     if( nbytes ) { /* process the remaining bytes */
710         /* encrypt the IV (and save the current one) */
711         memcpy( c->lastiv, c->iv, blocksize );
712         (*c->encrypt)( &c->context.c, c->iv, c->iv );
713         c->unused = blocksize;
714         /* and apply the xor */
715         c->unused -= nbytes;
716         for(ivp=c->iv; nbytes; nbytes-- )
717             *outbuf++ = (*ivp++ ^= *inbuf++);
718     }
719 }
720
721 static void
722 do_cfb_decrypt( GCRY_CIPHER_HD c,
723                 byte *outbuf, const byte *inbuf, unsigned nbytes )
724 {
725     byte *ivp;
726     ulong temp;
727     size_t blocksize = c->blocksize;
728
729     if( nbytes <= c->unused ) {
730         /* short enough to be encoded by the remaining XOR mask */
731         /* XOR the input with the IV and store input into IV */
732         for(ivp=c->iv+blocksize - c->unused; nbytes; nbytes--,c->unused--){
733             temp = *inbuf++;
734             *outbuf++ = *ivp ^ temp;
735             *ivp++ = temp;
736         }
737         return;
738     }
739
740     if( c->unused ) {
741         /* XOR the input with the IV and store input into IV */
742         nbytes -= c->unused;
743         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- ) {
744             temp = *inbuf++;
745             *outbuf++ = *ivp ^ temp;
746             *ivp++ = temp;
747         }
748     }
749
750     /* now we can process complete blocks */
751     while( nbytes >= blocksize ) {
752         int i;
753         /* encrypt the IV (and save the current one) */
754         memcpy( c->lastiv, c->iv, blocksize );
755         (*c->encrypt)( &c->context.c, c->iv, c->iv );
756         /* XOR the input with the IV and store input into IV */
757         for(ivp=c->iv,i=0; i < blocksize; i++ ) {
758             temp = *inbuf++;
759             *outbuf++ = *ivp ^ temp;
760             *ivp++ = temp;
761         }
762         nbytes -= blocksize;
763     }
764     if( nbytes ) { /* process the remaining bytes */
765         /* encrypt the IV (and save the current one) */
766         memcpy( c->lastiv, c->iv, blocksize );
767         (*c->encrypt)( &c->context.c, c->iv, c->iv );
768         c->unused = blocksize;
769         /* and apply the xor */
770         c->unused -= nbytes;
771         for(ivp=c->iv; nbytes; nbytes-- ) {
772             temp = *inbuf++;
773             *outbuf++ = *ivp ^ temp;
774             *ivp++ = temp;
775         }
776     }
777 }
778
779
780
781
782 /****************
783  * Encrypt INBUF to OUTBUF with the mode selected at open.
784  * inbuf and outbuf may overlap or be the same.
785  * Depending on the mode some contraints apply to NBYTES.
786  */
787 static int
788 cipher_encrypt( GCRY_CIPHER_HD c, byte *outbuf,
789                                   const byte *inbuf, unsigned int nbytes )
790 {
791     int rc = 0;
792
793     switch( c->mode ) {
794       case GCRY_CIPHER_MODE_ECB:
795         if (!(nbytes%c->blocksize))
796             do_ecb_encrypt(c, outbuf, inbuf, nbytes/c->blocksize );
797         else 
798             rc = GCRYERR_INV_ARG;
799         break;
800       case GCRY_CIPHER_MODE_CBC:
801         if (!(nbytes%c->blocksize))
802             do_cbc_encrypt(c, outbuf, inbuf, nbytes/c->blocksize );
803         else 
804             rc = GCRYERR_INV_ARG;
805         break;
806       case GCRY_CIPHER_MODE_CFB:
807         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
808         break;
809       case GCRY_CIPHER_MODE_STREAM:
810         (*c->stencrypt)( &c->context.c,
811                          outbuf, (byte*)/*arggg*/inbuf, nbytes );
812         break;
813       case GCRY_CIPHER_MODE_NONE:
814         if( inbuf != outbuf )
815             memmove( outbuf, inbuf, nbytes );
816         break;
817       default:
818         log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
819         rc = GCRYERR_INV_CIPHER_MODE;
820         break;
821     }
822     return rc;
823 }
824
825
826 /****************
827  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
828  * been requested,
829  */
830 int
831 gcry_cipher_encrypt( GCRY_CIPHER_HD h, byte *out, size_t outsize,
832                                        const byte  *in, size_t inlen )
833 {
834     int rc;
835
836     if ( !in ) {
837         /* caller requested in-place encryption */
838         /* actullay cipher_encrypt() does not need to know about it, but
839          * we may chnage this to get better performace */
840         rc = cipher_encrypt ( h, out, out, outsize );
841     }
842     else {
843         if ( outsize < inlen )
844             return set_lasterr ( GCRYERR_TOO_SHORT );
845         /* fixme: check that the inlength is a multipe of the blocksize
846          * if a blockoriented mode is used, or modify cipher_encrypt to
847          * return an error in this case */
848         rc = cipher_encrypt ( h, out, in, inlen );
849     }
850
851     return rc? set_lasterr (rc):0;
852 }
853
854
855
856 /****************
857  * Decrypt INBUF to OUTBUF with the mode selected at open.
858  * inbuf and outbuf may overlap or be the same.
859  * Depending on the mode some some contraints apply to NBYTES.
860  */
861 static int
862 cipher_decrypt( GCRY_CIPHER_HD c, byte *outbuf, const byte *inbuf,
863                                                         unsigned nbytes )
864 {
865     int rc = 0;
866
867     switch( c->mode ) {
868       case GCRY_CIPHER_MODE_ECB:
869         if (!(nbytes%c->blocksize))
870             do_ecb_decrypt(c, outbuf, inbuf, nbytes/c->blocksize );
871         else 
872             rc = GCRYERR_INV_ARG;
873         break;
874       case GCRY_CIPHER_MODE_CBC:
875         if (!(nbytes%c->blocksize))
876             do_cbc_decrypt(c, outbuf, inbuf, nbytes/c->blocksize );
877         else 
878             rc = GCRYERR_INV_ARG;
879         break;
880       case GCRY_CIPHER_MODE_CFB:
881         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
882         break;
883       case GCRY_CIPHER_MODE_STREAM:
884         (*c->stdecrypt)( &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_decrypt: invalid mode %d\n", c->mode );
893         rc = GCRYERR_INV_CIPHER_MODE;
894         break;
895     }
896     return rc;
897 }
898
899
900 int
901 gcry_cipher_decrypt( GCRY_CIPHER_HD h, byte *out, size_t outsize,
902                                  const byte  *in, size_t inlen )
903 {
904     int rc;
905
906     if( !in ) {
907         /* caller requested in-place encryption */
908         /* actullay cipher_encrypt() does not need to know about it, but
909          * we may chnage this to get better performace */
910         rc = cipher_decrypt( h, out, out, outsize );
911     }
912     else {
913         if( outsize < inlen )
914             return set_lasterr( GCRYERR_TOO_SHORT );
915         /* fixme: check that the inlength is a multipe of the blocksize
916          * if a blockoriented mode is used, or modify cipher_encrypt to
917          * return an error in this case */
918         rc = cipher_decrypt( h, out, in, inlen );
919     }
920     return rc? set_lasterr (rc):0;
921 }
922
923
924
925 /****************
926  * Used for PGP's somewhat strange CFB mode. Only works if
927  * the corresponding flag is set.
928  */
929 static void
930 cipher_sync( GCRY_CIPHER_HD c )
931 {
932     if( (c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused ) {
933         memmove(c->iv + c->unused, c->iv, c->blocksize - c->unused );
934         memcpy(c->iv, c->lastiv + c->blocksize - c->unused, c->unused);
935         c->unused = 0;
936     }
937 }
938
939
940 int
941 gcry_cipher_ctl( GCRY_CIPHER_HD h, int cmd, void *buffer, size_t buflen)
942 {
943   int rc = 0;
944
945   switch (cmd)
946     {
947     case GCRYCTL_SET_KEY:
948       rc = cipher_setkey( h, buffer, buflen );
949       break;
950     case GCRYCTL_SET_IV:
951       cipher_setiv( h, buffer, buflen );
952       break;
953     case GCRYCTL_CFB_SYNC:
954       cipher_sync( h );
955       break;
956
957     case GCRYCTL_DISABLE_ALGO:
958       /* this one expects a NULL handle and buffer pointing to an
959        * integer with the algo number.
960        */
961       if( h || !buffer || buflen != sizeof(int) )
962         return set_lasterr( GCRYERR_INV_CIPHER_ALGO );
963       disable_cipher_algo( *(int*)buffer );
964       break;
965
966     default:
967       rc = GCRYERR_INV_OP;
968     }
969   return set_lasterr (rc);
970 }
971
972
973 /****************
974  * Return information about the cipher handle.
975  * -1 is returned on error and gcry_errno() may be used to get more information
976  * about the error.
977  */
978 int
979 gcry_cipher_info( GCRY_CIPHER_HD h, int cmd, void *buffer, size_t *nbytes)
980 {
981     switch( cmd ) {
982       default:
983         set_lasterr( GCRYERR_INV_OP );
984         return -1;
985     }
986     return 0;
987 }
988
989 /****************
990  * Return information about the given cipher algorithm
991  * WHAT select the kind of information returned:
992  *  GCRYCTL_GET_KEYLEN:
993  *      Return the length of the key, if the algorithm
994  *      supports multiple key length, the maximum supported value
995  *      is returnd.  The length is return as number of octets.
996  *      buffer and nbytes must be zero.
997  *      The keylength is returned in _bytes_.
998  *  GCRYCTL_GET_BLKLEN:
999  *      Return the blocklength of the algorithm counted in octets.
1000  *      buffer and nbytes must be zero.
1001  *  GCRYCTL_TEST_ALGO:
1002  *      Returns 0 when the specified algorithm is available for use.
1003  *      buffer and nbytes must be zero.
1004  *
1005  * On error the value -1 is returned and the error reason may be
1006  * retrieved by gcry_errno().
1007  * Note:  Because this function is in most cases used to return an
1008  * integer value, we can make it easier for the caller to just look at
1009  * the return value.  The caller will in all cases consult the value
1010  * and thereby detecting whether a error occured or not (i.e. while checking
1011  * the block size)
1012  */
1013 int
1014 gcry_cipher_algo_info( int algo, int what, void *buffer, size_t *nbytes)
1015 {
1016     unsigned int ui;
1017
1018     switch( what ) {
1019       case GCRYCTL_GET_KEYLEN:
1020         if( buffer || nbytes ) {
1021             set_lasterr( GCRYERR_INV_CIPHER_ALGO );
1022             break;
1023         }
1024         ui = cipher_get_keylen( algo );
1025         if( ui > 0 && ui <= 512 )
1026             return (int)ui/8;
1027         /* the only reason is an invalid algo or a strange blocksize */
1028         set_lasterr( GCRYERR_INV_CIPHER_ALGO );
1029         break;
1030
1031       case GCRYCTL_GET_BLKLEN:
1032         if( buffer || nbytes ) {
1033             set_lasterr( GCRYERR_INV_CIPHER_ALGO );
1034             break;
1035         }
1036         ui = cipher_get_blocksize( algo );
1037         if( ui > 0 && ui < 10000 )
1038             return (int)ui;
1039         /* the only reason is an invalid algo or a strange blocksize */
1040         set_lasterr( GCRYERR_INV_CIPHER_ALGO );
1041         break;
1042
1043       case GCRYCTL_TEST_ALGO:
1044         if( buffer || nbytes ) {
1045             set_lasterr( GCRYERR_INV_ARG );
1046             break;
1047         }
1048         if( check_cipher_algo( algo ) ) {
1049             set_lasterr( GCRYERR_INV_CIPHER_ALGO );
1050             break;
1051         }
1052         return 0;
1053
1054       default:
1055         set_lasterr( GCRYERR_INV_OP );
1056     }
1057     return -1;
1058 }
1059
1060
1061