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