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