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