66470ee6a525bd0b3abd410d4c565f3287b2431d
[libgcrypt.git] / cipher / cipher.c
1 /* cipher.c  -  cipher dispatcher
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *               2005, 2007 Free Software Foundation, Inc.
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser general Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26
27 #include "g10lib.h"
28 #include "cipher.h"
29 #include "ath.h"
30
31 #define MAX_BLOCKSIZE 16
32 #define TABLE_SIZE 14
33 #define CTX_MAGIC_NORMAL 0x24091964
34 #define CTX_MAGIC_SECURE 0x46919042
35
36 #undef NEED_16BYTE_ALIGNED_CONTEXT
37 #if defined (__i386__) && SIZEOF_UNSIGNED_LONG == 4 && defined (__GNUC__)
38 #define NEED_16BYTE_ALIGNED_CONTEXT 1
39 #endif
40
41 /* This is the list of the default ciphers, which are included in
42    libgcrypt.  */
43 static struct cipher_table_entry
44 {
45   gcry_cipher_spec_t *cipher;
46   unsigned int algorithm;
47 } cipher_table[] =
48   {
49 #if USE_BLOWFISH
50     { &_gcry_cipher_spec_blowfish,   GCRY_CIPHER_BLOWFISH },
51 #endif
52 #if USE_DES
53     { &_gcry_cipher_spec_des,        GCRY_CIPHER_DES },
54     { &_gcry_cipher_spec_tripledes,  GCRY_CIPHER_3DES },
55 #endif
56 #if USE_ARCFOUR
57     { &_gcry_cipher_spec_arcfour,    GCRY_CIPHER_ARCFOUR },
58 #endif
59 #if USE_CAST5
60     { &_gcry_cipher_spec_cast5,      GCRY_CIPHER_CAST5 },
61 #endif
62 #if USE_AES
63     { &_gcry_cipher_spec_aes,        GCRY_CIPHER_AES},
64     { &_gcry_cipher_spec_aes192,     GCRY_CIPHER_AES192},
65     { &_gcry_cipher_spec_aes256,     GCRY_CIPHER_AES256},
66 #endif
67 #if USE_TWOFISH
68     { &_gcry_cipher_spec_twofish,    GCRY_CIPHER_TWOFISH },
69     { &_gcry_cipher_spec_twofish128, GCRY_CIPHER_TWOFISH128 },
70 #endif
71 #if USE_SERPENT
72     { &_gcry_cipher_spec_serpent128, GCRY_CIPHER_SERPENT128 },
73     { &_gcry_cipher_spec_serpent192, GCRY_CIPHER_SERPENT192 },
74     { &_gcry_cipher_spec_serpent256, GCRY_CIPHER_SERPENT256 },
75 #endif
76 #if USE_RFC2268
77     { &_gcry_cipher_spec_rfc2268_40, GCRY_CIPHER_RFC2268_40 },
78 #endif
79 #if USE_SEED
80     { &_gcry_cipher_spec_seed,       GCRY_CIPHER_SEED },
81 #endif
82 #if USE_CAMELLIA
83     { &_gcry_cipher_spec_camellia128, GCRY_CIPHER_CAMELLIA128 },
84     { &_gcry_cipher_spec_camellia192, GCRY_CIPHER_CAMELLIA192 },
85     { &_gcry_cipher_spec_camellia256, GCRY_CIPHER_CAMELLIA256 },
86 #endif
87     { NULL                    }
88   };
89
90 /* List of registered ciphers.  */
91 static gcry_module_t ciphers_registered;
92
93 /* This is the lock protecting CIPHERS_REGISTERED.  */
94 static ath_mutex_t ciphers_registered_lock = ATH_MUTEX_INITIALIZER;
95
96 /* Flag to check wether the default ciphers have already been
97    registered.  */
98 static int default_ciphers_registered;
99
100 /* Convenient macro for registering the default ciphers.  */
101 #define REGISTER_DEFAULT_CIPHERS                   \
102   do                                               \
103     {                                              \
104       ath_mutex_lock (&ciphers_registered_lock);   \
105       if (! default_ciphers_registered)            \
106         {                                          \
107           gcry_cipher_register_default ();         \
108           default_ciphers_registered = 1;          \
109         }                                          \
110       ath_mutex_unlock (&ciphers_registered_lock); \
111     }                                              \
112   while (0)
113
114
115 /* A VIA processor with the Padlock engine requires an alignment of
116    most data on a 16 byte boundary.  Because we trick out the compiler
117    while allocating the context, the align attribute as used in
118    rijndael.c does not work on its own.  Thus we need to make sure
119    that the entire context structure is a aligned on that boundary.
120    We achieve this by defining a new type and use that instead of our
121    usual alignment type.  */
122 typedef union 
123 {
124   PROPERLY_ALIGNED_TYPE foo;
125 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
126   char bar[16] __attribute__ ((aligned (16)));
127 #endif  
128   char c[1];
129 } cipher_context_alignment_t;
130
131
132 /* The handle structure.  */
133 struct gcry_cipher_handle
134 {
135   int magic;
136   size_t actual_handle_size;     /* Allocated size of this handle. */
137   size_t handle_offset;          /* Offset to the malloced block.  */
138   gcry_cipher_spec_t *cipher;
139   gcry_module_t module;
140
141   /* The algorithm id.  This is a hack required because the module
142      interface does not easily allow to retrieve this value. */
143   int algo;  
144
145   /* A structure with function pointers for bulk operations.  Due to
146      limitations of the module system (we don't want to change the
147      API) we need to keep these function pointers here.  The cipher
148      open function intializes them and the actual encryption routines
149      use them if they are not NULL.  */
150   struct {
151     void (*cfb_enc)(void *context, unsigned char *iv, 
152                     void *outbuf_arg, const void *inbuf_arg,
153                     unsigned int nblocks);
154     void (*cfb_dec)(void *context, unsigned char *iv, 
155                     void *outbuf_arg, const void *inbuf_arg,
156                     unsigned int nblocks);
157     void (*cbc_enc)(void *context, unsigned char *iv, 
158                     void *outbuf_arg, const void *inbuf_arg,
159                     unsigned int nblocks, int cbc_mac);
160     void (*cbc_dec)(void *context, unsigned char *iv, 
161                     void *outbuf_arg, const void *inbuf_arg,
162                     unsigned int nblocks);
163   } bulk;
164
165
166   int mode;
167   unsigned int flags;
168
169   /* The initialization vector.  To help code optimization we make
170      sure that it is aligned on an unsigned long and u32 boundary.  */
171   union {
172     unsigned long dummy_iv;         
173     u32 dummy_u32_iv;
174     unsigned char iv[MAX_BLOCKSIZE];    
175   } u_iv;
176
177   unsigned char lastiv[MAX_BLOCKSIZE];
178   int unused;  /* Number of unused bytes in the IV. */
179
180   unsigned char ctr[MAX_BLOCKSIZE];     /* For Counter (CTR) mode. */
181
182
183   /* What follows are two contexts of the cipher in use.  The first
184      one needs to be aligned well enough for the cipher operation
185      whereas the second one is a copy created by cipher_setkey and
186      used by cipher_reset.  That second copy has no need for proper
187      aligment because it is only accessed by memcpy.  */
188   cipher_context_alignment_t context;
189 };
190
191
192 \f
193 /* These dummy functions are used in case a cipher implementation
194    refuses to provide it's own functions.  */
195
196 static gcry_err_code_t
197 dummy_setkey (void *c, const unsigned char *key, unsigned int keylen)
198 {
199   (void)c; 
200   (void)key;
201   (void)keylen;
202   return GPG_ERR_NO_ERROR;
203 }
204
205 static void
206 dummy_encrypt_block (void *c,
207                      unsigned char *outbuf, const unsigned char *inbuf)
208 {
209   (void)c;
210   (void)outbuf;
211   (void)inbuf;
212   BUG();
213 }
214
215 static void
216 dummy_decrypt_block (void *c,
217                      unsigned char *outbuf, const unsigned char *inbuf)
218 {
219   (void)c;
220   (void)outbuf;
221   (void)inbuf;
222   BUG();
223 }
224
225 static void
226 dummy_encrypt_stream (void *c,
227                       unsigned char *outbuf, const unsigned char *inbuf,
228                       unsigned int n)
229 {
230   (void)c;
231   (void)outbuf;
232   (void)inbuf;
233   (void)n;
234   BUG();
235 }
236
237 static void
238 dummy_decrypt_stream (void *c,
239                       unsigned char *outbuf, const unsigned char *inbuf,
240                       unsigned int n)
241 {
242   (void)c;
243   (void)outbuf;
244   (void)inbuf;
245   (void)n;
246   BUG();
247 }
248
249 \f
250 /* Internal function.  Register all the ciphers included in
251    CIPHER_TABLE.  Note, that this function gets only used by the macro
252    REGISTER_DEFAULT_CIPHERS which protects it using a mutex. */
253 static void
254 gcry_cipher_register_default (void)
255 {
256   gcry_err_code_t err = GPG_ERR_NO_ERROR;
257   int i;
258   
259   for (i = 0; !err && cipher_table[i].cipher; i++)
260     {
261       if (! cipher_table[i].cipher->setkey)
262         cipher_table[i].cipher->setkey = dummy_setkey;
263       if (! cipher_table[i].cipher->encrypt)
264         cipher_table[i].cipher->encrypt = dummy_encrypt_block;
265       if (! cipher_table[i].cipher->decrypt)
266         cipher_table[i].cipher->decrypt = dummy_decrypt_block;
267       if (! cipher_table[i].cipher->stencrypt)
268         cipher_table[i].cipher->stencrypt = dummy_encrypt_stream;
269       if (! cipher_table[i].cipher->stdecrypt)
270         cipher_table[i].cipher->stdecrypt = dummy_decrypt_stream;
271
272       err = _gcry_module_add (&ciphers_registered,
273                               cipher_table[i].algorithm,
274                               (void *) cipher_table[i].cipher,
275                               NULL);
276     }
277
278   if (err)
279     BUG ();
280 }
281
282 /* Internal callback function.  Used via _gcry_module_lookup.  */
283 static int
284 gcry_cipher_lookup_func_name (void *spec, void *data)
285 {
286   gcry_cipher_spec_t *cipher = (gcry_cipher_spec_t *) spec;
287   char *name = (char *) data;
288   const char **aliases = cipher->aliases;
289   int i, ret = ! stricmp (name, cipher->name);
290
291   if (aliases)
292     for (i = 0; aliases[i] && (! ret); i++)
293       ret = ! stricmp (name, aliases[i]);
294
295   return ret;
296 }
297
298 /* Internal callback function.  Used via _gcry_module_lookup.  */
299 static int
300 gcry_cipher_lookup_func_oid (void *spec, void *data)
301 {
302   gcry_cipher_spec_t *cipher = (gcry_cipher_spec_t *) spec;
303   char *oid = (char *) data;
304   gcry_cipher_oid_spec_t *oid_specs = cipher->oids;
305   int ret = 0, i;
306
307   if (oid_specs)
308     for (i = 0; oid_specs[i].oid && (! ret); i++)
309       if (! stricmp (oid, oid_specs[i].oid))
310         ret = 1;
311
312   return ret;
313 }
314
315 /* Internal function.  Lookup a cipher entry by it's name.  */
316 static gcry_module_t
317 gcry_cipher_lookup_name (const char *name)
318 {
319   gcry_module_t cipher;
320
321   cipher = _gcry_module_lookup (ciphers_registered, (void *) name,
322                                 gcry_cipher_lookup_func_name);
323
324   return cipher;
325 }
326
327 /* Internal function.  Lookup a cipher entry by it's oid.  */
328 static gcry_module_t
329 gcry_cipher_lookup_oid (const char *oid)
330 {
331   gcry_module_t cipher;
332
333   cipher = _gcry_module_lookup (ciphers_registered, (void *) oid,
334                                 gcry_cipher_lookup_func_oid);
335
336   return cipher;
337 }
338
339 /* Register a new cipher module whose specification can be found in
340    CIPHER.  On success, a new algorithm ID is stored in ALGORITHM_ID
341    and a pointer representhing this module is stored in MODULE.  */
342 gcry_error_t
343 gcry_cipher_register (gcry_cipher_spec_t *cipher,
344                       int *algorithm_id,
345                       gcry_module_t *module)
346 {
347   gcry_err_code_t err = 0;
348   gcry_module_t mod;
349
350   ath_mutex_lock (&ciphers_registered_lock);
351   err = _gcry_module_add (&ciphers_registered, 0,
352                           (void *) cipher, &mod);
353   ath_mutex_unlock (&ciphers_registered_lock);
354
355   if (! err)
356     {
357       *module = mod;
358       *algorithm_id = mod->mod_id;
359     }
360
361   return gcry_error (err);
362 }
363
364 /* Unregister the cipher identified by MODULE, which must have been
365    registered with gcry_cipher_register.  */
366 void
367 gcry_cipher_unregister (gcry_module_t module)
368 {
369   ath_mutex_lock (&ciphers_registered_lock);
370   _gcry_module_release (module);
371   ath_mutex_unlock (&ciphers_registered_lock);
372 }
373
374 /* Locate the OID in the oid table and return the index or -1 when not
375    found.  An opitonal "oid." or "OID." prefix in OID is ignored, the
376    OID is expected to be in standard IETF dotted notation.  The
377    internal algorithm number is returned in ALGORITHM unless it
378    ispassed as NULL.  A pointer to the specification of the module
379    implementing this algorithm is return in OID_SPEC unless passed as
380    NULL.*/
381 static int 
382 search_oid (const char *oid, int *algorithm, gcry_cipher_oid_spec_t *oid_spec)
383 {
384   gcry_module_t module;
385   int ret = 0;
386
387   if (oid && ((! strncmp (oid, "oid.", 4))
388               || (! strncmp (oid, "OID.", 4))))
389     oid += 4;
390
391   module = gcry_cipher_lookup_oid (oid);
392   if (module)
393     {
394       gcry_cipher_spec_t *cipher = module->spec;
395       int i;
396
397       for (i = 0; cipher->oids[i].oid && !ret; i++)
398         if (! stricmp (oid, cipher->oids[i].oid))
399           {
400             if (algorithm)
401               *algorithm = module->mod_id;
402             if (oid_spec)
403               *oid_spec = cipher->oids[i];
404             ret = 1;
405           }
406       _gcry_module_release (module);
407     }
408
409   return ret;
410 }
411
412 /* Map STRING to the cipher algorithm identifier.  Returns the
413    algorithm ID of the cipher for the given name or 0 if the name is
414    not known.  It is valid to pass NULL for STRING which results in a
415    return value of 0. */
416 int
417 gcry_cipher_map_name (const char *string)
418 {
419   gcry_module_t cipher;
420   int ret, algorithm = 0;
421
422   if (! string)
423     return 0;
424
425   REGISTER_DEFAULT_CIPHERS;
426
427   /* If the string starts with a digit (optionally prefixed with
428      either "OID." or "oid."), we first look into our table of ASN.1
429      object identifiers to figure out the algorithm */
430
431   ath_mutex_lock (&ciphers_registered_lock);
432
433   ret = search_oid (string, &algorithm, NULL);
434   if (! ret)
435     {
436       cipher = gcry_cipher_lookup_name (string);
437       if (cipher)
438         {
439           algorithm = cipher->mod_id;
440           _gcry_module_release (cipher);
441         }
442     }
443
444   ath_mutex_unlock (&ciphers_registered_lock);
445   
446   return algorithm;
447 }
448
449
450 /* Given a STRING with an OID in dotted decimal notation, this
451    function returns the cipher mode (GCRY_CIPHER_MODE_*) associated
452    with that OID or 0 if no mode is known.  Passing NULL for string
453    yields a return value of 0. */
454 int
455 gcry_cipher_mode_from_oid (const char *string)
456 {
457   gcry_cipher_oid_spec_t oid_spec;
458   int ret = 0, mode = 0;
459
460   if (!string)
461     return 0;
462
463   ath_mutex_lock (&ciphers_registered_lock);
464   ret = search_oid (string, NULL, &oid_spec);
465   if (ret)
466     mode = oid_spec.mode;
467   ath_mutex_unlock (&ciphers_registered_lock);
468
469   return mode;
470 }
471
472
473 /* Map the cipher algorithm whose ID is contained in ALGORITHM to a
474    string representation of the algorithm name.  For unknown algorithm
475    IDs this function returns "?".  */
476 static const char *
477 cipher_algo_to_string (int algorithm)
478 {
479   gcry_module_t cipher;
480   const char *name;
481
482   REGISTER_DEFAULT_CIPHERS;
483
484   ath_mutex_lock (&ciphers_registered_lock);
485   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
486   if (cipher)
487     {
488       name = ((gcry_cipher_spec_t *) cipher->spec)->name;
489       _gcry_module_release (cipher);
490     }
491   else
492     name = "?";
493   ath_mutex_unlock (&ciphers_registered_lock);
494
495   return name;
496 }
497
498 /* Map the cipher algorithm identifier ALGORITHM to a string
499    representing this algorithm.  This string is the default name as
500    used by Libgcrypt.  An pointer to an empty string is returned for
501    an unknown algorithm.  NULL is never returned. */
502 const char *
503 gcry_cipher_algo_name (int algorithm)
504 {
505   return cipher_algo_to_string (algorithm);
506 }
507
508
509 /* Flag the cipher algorithm with the identifier ALGORITHM as
510    disabled.  There is no error return, the function does nothing for
511    unknown algorithms.  Disabled algorithms are vitually not available
512    in Libgcrypt. */
513 static void
514 disable_cipher_algo (int algorithm)
515 {
516   gcry_module_t cipher;
517
518   REGISTER_DEFAULT_CIPHERS;
519
520   ath_mutex_lock (&ciphers_registered_lock);
521   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
522   if (cipher)
523     {
524       if (! (cipher->flags & FLAG_MODULE_DISABLED))
525         cipher->flags |= FLAG_MODULE_DISABLED;
526       _gcry_module_release (cipher);
527     }
528   ath_mutex_unlock (&ciphers_registered_lock);
529 }
530
531
532 /* Return 0 if the cipher algorithm with indentifier ALGORITHM is
533    available. Returns a basic error code value if it is not available.  */
534 static gcry_err_code_t
535 check_cipher_algo (int algorithm)
536 {
537   gcry_err_code_t err = GPG_ERR_NO_ERROR;
538   gcry_module_t cipher;
539
540   REGISTER_DEFAULT_CIPHERS;
541
542   ath_mutex_lock (&ciphers_registered_lock);
543   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
544   if (cipher)
545     {
546       if (cipher->flags & FLAG_MODULE_DISABLED)
547         err = GPG_ERR_CIPHER_ALGO;
548       _gcry_module_release (cipher);
549     }
550   else
551     err = GPG_ERR_CIPHER_ALGO;
552   ath_mutex_unlock (&ciphers_registered_lock);
553   
554   return err;
555 }
556
557
558 /* Return the standard length of the key for the cipher algorithm with
559    the identifier ALGORITHM.  This function expects a valid algorithm
560    and will abort if the algorithm is not available or the length of
561    the key is not known. */
562 static unsigned int
563 cipher_get_keylen (int algorithm)
564 {
565   gcry_module_t cipher;
566   unsigned len = 0;
567
568   REGISTER_DEFAULT_CIPHERS;
569
570   ath_mutex_lock (&ciphers_registered_lock);
571   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
572   if (cipher)
573     {
574       len = ((gcry_cipher_spec_t *) cipher->spec)->keylen;
575       if (! len)
576         log_bug ("cipher %d w/o key length\n", algorithm);
577       _gcry_module_release (cipher);
578     }
579   else
580     log_bug ("cipher %d not found\n", algorithm);
581   ath_mutex_unlock (&ciphers_registered_lock);
582
583   return len;
584 }
585
586 /* Return the block length of the cipher algorithm with the identifier
587    ALGORITHM.  This function expects a valid algorithm and will abort
588    if the algorithm is not available or the length of the key is not
589    known. */
590 static unsigned int
591 cipher_get_blocksize (int algorithm)
592 {
593   gcry_module_t cipher;
594   unsigned len = 0;
595
596   REGISTER_DEFAULT_CIPHERS;
597
598   ath_mutex_lock (&ciphers_registered_lock);
599   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
600   if (cipher)
601     {
602       len = ((gcry_cipher_spec_t *) cipher->spec)->blocksize;
603       if (! len)
604           log_bug ("cipher %d w/o blocksize\n", algorithm);
605       _gcry_module_release (cipher);
606     }
607   else
608     log_bug ("cipher %d not found\n", algorithm);
609   ath_mutex_unlock (&ciphers_registered_lock);
610
611   return len;
612 }
613
614
615 /*
616    Open a cipher handle for use with cipher algorithm ALGORITHM, using
617    the cipher mode MODE (one of the GCRY_CIPHER_MODE_*) and return a
618    handle in HANDLE.  Put NULL into HANDLE and return an error code if
619    something goes wrong.  FLAGS may be used to modify the
620    operation.  The defined flags are:
621
622    GCRY_CIPHER_SECURE:  allocate all internal buffers in secure memory.
623    GCRY_CIPHER_ENABLE_SYNC:  Enable the sync operation as used in OpenPGP.
624    GCRY_CIPHER_CBC_CTS:  Enable CTS mode.
625    GCRY_CIPHER_CBC_MAC:  Enable MAC mode.
626
627    Values for these flags may be combined using OR.
628  */
629 gcry_error_t
630 gcry_cipher_open (gcry_cipher_hd_t *handle,
631                   int algo, int mode, unsigned int flags)
632 {
633   int secure = (flags & GCRY_CIPHER_SECURE);
634   gcry_cipher_spec_t *cipher = NULL;
635   gcry_module_t module = NULL;
636   gcry_cipher_hd_t h = NULL;
637   gcry_err_code_t err = 0;
638
639   /* If the application missed to call the random poll function, we do
640      it here to ensure that it is used once in a while. */
641   _gcry_fast_random_poll ();
642   
643   REGISTER_DEFAULT_CIPHERS;
644
645   /* Fetch the according module and check wether the cipher is marked
646      available for use.  */
647   ath_mutex_lock (&ciphers_registered_lock);
648   module = _gcry_module_lookup_id (ciphers_registered, algo);
649   if (module)
650     {
651       /* Found module.  */
652
653       if (module->flags & FLAG_MODULE_DISABLED)
654         {
655           /* Not available for use.  */
656           err = GPG_ERR_CIPHER_ALGO;
657           _gcry_module_release (module);
658         }
659       else
660         cipher = (gcry_cipher_spec_t *) module->spec;
661     }
662   else
663     err = GPG_ERR_CIPHER_ALGO;
664   ath_mutex_unlock (&ciphers_registered_lock);
665
666   /* check flags */
667   if ((! err)
668       && ((flags & ~(0 
669                      | GCRY_CIPHER_SECURE
670                      | GCRY_CIPHER_ENABLE_SYNC
671                      | GCRY_CIPHER_CBC_CTS
672                      | GCRY_CIPHER_CBC_MAC))
673           || (flags & GCRY_CIPHER_CBC_CTS & GCRY_CIPHER_CBC_MAC)))
674     err = GPG_ERR_CIPHER_ALGO;
675
676   /* check that a valid mode has been requested */
677   if (! err)
678     switch (mode)
679       {
680       case GCRY_CIPHER_MODE_ECB:
681       case GCRY_CIPHER_MODE_CBC:
682       case GCRY_CIPHER_MODE_CFB:
683       case GCRY_CIPHER_MODE_OFB:
684       case GCRY_CIPHER_MODE_CTR:
685         if ((cipher->encrypt == dummy_encrypt_block)
686             || (cipher->decrypt == dummy_decrypt_block))
687           err = GPG_ERR_INV_CIPHER_MODE;
688         break;
689
690       case GCRY_CIPHER_MODE_STREAM:
691         if ((cipher->stencrypt == dummy_encrypt_stream)
692             || (cipher->stdecrypt == dummy_decrypt_stream))
693           err = GPG_ERR_INV_CIPHER_MODE;
694         break;
695
696       case GCRY_CIPHER_MODE_NONE:
697         /* FIXME: issue a warning when this mode is used */
698         break;
699
700       default:
701         err = GPG_ERR_INV_CIPHER_MODE;
702       }
703
704   /* Perform selftest here and mark this with a flag in cipher_table?
705      No, we should not do this as it takes too long.  Further it does
706      not make sense to exclude algorithms with failing selftests at
707      runtime: If a selftest fails there is something seriously wrong
708      with the system and thus we better die immediately. */
709
710   if (! err)
711     {
712       size_t size = (sizeof (*h)
713                      + 2 * cipher->contextsize
714                      - sizeof (cipher_context_alignment_t)
715 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
716                      + 15  /* Space for leading alignment gap.  */
717 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
718                      );
719
720       if (secure)
721         h = gcry_calloc_secure (1, size);
722       else
723         h = gcry_calloc (1, size);
724
725       if (! h)
726         err = gpg_err_code_from_errno (errno);
727       else
728         {
729           size_t off = 0;
730
731 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
732           if ( ((unsigned long)h & 0x0f) )
733             {
734               /* The malloced block is not aligned on a 16 byte
735                  boundary.  Correct for this.  */
736               off = 16 - ((unsigned long)h & 0x0f);
737               h = (void*)((char*)h + off);
738             }
739 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
740
741           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
742           h->actual_handle_size = size - off;
743           h->handle_offset = off;
744           h->cipher = cipher;
745           h->module = module;
746           h->algo = algo;
747           h->mode = mode;
748           h->flags = flags;
749
750           /* Setup bulk encryption routines.  */
751           switch (algo)
752             {
753 #ifdef USE_AES
754             case GCRY_CIPHER_AES128:
755             case GCRY_CIPHER_AES192:
756             case GCRY_CIPHER_AES256:
757               h->bulk.cfb_enc = _gcry_aes_cfb_enc;
758               h->bulk.cfb_dec = _gcry_aes_cfb_dec;
759               h->bulk.cbc_enc = _gcry_aes_cbc_enc;
760               h->bulk.cbc_dec = _gcry_aes_cbc_dec;
761               break;
762 #endif /*USE_AES*/
763               
764             default:
765               break;
766             }
767         }
768     }
769
770   /* Done.  */
771
772   if (err)
773     {
774       if (module)
775         {
776           /* Release module.  */
777           ath_mutex_lock (&ciphers_registered_lock);
778           _gcry_module_release (module);
779           ath_mutex_unlock (&ciphers_registered_lock);
780         }
781     }
782
783   *handle = err ? NULL : h;
784
785   return gcry_error (err);
786 }
787
788
789 /* Release all resources associated with the cipher handle H. H may be
790    NULL in which case this is a no-operation. */
791 void
792 gcry_cipher_close (gcry_cipher_hd_t h)
793 {
794   size_t off;
795
796   if (! h)
797     return;
798
799   if ((h->magic != CTX_MAGIC_SECURE)
800       && (h->magic != CTX_MAGIC_NORMAL))
801     _gcry_fatal_error(GPG_ERR_INTERNAL,
802                       "gcry_cipher_close: already closed/invalid handle");
803   else
804     h->magic = 0;
805
806   /* Release module.  */
807   ath_mutex_lock (&ciphers_registered_lock);
808   _gcry_module_release (h->module);
809   ath_mutex_unlock (&ciphers_registered_lock);
810
811   /* We always want to wipe out the memory even when the context has
812      been allocated in secure memory.  The user might have disabled
813      secure memory or is using his own implementation which does not
814      do the wiping.  To accomplish this we need to keep track of the
815      actual size of this structure because we have no way to known
816      how large the allocated area was when using a standard malloc. */
817   off = h->handle_offset;
818   wipememory (h, h->actual_handle_size);
819
820   gcry_free ((char*)h - off);
821 }
822
823
824 /* Set the key to be used for the encryption context C to KEY with
825    length KEYLEN.  The length should match the required length. */
826 static gcry_error_t
827 cipher_setkey (gcry_cipher_hd_t c, byte *key, unsigned keylen)
828 {
829   gcry_err_code_t ret;
830
831   ret = (*c->cipher->setkey) (&c->context.c, key, keylen);
832   if (! ret)
833     /* Duplicate initial context.  */
834     memcpy ((void *) ((char *) &c->context.c + c->cipher->contextsize),
835             (void *) &c->context.c,
836             c->cipher->contextsize);
837
838   return gcry_error (ret);
839 }
840
841
842 /* Set the IV to be used for the encryption context C to IV with
843    length IVLEN.  The length should match the required length. */
844 static void
845 cipher_setiv( gcry_cipher_hd_t c, const byte *iv, unsigned ivlen )
846 {
847   memset (c->u_iv.iv, 0, c->cipher->blocksize);
848   if (iv) 
849     {
850       if (ivlen != c->cipher->blocksize)
851         log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
852                   ivlen, (unsigned int)c->cipher->blocksize);
853       if (ivlen > c->cipher->blocksize)
854         ivlen = c->cipher->blocksize;
855       memcpy (c->u_iv.iv, iv, ivlen);
856     }
857   c->unused = 0;
858 }
859
860
861 /* Reset the cipher context to the initial context.  This is basically
862    the same as an release followed by a new. */
863 static void
864 cipher_reset (gcry_cipher_hd_t c)
865 {
866   memcpy (&c->context.c,
867           (char *) &c->context.c + c->cipher->contextsize,
868           c->cipher->contextsize);
869   memset (c->u_iv.iv, 0, c->cipher->blocksize);
870   memset (c->lastiv, 0, c->cipher->blocksize);
871   memset (c->ctr, 0, c->cipher->blocksize);
872 }
873
874
875 static void
876 do_ecb_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
877                 unsigned int nblocks )
878 {
879     unsigned int n;
880
881     for(n=0; n < nblocks; n++ ) {
882         c->cipher->encrypt ( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
883         inbuf  += c->cipher->blocksize;
884         outbuf += c->cipher->blocksize;
885     }
886 }
887
888 static void
889 do_ecb_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
890                 unsigned int nblocks )
891 {
892     unsigned n;
893
894     for(n=0; n < nblocks; n++ ) {
895         c->cipher->decrypt ( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
896         inbuf  += c->cipher->blocksize;
897         outbuf += c->cipher->blocksize;
898     }
899 }
900
901
902 static void
903 do_cbc_encrypt (gcry_cipher_hd_t c, unsigned char *outbuf, 
904                 const unsigned char *inbuf, unsigned int nbytes )
905 {
906   unsigned int n;
907   unsigned char *ivp;
908   int i;
909   size_t blocksize = c->cipher->blocksize;
910   unsigned nblocks = nbytes / blocksize;
911
912   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) 
913     {
914       if ((nbytes % blocksize) == 0)
915         nblocks--;
916     }
917
918   if (c->bulk.cbc_enc)
919     {
920       c->bulk.cbc_enc (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks,
921                        (c->flags & GCRY_CIPHER_CBC_MAC)); 
922       inbuf  += nblocks * blocksize;
923       if (!(c->flags & GCRY_CIPHER_CBC_MAC))
924         outbuf += nblocks * blocksize;
925     }
926   else
927     {
928       for (n=0; n < nblocks; n++ )
929         {
930           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
931             outbuf[i] = inbuf[i] ^ *ivp++;
932           c->cipher->encrypt ( &c->context.c, outbuf, outbuf );
933           memcpy (c->u_iv.iv, outbuf, blocksize );
934           inbuf  += blocksize;
935           if (!(c->flags & GCRY_CIPHER_CBC_MAC))
936             outbuf += blocksize;
937         }
938     }
939
940   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize)
941     {
942       /* We have to be careful here, since outbuf might be equal to
943          inbuf.  */
944       int restbytes;
945       unsigned char b;
946
947       if ((nbytes % blocksize) == 0)
948         restbytes = blocksize;
949       else
950         restbytes = nbytes % blocksize;
951
952       outbuf -= blocksize;
953       for (ivp = c->u_iv.iv, i = 0; i < restbytes; i++)
954         {
955           b = inbuf[i];
956           outbuf[blocksize + i] = outbuf[i];
957           outbuf[i] = b ^ *ivp++;
958         }
959       for (; i < blocksize; i++)
960         outbuf[i] = 0 ^ *ivp++;
961       
962       c->cipher->encrypt (&c->context.c, outbuf, outbuf);
963       memcpy (c->u_iv.iv, outbuf, blocksize);
964     }
965 }
966
967
968 static void
969 do_cbc_decrypt (gcry_cipher_hd_t c, unsigned char *outbuf, 
970                 const unsigned char *inbuf, unsigned int nbytes)
971 {
972   unsigned int n;
973   unsigned char *ivp;
974   int i;
975   size_t blocksize = c->cipher->blocksize;
976   unsigned int nblocks = nbytes / blocksize;
977
978   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize)
979     {
980       nblocks--;
981       if ((nbytes % blocksize) == 0)
982         nblocks--;
983       memcpy (c->lastiv, c->u_iv.iv, blocksize);
984     }
985
986   if (c->bulk.cbc_dec)
987     {
988       c->bulk.cbc_dec (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
989       inbuf  += nblocks * blocksize;
990       outbuf += nblocks * blocksize;
991     }
992   else
993     {
994       for (n=0; n < nblocks; n++ ) 
995         {
996           /* Because outbuf and inbuf might be the same, we have to
997            * save the original ciphertext block.  We use lastiv for
998            * this here because it is not used otherwise. */
999           memcpy (c->lastiv, inbuf, blocksize);
1000           c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
1001           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1002             outbuf[i] ^= *ivp++;
1003           memcpy(c->u_iv.iv, c->lastiv, blocksize );
1004           inbuf  += c->cipher->blocksize;
1005           outbuf += c->cipher->blocksize;
1006         }
1007     }
1008
1009   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) 
1010     {
1011       int restbytes;
1012       
1013       if ((nbytes % blocksize) == 0)
1014         restbytes = blocksize;
1015       else
1016         restbytes = nbytes % blocksize;
1017       
1018       memcpy (c->lastiv, c->u_iv.iv, blocksize );         /* Save Cn-2. */
1019       memcpy (c->u_iv.iv, inbuf + blocksize, restbytes ); /* Save Cn. */
1020
1021       c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
1022       for (ivp=c->u_iv.iv,i=0; i < restbytes; i++ )
1023         outbuf[i] ^= *ivp++;
1024       
1025       memcpy(outbuf + blocksize, outbuf, restbytes);
1026       for(i=restbytes; i < blocksize; i++)
1027         c->u_iv.iv[i] = outbuf[i];
1028       c->cipher->decrypt (&c->context.c, outbuf, c->u_iv.iv);
1029       for(ivp=c->lastiv,i=0; i < blocksize; i++ )
1030         outbuf[i] ^= *ivp++;
1031       /* c->lastiv is now really lastlastiv, does this matter? */
1032     }
1033 }
1034
1035
1036 static void
1037 do_cfb_encrypt( gcry_cipher_hd_t c, unsigned char *outbuf, 
1038                 const unsigned char *inbuf, unsigned int nbytes )
1039 {
1040   unsigned char *ivp;
1041   size_t blocksize = c->cipher->blocksize;
1042   size_t blocksize_x_2 = blocksize + blocksize;
1043   
1044   if ( nbytes <= c->unused )
1045     {
1046       /* Short enough to be encoded by the remaining XOR mask. */
1047       /* XOR the input with the IV and store input into IV. */
1048       for (ivp=c->u_iv.iv+c->cipher->blocksize - c->unused;
1049            nbytes;
1050            nbytes--, c->unused-- )
1051         *outbuf++ = (*ivp++ ^= *inbuf++);
1052       return;
1053     }
1054
1055   if ( c->unused )
1056     {
1057       /* XOR the input with the IV and store input into IV */
1058       nbytes -= c->unused;
1059       for(ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1060         *outbuf++ = (*ivp++ ^= *inbuf++);
1061     }
1062
1063   /* Now we can process complete blocks.  We use a loop as long as we
1064      have at least 2 blocks and use conditions for the rest.  This
1065      also allows to use a bulk encryption function if available.  */
1066   if (nbytes >= blocksize_x_2 && c->bulk.cfb_enc)
1067     {
1068       unsigned int nblocks = nbytes / blocksize;
1069       c->bulk.cfb_enc (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1070       outbuf += nblocks * blocksize;
1071       inbuf  += nblocks * blocksize;
1072       nbytes -= nblocks * blocksize;
1073     }
1074   else
1075     {
1076       while ( nbytes >= blocksize_x_2 )
1077         {
1078           int i;
1079           /* Encrypt the IV. */
1080           c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1081           /* XOR the input with the IV and store input into IV.  */
1082           for(ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1083             *outbuf++ = (*ivp++ ^= *inbuf++);
1084           nbytes -= blocksize;
1085         }
1086     }
1087
1088   if ( nbytes >= blocksize )
1089     {
1090       int i;
1091       /* Save the current IV and then encrypt the IV. */
1092       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1093       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1094       /* XOR the input with the IV and store input into IV */
1095       for(ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1096         *outbuf++ = (*ivp++ ^= *inbuf++);
1097       nbytes -= blocksize;
1098     }
1099   if ( nbytes ) 
1100     {
1101       /* Save the current IV and then encrypt the IV. */
1102       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1103       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1104       c->unused = blocksize;
1105       /* Apply the XOR. */
1106       c->unused -= nbytes;
1107       for(ivp=c->u_iv.iv; nbytes; nbytes-- )
1108         *outbuf++ = (*ivp++ ^= *inbuf++);
1109     }
1110 }
1111
1112
1113 static void
1114 do_cfb_decrypt( gcry_cipher_hd_t c, unsigned char *outbuf, 
1115                 const unsigned char *inbuf, unsigned int nbytes )
1116 {
1117   unsigned char *ivp;
1118   unsigned long temp;
1119   int i;
1120   size_t blocksize = c->cipher->blocksize;
1121   size_t blocksize_x_2 = blocksize + blocksize;
1122   
1123   if (nbytes <= c->unused)
1124     {
1125       /* Short enough to be encoded by the remaining XOR mask. */
1126       /* XOR the input with the IV and store input into IV. */
1127       for (ivp=c->u_iv.iv+blocksize - c->unused;
1128            nbytes; 
1129            nbytes--, c->unused--)
1130         {
1131           temp = *inbuf++;
1132           *outbuf++ = *ivp ^ temp;
1133           *ivp++ = temp;
1134         }
1135       return;
1136     }
1137   
1138   if (c->unused)
1139     {
1140       /* XOR the input with the IV and store input into IV. */
1141       nbytes -= c->unused;
1142       for (ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1143         {
1144           temp = *inbuf++;
1145           *outbuf++ = *ivp ^ temp;
1146           *ivp++ = temp;
1147         }
1148     }
1149   
1150   /* Now we can process complete blocks.  We use a loop as long as we
1151      have at least 2 blocks and use conditions for the rest.  This
1152      also allows to use a bulk encryption function if available.  */
1153   if (nbytes >= blocksize_x_2 && c->bulk.cfb_dec)
1154     {
1155       unsigned int nblocks = nbytes / blocksize;
1156       c->bulk.cfb_dec (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1157       outbuf += nblocks * blocksize;
1158       inbuf  += nblocks * blocksize;
1159       nbytes -= nblocks * blocksize;
1160     }
1161   else
1162     {
1163       while (nbytes >= blocksize_x_2 )
1164         {
1165           /* Encrypt the IV. */
1166           c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1167           /* XOR the input with the IV and store input into IV. */
1168           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1169             {
1170               temp = *inbuf++;
1171               *outbuf++ = *ivp ^ temp;
1172               *ivp++ = temp;
1173             }
1174           nbytes -= blocksize;
1175         }
1176     }
1177
1178   if (nbytes >= blocksize )
1179     {
1180       /* Save the current IV and then encrypt the IV. */
1181       memcpy ( c->lastiv, c->u_iv.iv, blocksize);
1182       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1183       /* XOR the input with the IV and store input into IV */
1184       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1185         {
1186           temp = *inbuf++;
1187           *outbuf++ = *ivp ^ temp;
1188           *ivp++ = temp;
1189         }
1190       nbytes -= blocksize;
1191     }
1192
1193   if (nbytes)
1194     { 
1195       /* Save the current IV and then encrypt the IV. */
1196       memcpy ( c->lastiv, c->u_iv.iv, blocksize );
1197       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1198       c->unused = blocksize;
1199       /* Apply the XOR. */
1200       c->unused -= nbytes;
1201       for (ivp=c->u_iv.iv; nbytes; nbytes-- )
1202         {
1203           temp = *inbuf++;
1204           *outbuf++ = *ivp ^ temp;
1205           *ivp++ = temp;
1206         }
1207     }
1208 }
1209
1210
1211 static void
1212 do_ofb_encrypt( gcry_cipher_hd_t c,
1213                 byte *outbuf, const byte *inbuf, unsigned nbytes )
1214 {
1215   byte *ivp;
1216   size_t blocksize = c->cipher->blocksize;
1217
1218   if ( nbytes <= c->unused )
1219     {
1220       /* Short enough to be encoded by the remaining XOR mask. */
1221       /* XOR the input with the IV */
1222       for (ivp=c->u_iv.iv+c->cipher->blocksize - c->unused;
1223            nbytes;
1224            nbytes--, c->unused-- )
1225         *outbuf++ = (*ivp++ ^ *inbuf++);
1226       return;
1227     }
1228
1229   if( c->unused )
1230     {
1231       nbytes -= c->unused;
1232       for(ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1233         *outbuf++ = (*ivp++ ^ *inbuf++);
1234     }
1235
1236   /* Now we can process complete blocks. */
1237   while ( nbytes >= blocksize )
1238     {
1239       int i;
1240       /* Encrypt the IV (and save the current one). */
1241       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1242       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1243       
1244       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1245         *outbuf++ = (*ivp++ ^ *inbuf++);
1246       nbytes -= blocksize;
1247     }
1248   if ( nbytes )
1249     { /* process the remaining bytes */
1250       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1251       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1252       c->unused = blocksize;
1253       c->unused -= nbytes;
1254       for(ivp=c->u_iv.iv; nbytes; nbytes-- )
1255         *outbuf++ = (*ivp++ ^ *inbuf++);
1256     }
1257 }
1258
1259 static void
1260 do_ofb_decrypt( gcry_cipher_hd_t c,
1261                 byte *outbuf, const byte *inbuf, unsigned int nbytes )
1262 {
1263   byte *ivp;
1264   size_t blocksize = c->cipher->blocksize;
1265   
1266   if( nbytes <= c->unused )
1267     {
1268       /* Short enough to be encoded by the remaining XOR mask. */
1269       for (ivp=c->u_iv.iv+blocksize - c->unused; nbytes; nbytes--,c->unused--)
1270         *outbuf++ = *ivp++ ^ *inbuf++;
1271       return;
1272     }
1273
1274   if ( c->unused )
1275     {
1276       nbytes -= c->unused;
1277       for (ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1278         *outbuf++ = *ivp++ ^ *inbuf++;
1279     }
1280
1281   /* Now we can process complete blocks. */
1282   while ( nbytes >= blocksize )
1283     {
1284       int i;
1285       /* Encrypt the IV (and save the current one). */
1286       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1287       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1288       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1289         *outbuf++ = *ivp++ ^ *inbuf++;
1290       nbytes -= blocksize;
1291     }
1292   if ( nbytes ) 
1293     { /* Process the remaining bytes. */
1294       /* Encrypt the IV (and save the current one). */
1295       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1296       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1297       c->unused = blocksize;
1298       c->unused -= nbytes;
1299       for (ivp=c->u_iv.iv; nbytes; nbytes-- )
1300         *outbuf++ = *ivp++ ^ *inbuf++;
1301     }
1302 }
1303
1304
1305 static void
1306 do_ctr_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1307                 unsigned int nbytes )
1308 {
1309   unsigned int n;
1310   byte tmp[MAX_BLOCKSIZE];
1311   int i;
1312
1313   for(n=0; n < nbytes; n++)
1314     {
1315       if ((n % c->cipher->blocksize) == 0)
1316         {
1317           c->cipher->encrypt (&c->context.c, tmp, c->ctr);
1318
1319           for (i = c->cipher->blocksize; i > 0; i--)
1320             {
1321               c->ctr[i-1]++;
1322               if (c->ctr[i-1] != 0)
1323                 break;
1324             }
1325         }
1326
1327       /* XOR input with encrypted counter and store in output. */
1328       outbuf[n] = inbuf[n] ^ tmp[n % c->cipher->blocksize];
1329     }
1330 }
1331
1332 static void
1333 do_ctr_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1334                 unsigned int nbytes )
1335 {
1336   do_ctr_encrypt (c, outbuf, inbuf, nbytes);
1337 }
1338
1339
1340 /****************
1341  * Encrypt INBUF to OUTBUF with the mode selected at open.
1342  * inbuf and outbuf may overlap or be the same.
1343  * Depending on the mode some contraints apply to NBYTES.
1344  */
1345 static gcry_err_code_t
1346 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf,
1347                 const byte *inbuf, unsigned int nbytes)
1348 {
1349     gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1350
1351     switch( c->mode ) {
1352       case GCRY_CIPHER_MODE_ECB:
1353         if (!(nbytes%c->cipher->blocksize))
1354             do_ecb_encrypt(c, outbuf, inbuf, nbytes/c->cipher->blocksize );
1355         else 
1356             rc = GPG_ERR_INV_ARG;
1357         break;
1358       case GCRY_CIPHER_MODE_CBC:
1359         if (!(nbytes%c->cipher->blocksize)
1360             || (nbytes > c->cipher->blocksize
1361                 && (c->flags & GCRY_CIPHER_CBC_CTS)))
1362             do_cbc_encrypt(c, outbuf, inbuf, nbytes );
1363         else 
1364             rc = GPG_ERR_INV_ARG;
1365         break;
1366       case GCRY_CIPHER_MODE_CFB:
1367         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
1368         break;
1369       case GCRY_CIPHER_MODE_OFB:
1370         do_ofb_encrypt(c, outbuf, inbuf, nbytes );
1371         break;
1372       case GCRY_CIPHER_MODE_CTR:
1373         do_ctr_encrypt(c, outbuf, inbuf, nbytes );
1374         break;
1375       case GCRY_CIPHER_MODE_STREAM:
1376         c->cipher->stencrypt ( &c->context.c,
1377                                outbuf, (byte*)/*arggg*/inbuf, nbytes );
1378         break;
1379       case GCRY_CIPHER_MODE_NONE:
1380         if( inbuf != outbuf )
1381             memmove( outbuf, inbuf, nbytes );
1382         break;
1383       default:
1384         log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
1385         rc = GPG_ERR_INV_CIPHER_MODE;
1386         break;
1387     }
1388     return rc;
1389 }
1390
1391
1392 /****************
1393  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
1394  * been requested.
1395  */
1396 gcry_error_t
1397 gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1398                      const void *in, size_t inlen)
1399 {
1400   gcry_err_code_t err;
1401
1402   if (!in)
1403     /* Caller requested in-place encryption. */
1404     /* Actually cipher_encrypt() does not need to know about it, but
1405      * we may change it in the future to get better performance.  */
1406     err = cipher_encrypt (h, out, out, outsize);
1407   else if (outsize < ((h->flags & GCRY_CIPHER_CBC_MAC) ?
1408                       h->cipher->blocksize : inlen))
1409     err = GPG_ERR_TOO_SHORT;
1410   else if ((h->mode == GCRY_CIPHER_MODE_ECB
1411             || (h->mode == GCRY_CIPHER_MODE_CBC
1412                 && (! ((h->flags & GCRY_CIPHER_CBC_CTS)
1413                        && (inlen > h->cipher->blocksize)))))
1414            && (inlen % h->cipher->blocksize))
1415     err = GPG_ERR_INV_ARG;
1416   else
1417     err = cipher_encrypt (h, out, in, inlen);
1418
1419   if (err && out)
1420     memset (out, 0x42, outsize); /* Failsafe: Make sure that the
1421                                     plaintext will never make it into
1422                                     OUT. */
1423
1424   return gcry_error (err);
1425 }
1426
1427
1428
1429 /****************
1430  * Decrypt INBUF to OUTBUF with the mode selected at open.
1431  * inbuf and outbuf may overlap or be the same.
1432  * Depending on the mode some some contraints apply to NBYTES.
1433  */
1434 static gcry_err_code_t
1435 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1436                 unsigned int nbytes)
1437 {
1438     gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1439
1440     switch( c->mode ) {
1441       case GCRY_CIPHER_MODE_ECB:
1442         if (!(nbytes%c->cipher->blocksize))
1443             do_ecb_decrypt(c, outbuf, inbuf, nbytes/c->cipher->blocksize );
1444         else 
1445             rc = GPG_ERR_INV_ARG;
1446         break;
1447       case GCRY_CIPHER_MODE_CBC:
1448         if (!(nbytes%c->cipher->blocksize)
1449             || (nbytes > c->cipher->blocksize
1450                 && (c->flags & GCRY_CIPHER_CBC_CTS)))
1451             do_cbc_decrypt(c, outbuf, inbuf, nbytes );
1452         else 
1453             rc = GPG_ERR_INV_ARG;
1454         break;
1455       case GCRY_CIPHER_MODE_CFB:
1456         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
1457         break;
1458       case GCRY_CIPHER_MODE_OFB:
1459         do_ofb_decrypt(c, outbuf, inbuf, nbytes );
1460         break;
1461       case GCRY_CIPHER_MODE_CTR:
1462         do_ctr_decrypt(c, outbuf, inbuf, nbytes );
1463         break;
1464       case GCRY_CIPHER_MODE_STREAM:
1465         c->cipher->stdecrypt ( &c->context.c,
1466                                outbuf, (byte*)/*arggg*/inbuf, nbytes );
1467         break;
1468       case GCRY_CIPHER_MODE_NONE:
1469         if( inbuf != outbuf )
1470             memmove( outbuf, inbuf, nbytes );
1471         break;
1472       default:
1473         log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1474         rc = GPG_ERR_INV_CIPHER_MODE;
1475         break;
1476     }
1477     return rc;
1478 }
1479
1480
1481 gcry_error_t
1482 gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1483                      const void *in, size_t inlen)
1484 {
1485   gcry_err_code_t err = 0;
1486
1487   if (!in)
1488     /* Caller requested in-place encryption. */
1489     /* Actually cipher_encrypt() does not need to know about it, but
1490      * we may change it in the future to get better performance.  */
1491     err = cipher_decrypt (h, out, out, outsize);
1492   else if (outsize < inlen)
1493     err = GPG_ERR_TOO_SHORT;
1494   else if (((h->mode == GCRY_CIPHER_MODE_ECB)
1495             || ((h->mode == GCRY_CIPHER_MODE_CBC)
1496                 && (! ((h->flags & GCRY_CIPHER_CBC_CTS)
1497                        && (inlen > h->cipher->blocksize)))))
1498            && (inlen % h->cipher->blocksize) != 0)
1499     err = GPG_ERR_INV_ARG;
1500   else
1501     err = cipher_decrypt (h, out, in, inlen);
1502
1503   return gcry_error (err);
1504 }
1505
1506
1507
1508 /****************
1509  * Used for PGP's somewhat strange CFB mode. Only works if
1510  * the corresponding flag is set.
1511  */
1512 static void
1513 cipher_sync( gcry_cipher_hd_t c )
1514 {
1515   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1516     {
1517       memmove (c->u_iv.iv + c->unused,
1518                c->u_iv.iv, c->cipher->blocksize - c->unused);
1519       memcpy (c->u_iv.iv,
1520               c->lastiv + c->cipher->blocksize - c->unused, c->unused);
1521       c->unused = 0;
1522     }
1523 }
1524
1525
1526 gcry_error_t
1527 gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1528 {
1529   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1530
1531   switch (cmd)
1532     {
1533     case GCRYCTL_SET_KEY:
1534       rc = cipher_setkey( h, buffer, buflen );
1535       break;
1536     case GCRYCTL_SET_IV:
1537       cipher_setiv( h, buffer, buflen );
1538       break;
1539     case GCRYCTL_RESET:
1540       cipher_reset (h);
1541       break;
1542     case GCRYCTL_CFB_SYNC:
1543       cipher_sync( h );
1544       break;
1545     case GCRYCTL_SET_CBC_CTS:
1546       if (buflen)
1547         if (h->flags & GCRY_CIPHER_CBC_MAC)
1548           rc = GPG_ERR_INV_FLAG;
1549         else
1550           h->flags |= GCRY_CIPHER_CBC_CTS;
1551       else
1552         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1553       break;
1554     case GCRYCTL_SET_CBC_MAC:
1555       if (buflen)
1556         if (h->flags & GCRY_CIPHER_CBC_CTS)
1557           rc = GPG_ERR_INV_FLAG;
1558         else
1559           h->flags |= GCRY_CIPHER_CBC_MAC;
1560       else
1561         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1562       break;
1563     case GCRYCTL_DISABLE_ALGO:
1564       /* this one expects a NULL handle and buffer pointing to an
1565        * integer with the algo number.
1566        */
1567       if( h || !buffer || buflen != sizeof(int) )
1568         return gcry_error (GPG_ERR_CIPHER_ALGO);
1569       disable_cipher_algo( *(int*)buffer );
1570       break;
1571     case GCRYCTL_SET_CTR:
1572       if (buffer && buflen == h->cipher->blocksize)
1573         memcpy (h->ctr, buffer, h->cipher->blocksize);
1574       else if (buffer == NULL || buflen == 0)
1575         memset (h->ctr, 0, h->cipher->blocksize);
1576       else
1577         rc = GPG_ERR_INV_ARG;
1578       break;
1579
1580     default:
1581       rc = GPG_ERR_INV_OP;
1582     }
1583
1584   return gcry_error (rc);
1585 }
1586
1587
1588 /****************
1589  * Return information about the cipher handle.
1590  */
1591 gcry_error_t
1592 gcry_cipher_info( gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1593 {
1594   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1595
1596   (void)h;
1597   (void)buffer;
1598   (void)nbytes;
1599
1600   switch (cmd)
1601     {
1602     default:
1603       err = GPG_ERR_INV_OP;
1604     }
1605
1606   return gcry_error (err);
1607 }
1608
1609 /****************
1610  * Return information about the given cipher algorithm
1611  * WHAT select the kind of information returned:
1612  *  GCRYCTL_GET_KEYLEN:
1613  *      Return the length of the key, if the algorithm
1614  *      supports multiple key length, the maximum supported value
1615  *      is returnd.  The length is return as number of octets.
1616  *      buffer and nbytes must be zero.
1617  *      The keylength is returned in _bytes_.
1618  *  GCRYCTL_GET_BLKLEN:
1619  *      Return the blocklength of the algorithm counted in octets.
1620  *      buffer and nbytes must be zero.
1621  *  GCRYCTL_TEST_ALGO:
1622  *      Returns 0 when the specified algorithm is available for use.
1623  *      buffer and nbytes must be zero.
1624  *
1625  * Note:  Because this function is in most cases used to return an
1626  * integer value, we can make it easier for the caller to just look at
1627  * the return value.  The caller will in all cases consult the value
1628  * and thereby detecting whether a error occured or not (i.e. while checking
1629  * the block size)
1630  */
1631 gcry_error_t
1632 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1633 {
1634   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1635   unsigned int ui;
1636
1637   switch (what)
1638     {
1639     case GCRYCTL_GET_KEYLEN:
1640       if (buffer || (! nbytes))
1641         err = GPG_ERR_CIPHER_ALGO;
1642       else
1643         {
1644           ui = cipher_get_keylen (algo);
1645           if ((ui > 0) && (ui <= 512))
1646             *nbytes = (size_t) ui / 8;
1647           else
1648             /* The only reason is an invalid algo or a strange
1649                blocksize.  */
1650             err = GPG_ERR_CIPHER_ALGO;
1651         }
1652       break;
1653
1654     case GCRYCTL_GET_BLKLEN:
1655       if (buffer || (! nbytes))
1656         err = GPG_ERR_CIPHER_ALGO;
1657       else
1658         {
1659           ui = cipher_get_blocksize (algo);
1660           if ((ui > 0) && (ui < 10000))
1661             *nbytes = ui;
1662           else
1663             /* The only reason is an invalid algo or a strange
1664                blocksize.  */
1665             err = GPG_ERR_CIPHER_ALGO;
1666         }
1667       break;
1668
1669     case GCRYCTL_TEST_ALGO:
1670       if (buffer || nbytes)
1671         err = GPG_ERR_INV_ARG;
1672       else
1673         err = check_cipher_algo (algo);
1674       break;
1675
1676       default:
1677         err = GPG_ERR_INV_OP;
1678     }
1679
1680   return gcry_error (err);
1681 }
1682
1683
1684 size_t
1685 gcry_cipher_get_algo_keylen (int algo) 
1686 {
1687   size_t n;
1688
1689   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1690     n = 0;
1691   return n;
1692 }
1693
1694
1695 size_t
1696 gcry_cipher_get_algo_blklen (int algo) 
1697 {
1698   size_t n;
1699
1700   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1701     n = 0;
1702   return n;
1703 }
1704
1705
1706 gcry_err_code_t
1707 _gcry_cipher_init (void)
1708 {
1709   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1710
1711   REGISTER_DEFAULT_CIPHERS;
1712
1713   return err;
1714 }
1715
1716 /* Get a list consisting of the IDs of the loaded cipher modules.  If
1717    LIST is zero, write the number of loaded cipher modules to
1718    LIST_LENGTH and return.  If LIST is non-zero, the first
1719    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
1720    according size.  In case there are less cipher modules than
1721    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
1722 gcry_error_t
1723 gcry_cipher_list (int *list, int *list_length)
1724 {
1725   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1726
1727   ath_mutex_lock (&ciphers_registered_lock);
1728   err = _gcry_module_list (ciphers_registered, list, list_length);
1729   ath_mutex_unlock (&ciphers_registered_lock);
1730
1731   return err;
1732 }