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