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