Implemented the AES-Wrap algorithm
[libgcrypt.git] / cipher / cipher.c
1 /* cipher.c  -  cipher dispatcher
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *               2005, 2007, 2008 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 /* A dummy extraspec so that we do not need to tests the extraspec
42    field from the module specification against NULL and instead
43    directly test the respective fields of extraspecs.  */
44 static cipher_extra_spec_t dummy_extra_spec;
45
46 /* This is the list of the default ciphers, which are included in
47    libgcrypt.  */
48 static struct cipher_table_entry
49 {
50   gcry_cipher_spec_t *cipher;
51   cipher_extra_spec_t *extraspec;
52   unsigned int algorithm;
53   int fips_allowed;
54 } cipher_table[] =
55   {
56 #if USE_BLOWFISH
57     { &_gcry_cipher_spec_blowfish,
58       &dummy_extra_spec,                  GCRY_CIPHER_BLOWFISH },
59 #endif
60 #if USE_DES
61     { &_gcry_cipher_spec_des,       
62       &dummy_extra_spec,                  GCRY_CIPHER_DES },
63     { &_gcry_cipher_spec_tripledes,
64       &_gcry_cipher_extraspec_tripledes,  GCRY_CIPHER_3DES, 1 },
65 #endif
66 #if USE_ARCFOUR
67     { &_gcry_cipher_spec_arcfour,    
68       &dummy_extra_spec,                  GCRY_CIPHER_ARCFOUR },
69 #endif
70 #if USE_CAST5
71     { &_gcry_cipher_spec_cast5,      
72       &dummy_extra_spec,                  GCRY_CIPHER_CAST5 },
73 #endif
74 #if USE_AES
75     { &_gcry_cipher_spec_aes,        
76       &_gcry_cipher_extraspec_aes,        GCRY_CIPHER_AES,    1 },
77     { &_gcry_cipher_spec_aes192,     
78       &_gcry_cipher_extraspec_aes192,     GCRY_CIPHER_AES192, 1 },
79     { &_gcry_cipher_spec_aes256,     
80       &_gcry_cipher_extraspec_aes256,     GCRY_CIPHER_AES256, 1 },
81 #endif
82 #if USE_TWOFISH
83     { &_gcry_cipher_spec_twofish,
84       &dummy_extra_spec,                  GCRY_CIPHER_TWOFISH },
85     { &_gcry_cipher_spec_twofish128,     
86       &dummy_extra_spec,                  GCRY_CIPHER_TWOFISH128 },
87 #endif
88 #if USE_SERPENT
89     { &_gcry_cipher_spec_serpent128, 
90       &dummy_extra_spec,                  GCRY_CIPHER_SERPENT128 },
91     { &_gcry_cipher_spec_serpent192,
92       &dummy_extra_spec,                  GCRY_CIPHER_SERPENT192 },
93     { &_gcry_cipher_spec_serpent256, 
94       &dummy_extra_spec,                  GCRY_CIPHER_SERPENT256 },
95 #endif
96 #if USE_RFC2268
97     { &_gcry_cipher_spec_rfc2268_40,
98       &dummy_extra_spec,                  GCRY_CIPHER_RFC2268_40 },
99 #endif
100 #if USE_SEED
101     { &_gcry_cipher_spec_seed, 
102       &dummy_extra_spec,                  GCRY_CIPHER_SEED },
103 #endif
104 #if USE_CAMELLIA
105     { &_gcry_cipher_spec_camellia128,
106       &dummy_extra_spec,                  GCRY_CIPHER_CAMELLIA128 },
107     { &_gcry_cipher_spec_camellia192, 
108       &dummy_extra_spec,                  GCRY_CIPHER_CAMELLIA192 },
109     { &_gcry_cipher_spec_camellia256,
110       &dummy_extra_spec,                  GCRY_CIPHER_CAMELLIA256 },
111 #endif
112     { NULL                    }
113   };
114
115 /* List of registered ciphers.  */
116 static gcry_module_t ciphers_registered;
117
118 /* This is the lock protecting CIPHERS_REGISTERED.  */
119 static ath_mutex_t ciphers_registered_lock = ATH_MUTEX_INITIALIZER;
120
121 /* Flag to check wether the default ciphers have already been
122    registered.  */
123 static int default_ciphers_registered;
124
125 /* Convenient macro for registering the default ciphers.  */
126 #define REGISTER_DEFAULT_CIPHERS                   \
127   do                                               \
128     {                                              \
129       ath_mutex_lock (&ciphers_registered_lock);   \
130       if (! default_ciphers_registered)            \
131         {                                          \
132           cipher_register_default ();              \
133           default_ciphers_registered = 1;          \
134         }                                          \
135       ath_mutex_unlock (&ciphers_registered_lock); \
136     }                                              \
137   while (0)
138
139
140 /* A VIA processor with the Padlock engine requires an alignment of
141    most data on a 16 byte boundary.  Because we trick out the compiler
142    while allocating the context, the align attribute as used in
143    rijndael.c does not work on its own.  Thus we need to make sure
144    that the entire context structure is a aligned on that boundary.
145    We achieve this by defining a new type and use that instead of our
146    usual alignment type.  */
147 typedef union 
148 {
149   PROPERLY_ALIGNED_TYPE foo;
150 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
151   char bar[16] __attribute__ ((aligned (16)));
152 #endif  
153   char c[1];
154 } cipher_context_alignment_t;
155
156
157 /* The handle structure.  */
158 struct gcry_cipher_handle
159 {
160   int magic;
161   size_t actual_handle_size;     /* Allocated size of this handle. */
162   size_t handle_offset;          /* Offset to the malloced block.  */
163   gcry_cipher_spec_t *cipher;
164   cipher_extra_spec_t *extraspec;
165   gcry_module_t module;
166
167   /* The algorithm id.  This is a hack required because the module
168      interface does not easily allow to retrieve this value. */
169   int algo;  
170
171   /* A structure with function pointers for bulk operations.  Due to
172      limitations of the module system (we don't want to change the
173      API) we need to keep these function pointers here.  The cipher
174      open function intializes them and the actual encryption routines
175      use them if they are not NULL.  */
176   struct {
177     void (*cfb_enc)(void *context, unsigned char *iv, 
178                     void *outbuf_arg, const void *inbuf_arg,
179                     unsigned int nblocks);
180     void (*cfb_dec)(void *context, unsigned char *iv, 
181                     void *outbuf_arg, const void *inbuf_arg,
182                     unsigned int nblocks);
183     void (*cbc_enc)(void *context, unsigned char *iv, 
184                     void *outbuf_arg, const void *inbuf_arg,
185                     unsigned int nblocks, int cbc_mac);
186     void (*cbc_dec)(void *context, unsigned char *iv, 
187                     void *outbuf_arg, const void *inbuf_arg,
188                     unsigned int nblocks);
189   } bulk;
190
191
192   int mode;
193   unsigned int flags;
194
195   struct {
196     unsigned int key:1; /* Set to 1 if a key has been set.  */
197     unsigned int iv:1;  /* Set to 1 if ae IV has been set.  */
198   } marks;
199
200   /* The initialization vector.  To help code optimization we make
201      sure that it is aligned on an unsigned long and u32 boundary.  */
202   union {
203     unsigned long dummy_iv;         
204     u32 dummy_u32_iv;
205     unsigned char iv[MAX_BLOCKSIZE];    
206   } u_iv;
207
208   unsigned char lastiv[MAX_BLOCKSIZE];
209   int unused;  /* Number of unused bytes in the IV. */
210
211   unsigned char ctr[MAX_BLOCKSIZE];     /* For Counter (CTR) mode. */
212
213
214   /* What follows are two contexts of the cipher in use.  The first
215      one needs to be aligned well enough for the cipher operation
216      whereas the second one is a copy created by cipher_setkey and
217      used by cipher_reset.  That second copy has no need for proper
218      aligment because it is only accessed by memcpy.  */
219   cipher_context_alignment_t context;
220 };
221
222
223 \f
224 /* These dummy functions are used in case a cipher implementation
225    refuses to provide it's own functions.  */
226
227 static gcry_err_code_t
228 dummy_setkey (void *c, const unsigned char *key, unsigned int keylen)
229 {
230   (void)c; 
231   (void)key;
232   (void)keylen;
233   return GPG_ERR_NO_ERROR;
234 }
235
236 static void
237 dummy_encrypt_block (void *c,
238                      unsigned char *outbuf, const unsigned char *inbuf)
239 {
240   (void)c;
241   (void)outbuf;
242   (void)inbuf;
243   BUG();
244 }
245
246 static void
247 dummy_decrypt_block (void *c,
248                      unsigned char *outbuf, const unsigned char *inbuf)
249 {
250   (void)c;
251   (void)outbuf;
252   (void)inbuf;
253   BUG();
254 }
255
256 static void
257 dummy_encrypt_stream (void *c,
258                       unsigned char *outbuf, const unsigned char *inbuf,
259                       unsigned int n)
260 {
261   (void)c;
262   (void)outbuf;
263   (void)inbuf;
264   (void)n;
265   BUG();
266 }
267
268 static void
269 dummy_decrypt_stream (void *c,
270                       unsigned char *outbuf, const unsigned char *inbuf,
271                       unsigned int n)
272 {
273   (void)c;
274   (void)outbuf;
275   (void)inbuf;
276   (void)n;
277   BUG();
278 }
279
280 \f
281 /* Internal function.  Register all the ciphers included in
282    CIPHER_TABLE.  Note, that this function gets only used by the macro
283    REGISTER_DEFAULT_CIPHERS which protects it using a mutex. */
284 static void
285 cipher_register_default (void)
286 {
287   gcry_err_code_t err = GPG_ERR_NO_ERROR;
288   int i;
289   
290   for (i = 0; !err && cipher_table[i].cipher; i++)
291     {
292       if (! cipher_table[i].cipher->setkey)
293         cipher_table[i].cipher->setkey = dummy_setkey;
294       if (! cipher_table[i].cipher->encrypt)
295         cipher_table[i].cipher->encrypt = dummy_encrypt_block;
296       if (! cipher_table[i].cipher->decrypt)
297         cipher_table[i].cipher->decrypt = dummy_decrypt_block;
298       if (! cipher_table[i].cipher->stencrypt)
299         cipher_table[i].cipher->stencrypt = dummy_encrypt_stream;
300       if (! cipher_table[i].cipher->stdecrypt)
301         cipher_table[i].cipher->stdecrypt = dummy_decrypt_stream;
302
303       if ( fips_mode () && !cipher_table[i].fips_allowed )
304         continue;
305
306       err = _gcry_module_add (&ciphers_registered,
307                               cipher_table[i].algorithm,
308                               (void *) cipher_table[i].cipher,
309                               (void *) cipher_table[i].extraspec,
310                               NULL);
311     }
312
313   if (err)
314     BUG ();
315 }
316
317 /* Internal callback function.  Used via _gcry_module_lookup.  */
318 static int
319 gcry_cipher_lookup_func_name (void *spec, void *data)
320 {
321   gcry_cipher_spec_t *cipher = (gcry_cipher_spec_t *) spec;
322   char *name = (char *) data;
323   const char **aliases = cipher->aliases;
324   int i, ret = ! stricmp (name, cipher->name);
325
326   if (aliases)
327     for (i = 0; aliases[i] && (! ret); i++)
328       ret = ! stricmp (name, aliases[i]);
329
330   return ret;
331 }
332
333 /* Internal callback function.  Used via _gcry_module_lookup.  */
334 static int
335 gcry_cipher_lookup_func_oid (void *spec, void *data)
336 {
337   gcry_cipher_spec_t *cipher = (gcry_cipher_spec_t *) spec;
338   char *oid = (char *) data;
339   gcry_cipher_oid_spec_t *oid_specs = cipher->oids;
340   int ret = 0, i;
341
342   if (oid_specs)
343     for (i = 0; oid_specs[i].oid && (! ret); i++)
344       if (! stricmp (oid, oid_specs[i].oid))
345         ret = 1;
346
347   return ret;
348 }
349
350 /* Internal function.  Lookup a cipher entry by it's name.  */
351 static gcry_module_t
352 gcry_cipher_lookup_name (const char *name)
353 {
354   gcry_module_t cipher;
355
356   cipher = _gcry_module_lookup (ciphers_registered, (void *) name,
357                                 gcry_cipher_lookup_func_name);
358
359   return cipher;
360 }
361
362 /* Internal function.  Lookup a cipher entry by it's oid.  */
363 static gcry_module_t
364 gcry_cipher_lookup_oid (const char *oid)
365 {
366   gcry_module_t cipher;
367
368   cipher = _gcry_module_lookup (ciphers_registered, (void *) oid,
369                                 gcry_cipher_lookup_func_oid);
370
371   return cipher;
372 }
373
374 /* Register a new cipher module whose specification can be found in
375    CIPHER.  On success, a new algorithm ID is stored in ALGORITHM_ID
376    and a pointer representhing this module is stored in MODULE.  */
377 gcry_error_t
378 _gcry_cipher_register (gcry_cipher_spec_t *cipher,
379                        cipher_extra_spec_t *extraspec,
380                        int *algorithm_id,
381                        gcry_module_t *module)
382 {
383   gcry_err_code_t err = 0;
384   gcry_module_t mod;
385
386   /* We do not support module loading in fips mode.  */
387   if (fips_mode ())
388     return gpg_error (GPG_ERR_NOT_SUPPORTED);
389
390   ath_mutex_lock (&ciphers_registered_lock);
391   err = _gcry_module_add (&ciphers_registered, 0,
392                           (void *)cipher, 
393                           (void *)(extraspec? extraspec : &dummy_extra_spec), 
394                           &mod);
395   ath_mutex_unlock (&ciphers_registered_lock);
396
397   if (! err)
398     {
399       *module = mod;
400       *algorithm_id = mod->mod_id;
401     }
402
403   return gcry_error (err);
404 }
405
406 /* Unregister the cipher identified by MODULE, which must have been
407    registered with gcry_cipher_register.  */
408 void
409 gcry_cipher_unregister (gcry_module_t module)
410 {
411   ath_mutex_lock (&ciphers_registered_lock);
412   _gcry_module_release (module);
413   ath_mutex_unlock (&ciphers_registered_lock);
414 }
415
416 /* Locate the OID in the oid table and return the index or -1 when not
417    found.  An opitonal "oid." or "OID." prefix in OID is ignored, the
418    OID is expected to be in standard IETF dotted notation.  The
419    internal algorithm number is returned in ALGORITHM unless it
420    ispassed as NULL.  A pointer to the specification of the module
421    implementing this algorithm is return in OID_SPEC unless passed as
422    NULL.*/
423 static int 
424 search_oid (const char *oid, int *algorithm, gcry_cipher_oid_spec_t *oid_spec)
425 {
426   gcry_module_t module;
427   int ret = 0;
428
429   if (oid && ((! strncmp (oid, "oid.", 4))
430               || (! strncmp (oid, "OID.", 4))))
431     oid += 4;
432
433   module = gcry_cipher_lookup_oid (oid);
434   if (module)
435     {
436       gcry_cipher_spec_t *cipher = module->spec;
437       int i;
438
439       for (i = 0; cipher->oids[i].oid && !ret; i++)
440         if (! stricmp (oid, cipher->oids[i].oid))
441           {
442             if (algorithm)
443               *algorithm = module->mod_id;
444             if (oid_spec)
445               *oid_spec = cipher->oids[i];
446             ret = 1;
447           }
448       _gcry_module_release (module);
449     }
450
451   return ret;
452 }
453
454 /* Map STRING to the cipher algorithm identifier.  Returns the
455    algorithm ID of the cipher for the given name or 0 if the name is
456    not known.  It is valid to pass NULL for STRING which results in a
457    return value of 0. */
458 int
459 gcry_cipher_map_name (const char *string)
460 {
461   gcry_module_t cipher;
462   int ret, algorithm = 0;
463
464   if (! string)
465     return 0;
466
467   REGISTER_DEFAULT_CIPHERS;
468
469   /* If the string starts with a digit (optionally prefixed with
470      either "OID." or "oid."), we first look into our table of ASN.1
471      object identifiers to figure out the algorithm */
472
473   ath_mutex_lock (&ciphers_registered_lock);
474
475   ret = search_oid (string, &algorithm, NULL);
476   if (! ret)
477     {
478       cipher = gcry_cipher_lookup_name (string);
479       if (cipher)
480         {
481           algorithm = cipher->mod_id;
482           _gcry_module_release (cipher);
483         }
484     }
485
486   ath_mutex_unlock (&ciphers_registered_lock);
487   
488   return algorithm;
489 }
490
491
492 /* Given a STRING with an OID in dotted decimal notation, this
493    function returns the cipher mode (GCRY_CIPHER_MODE_*) associated
494    with that OID or 0 if no mode is known.  Passing NULL for string
495    yields a return value of 0. */
496 int
497 gcry_cipher_mode_from_oid (const char *string)
498 {
499   gcry_cipher_oid_spec_t oid_spec;
500   int ret = 0, mode = 0;
501
502   if (!string)
503     return 0;
504
505   ath_mutex_lock (&ciphers_registered_lock);
506   ret = search_oid (string, NULL, &oid_spec);
507   if (ret)
508     mode = oid_spec.mode;
509   ath_mutex_unlock (&ciphers_registered_lock);
510
511   return mode;
512 }
513
514
515 /* Map the cipher algorithm whose ID is contained in ALGORITHM to a
516    string representation of the algorithm name.  For unknown algorithm
517    IDs this function returns "?".  */
518 static const char *
519 cipher_algo_to_string (int algorithm)
520 {
521   gcry_module_t cipher;
522   const char *name;
523
524   REGISTER_DEFAULT_CIPHERS;
525
526   ath_mutex_lock (&ciphers_registered_lock);
527   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
528   if (cipher)
529     {
530       name = ((gcry_cipher_spec_t *) cipher->spec)->name;
531       _gcry_module_release (cipher);
532     }
533   else
534     name = "?";
535   ath_mutex_unlock (&ciphers_registered_lock);
536
537   return name;
538 }
539
540 /* Map the cipher algorithm identifier ALGORITHM to a string
541    representing this algorithm.  This string is the default name as
542    used by Libgcrypt.  An pointer to an empty string is returned for
543    an unknown algorithm.  NULL is never returned. */
544 const char *
545 gcry_cipher_algo_name (int algorithm)
546 {
547   return cipher_algo_to_string (algorithm);
548 }
549
550
551 /* Flag the cipher algorithm with the identifier ALGORITHM as
552    disabled.  There is no error return, the function does nothing for
553    unknown algorithms.  Disabled algorithms are vitually not available
554    in Libgcrypt. */
555 static void
556 disable_cipher_algo (int algorithm)
557 {
558   gcry_module_t cipher;
559
560   REGISTER_DEFAULT_CIPHERS;
561
562   ath_mutex_lock (&ciphers_registered_lock);
563   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
564   if (cipher)
565     {
566       if (! (cipher->flags & FLAG_MODULE_DISABLED))
567         cipher->flags |= FLAG_MODULE_DISABLED;
568       _gcry_module_release (cipher);
569     }
570   ath_mutex_unlock (&ciphers_registered_lock);
571 }
572
573
574 /* Return 0 if the cipher algorithm with identifier ALGORITHM is
575    available. Returns a basic error code value if it is not
576    available.  */
577 static gcry_err_code_t
578 check_cipher_algo (int algorithm)
579 {
580   gcry_err_code_t err = GPG_ERR_NO_ERROR;
581   gcry_module_t cipher;
582
583   REGISTER_DEFAULT_CIPHERS;
584
585   ath_mutex_lock (&ciphers_registered_lock);
586   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
587   if (cipher)
588     {
589       if (cipher->flags & FLAG_MODULE_DISABLED)
590         err = GPG_ERR_CIPHER_ALGO;
591       _gcry_module_release (cipher);
592     }
593   else
594     err = GPG_ERR_CIPHER_ALGO;
595   ath_mutex_unlock (&ciphers_registered_lock);
596   
597   return err;
598 }
599
600
601 /* Return the standard length of the key for the cipher algorithm with
602    the identifier ALGORITHM.  This function expects a valid algorithm
603    and will abort if the algorithm is not available or the length of
604    the key is not known. */
605 static unsigned int
606 cipher_get_keylen (int algorithm)
607 {
608   gcry_module_t cipher;
609   unsigned len = 0;
610
611   REGISTER_DEFAULT_CIPHERS;
612
613   ath_mutex_lock (&ciphers_registered_lock);
614   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
615   if (cipher)
616     {
617       len = ((gcry_cipher_spec_t *) cipher->spec)->keylen;
618       if (!len)
619         log_bug ("cipher %d w/o key length\n", algorithm);
620       _gcry_module_release (cipher);
621     }
622   else
623     log_bug ("cipher %d not found\n", algorithm);
624   ath_mutex_unlock (&ciphers_registered_lock);
625
626   return len;
627 }
628
629 /* Return the block length of the cipher algorithm with the identifier
630    ALGORITHM.  This function expects a valid algorithm and will abort
631    if the algorithm is not available or the length of the key is not
632    known. */
633 static unsigned int
634 cipher_get_blocksize (int algorithm)
635 {
636   gcry_module_t cipher;
637   unsigned len = 0;
638
639   REGISTER_DEFAULT_CIPHERS;
640
641   ath_mutex_lock (&ciphers_registered_lock);
642   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
643   if (cipher)
644     {
645       len = ((gcry_cipher_spec_t *) cipher->spec)->blocksize;
646       if (! len)
647           log_bug ("cipher %d w/o blocksize\n", algorithm);
648       _gcry_module_release (cipher);
649     }
650   else
651     log_bug ("cipher %d not found\n", algorithm);
652   ath_mutex_unlock (&ciphers_registered_lock);
653
654   return len;
655 }
656
657
658 /*
659    Open a cipher handle for use with cipher algorithm ALGORITHM, using
660    the cipher mode MODE (one of the GCRY_CIPHER_MODE_*) and return a
661    handle in HANDLE.  Put NULL into HANDLE and return an error code if
662    something goes wrong.  FLAGS may be used to modify the
663    operation.  The defined flags are:
664
665    GCRY_CIPHER_SECURE:  allocate all internal buffers in secure memory.
666    GCRY_CIPHER_ENABLE_SYNC:  Enable the sync operation as used in OpenPGP.
667    GCRY_CIPHER_CBC_CTS:  Enable CTS mode.
668    GCRY_CIPHER_CBC_MAC:  Enable MAC mode.
669
670    Values for these flags may be combined using OR.
671  */
672 gcry_error_t
673 gcry_cipher_open (gcry_cipher_hd_t *handle,
674                   int algo, int mode, unsigned int flags)
675 {
676   int secure = (flags & GCRY_CIPHER_SECURE);
677   gcry_cipher_spec_t *cipher = NULL;
678   cipher_extra_spec_t *extraspec = NULL;
679   gcry_module_t module = NULL;
680   gcry_cipher_hd_t h = NULL;
681   gcry_err_code_t err = 0;
682
683   /* If the application missed to call the random poll function, we do
684      it here to ensure that it is used once in a while. */
685   _gcry_fast_random_poll ();
686   
687   REGISTER_DEFAULT_CIPHERS;
688
689   /* Fetch the according module and check wether the cipher is marked
690      available for use.  */
691   ath_mutex_lock (&ciphers_registered_lock);
692   module = _gcry_module_lookup_id (ciphers_registered, algo);
693   if (module)
694     {
695       /* Found module.  */
696
697       if (module->flags & FLAG_MODULE_DISABLED)
698         {
699           /* Not available for use.  */
700           err = GPG_ERR_CIPHER_ALGO;
701           _gcry_module_release (module);
702         }
703       else
704         {
705           cipher = (gcry_cipher_spec_t *) module->spec;
706           extraspec = module->extraspec;
707         }
708     }
709   else
710     err = GPG_ERR_CIPHER_ALGO;
711   ath_mutex_unlock (&ciphers_registered_lock);
712
713   /* check flags */
714   if ((! err)
715       && ((flags & ~(0 
716                      | GCRY_CIPHER_SECURE
717                      | GCRY_CIPHER_ENABLE_SYNC
718                      | GCRY_CIPHER_CBC_CTS
719                      | GCRY_CIPHER_CBC_MAC))
720           || (flags & GCRY_CIPHER_CBC_CTS & GCRY_CIPHER_CBC_MAC)))
721     err = GPG_ERR_CIPHER_ALGO;
722
723   /* check that a valid mode has been requested */
724   if (! err)
725     switch (mode)
726       {
727       case GCRY_CIPHER_MODE_ECB:
728       case GCRY_CIPHER_MODE_CBC:
729       case GCRY_CIPHER_MODE_CFB:
730       case GCRY_CIPHER_MODE_OFB:
731       case GCRY_CIPHER_MODE_CTR:
732       case GCRY_CIPHER_MODE_AESWRAP:
733         if ((cipher->encrypt == dummy_encrypt_block)
734             || (cipher->decrypt == dummy_decrypt_block))
735           err = GPG_ERR_INV_CIPHER_MODE;
736         break;
737
738       case GCRY_CIPHER_MODE_STREAM:
739         if ((cipher->stencrypt == dummy_encrypt_stream)
740             || (cipher->stdecrypt == dummy_decrypt_stream))
741           err = GPG_ERR_INV_CIPHER_MODE;
742         break;
743
744       case GCRY_CIPHER_MODE_NONE:
745         /* This mode may be used for debugging.  It copies the main
746            text verbatim to the ciphertext.  We do not allow this in
747            fips mode or if no debug flag has been set.  */
748         if (fips_mode () || !_gcry_get_debug_flag (0))
749           err = GPG_ERR_INV_CIPHER_MODE;
750         break;
751
752       default:
753         err = GPG_ERR_INV_CIPHER_MODE;
754       }
755
756   /* Perform selftest here and mark this with a flag in cipher_table?
757      No, we should not do this as it takes too long.  Further it does
758      not make sense to exclude algorithms with failing selftests at
759      runtime: If a selftest fails there is something seriously wrong
760      with the system and thus we better die immediately. */
761
762   if (! err)
763     {
764       size_t size = (sizeof (*h)
765                      + 2 * cipher->contextsize
766                      - sizeof (cipher_context_alignment_t)
767 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
768                      + 15  /* Space for leading alignment gap.  */
769 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
770                      );
771
772       if (secure)
773         h = gcry_calloc_secure (1, size);
774       else
775         h = gcry_calloc (1, size);
776
777       if (! h)
778         err = gpg_err_code_from_errno (errno);
779       else
780         {
781           size_t off = 0;
782
783 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
784           if ( ((unsigned long)h & 0x0f) )
785             {
786               /* The malloced block is not aligned on a 16 byte
787                  boundary.  Correct for this.  */
788               off = 16 - ((unsigned long)h & 0x0f);
789               h = (void*)((char*)h + off);
790             }
791 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
792
793           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
794           h->actual_handle_size = size - off;
795           h->handle_offset = off;
796           h->cipher = cipher;
797           h->extraspec = extraspec;
798           h->module = module;
799           h->algo = algo;
800           h->mode = mode;
801           h->flags = flags;
802
803           /* Setup bulk encryption routines.  */
804           switch (algo)
805             {
806 #ifdef USE_AES
807             case GCRY_CIPHER_AES128:
808             case GCRY_CIPHER_AES192:
809             case GCRY_CIPHER_AES256:
810               h->bulk.cfb_enc = _gcry_aes_cfb_enc;
811               h->bulk.cfb_dec = _gcry_aes_cfb_dec;
812               h->bulk.cbc_enc = _gcry_aes_cbc_enc;
813               h->bulk.cbc_dec = _gcry_aes_cbc_dec;
814               break;
815 #endif /*USE_AES*/
816               
817             default:
818               break;
819             }
820         }
821     }
822
823   /* Done.  */
824
825   if (err)
826     {
827       if (module)
828         {
829           /* Release module.  */
830           ath_mutex_lock (&ciphers_registered_lock);
831           _gcry_module_release (module);
832           ath_mutex_unlock (&ciphers_registered_lock);
833         }
834     }
835
836   *handle = err ? NULL : h;
837
838   return gcry_error (err);
839 }
840
841
842 /* Release all resources associated with the cipher handle H. H may be
843    NULL in which case this is a no-operation. */
844 void
845 gcry_cipher_close (gcry_cipher_hd_t h)
846 {
847   size_t off;
848
849   if (!h)
850     return;
851
852   if ((h->magic != CTX_MAGIC_SECURE)
853       && (h->magic != CTX_MAGIC_NORMAL))
854     _gcry_fatal_error(GPG_ERR_INTERNAL,
855                       "gcry_cipher_close: already closed/invalid handle");
856   else
857     h->magic = 0;
858
859   /* Release module.  */
860   ath_mutex_lock (&ciphers_registered_lock);
861   _gcry_module_release (h->module);
862   ath_mutex_unlock (&ciphers_registered_lock);
863
864   /* We always want to wipe out the memory even when the context has
865      been allocated in secure memory.  The user might have disabled
866      secure memory or is using his own implementation which does not
867      do the wiping.  To accomplish this we need to keep track of the
868      actual size of this structure because we have no way to known
869      how large the allocated area was when using a standard malloc. */
870   off = h->handle_offset;
871   wipememory (h, h->actual_handle_size);
872
873   gcry_free ((char*)h - off);
874 }
875
876
877 /* Set the key to be used for the encryption context C to KEY with
878    length KEYLEN.  The length should match the required length. */
879 static gcry_error_t
880 cipher_setkey (gcry_cipher_hd_t c, byte *key, unsigned int keylen)
881 {
882   gcry_err_code_t ret;
883
884   ret = (*c->cipher->setkey) (&c->context.c, key, keylen);
885   if (!ret)
886     {
887       /* Duplicate initial context.  */
888       memcpy ((void *) ((char *) &c->context.c + c->cipher->contextsize),
889               (void *) &c->context.c,
890               c->cipher->contextsize);
891       c->marks.key = 1;
892     }
893   else
894     c->marks.key = 0;
895
896   return gcry_error (ret);
897 }
898
899
900 /* Set the IV to be used for the encryption context C to IV with
901    length IVLEN.  The length should match the required length. */
902 static void
903 cipher_setiv( gcry_cipher_hd_t c, const byte *iv, unsigned ivlen )
904 {
905   memset (c->u_iv.iv, 0, c->cipher->blocksize);
906   if (iv) 
907     {
908       if (ivlen != c->cipher->blocksize)
909         {
910           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
911                     ivlen, (unsigned int)c->cipher->blocksize);
912           fips_signal_error ("IV length does not match blocklength");
913         }
914       if (ivlen > c->cipher->blocksize)
915         ivlen = c->cipher->blocksize;
916       memcpy (c->u_iv.iv, iv, ivlen);
917       c->marks.iv = 1;
918     }
919   else
920       c->marks.iv = 0;
921   c->unused = 0;
922 }
923
924
925 /* Reset the cipher context to the initial context.  This is basically
926    the same as an release followed by a new. */
927 static void
928 cipher_reset (gcry_cipher_hd_t c)
929 {
930   memcpy (&c->context.c,
931           (char *) &c->context.c + c->cipher->contextsize,
932           c->cipher->contextsize);
933   memset (&c->marks, 0, sizeof c->marks);
934   memset (c->u_iv.iv, 0, c->cipher->blocksize);
935   memset (c->lastiv, 0, c->cipher->blocksize);
936   memset (c->ctr, 0, c->cipher->blocksize);
937 }
938
939
940 static void
941 do_ecb_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
942                 unsigned int nblocks )
943 {
944   unsigned int n;
945   
946   for (n=0; n < nblocks; n++ )
947     {
948       c->cipher->encrypt ( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
949       inbuf  += c->cipher->blocksize;
950       outbuf += c->cipher->blocksize;
951     }
952 }
953
954 static void
955 do_ecb_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
956                 unsigned int nblocks )
957 {
958   unsigned int n;
959
960   for (n=0; n < nblocks; n++ ) 
961     {
962       c->cipher->decrypt ( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
963       inbuf  += c->cipher->blocksize;
964       outbuf += c->cipher->blocksize;
965     }
966 }
967
968
969 static void
970 do_cbc_encrypt (gcry_cipher_hd_t c, unsigned char *outbuf, 
971                 const unsigned char *inbuf, unsigned int nbytes )
972 {
973   unsigned int n;
974   unsigned char *ivp;
975   int i;
976   size_t blocksize = c->cipher->blocksize;
977   unsigned nblocks = nbytes / blocksize;
978
979   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) 
980     {
981       if ((nbytes % blocksize) == 0)
982         nblocks--;
983     }
984
985   if (c->bulk.cbc_enc)
986     {
987       c->bulk.cbc_enc (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks,
988                        (c->flags & GCRY_CIPHER_CBC_MAC)); 
989       inbuf  += nblocks * blocksize;
990       if (!(c->flags & GCRY_CIPHER_CBC_MAC))
991         outbuf += nblocks * blocksize;
992     }
993   else
994     {
995       for (n=0; n < nblocks; n++ )
996         {
997           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
998             outbuf[i] = inbuf[i] ^ *ivp++;
999           c->cipher->encrypt ( &c->context.c, outbuf, outbuf );
1000           memcpy (c->u_iv.iv, outbuf, blocksize );
1001           inbuf  += blocksize;
1002           if (!(c->flags & GCRY_CIPHER_CBC_MAC))
1003             outbuf += blocksize;
1004         }
1005     }
1006
1007   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize)
1008     {
1009       /* We have to be careful here, since outbuf might be equal to
1010          inbuf.  */
1011       int restbytes;
1012       unsigned char b;
1013
1014       if ((nbytes % blocksize) == 0)
1015         restbytes = blocksize;
1016       else
1017         restbytes = nbytes % blocksize;
1018
1019       outbuf -= blocksize;
1020       for (ivp = c->u_iv.iv, i = 0; i < restbytes; i++)
1021         {
1022           b = inbuf[i];
1023           outbuf[blocksize + i] = outbuf[i];
1024           outbuf[i] = b ^ *ivp++;
1025         }
1026       for (; i < blocksize; i++)
1027         outbuf[i] = 0 ^ *ivp++;
1028       
1029       c->cipher->encrypt (&c->context.c, outbuf, outbuf);
1030       memcpy (c->u_iv.iv, outbuf, blocksize);
1031     }
1032 }
1033
1034
1035 static void
1036 do_cbc_decrypt (gcry_cipher_hd_t c, unsigned char *outbuf, 
1037                 const unsigned char *inbuf, unsigned int nbytes)
1038 {
1039   unsigned int n;
1040   unsigned char *ivp;
1041   int i;
1042   size_t blocksize = c->cipher->blocksize;
1043   unsigned int nblocks = nbytes / blocksize;
1044
1045   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize)
1046     {
1047       nblocks--;
1048       if ((nbytes % blocksize) == 0)
1049         nblocks--;
1050       memcpy (c->lastiv, c->u_iv.iv, blocksize);
1051     }
1052
1053   if (c->bulk.cbc_dec)
1054     {
1055       c->bulk.cbc_dec (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1056       inbuf  += nblocks * blocksize;
1057       outbuf += nblocks * blocksize;
1058     }
1059   else
1060     {
1061       for (n=0; n < nblocks; n++ ) 
1062         {
1063           /* Because outbuf and inbuf might be the same, we have to
1064            * save the original ciphertext block.  We use LASTIV for
1065            * this here because it is not used otherwise. */
1066           memcpy (c->lastiv, inbuf, blocksize);
1067           c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
1068           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1069             outbuf[i] ^= *ivp++;
1070           memcpy(c->u_iv.iv, c->lastiv, blocksize );
1071           inbuf  += c->cipher->blocksize;
1072           outbuf += c->cipher->blocksize;
1073         }
1074     }
1075
1076   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) 
1077     {
1078       int restbytes;
1079       
1080       if ((nbytes % blocksize) == 0)
1081         restbytes = blocksize;
1082       else
1083         restbytes = nbytes % blocksize;
1084       
1085       memcpy (c->lastiv, c->u_iv.iv, blocksize );         /* Save Cn-2. */
1086       memcpy (c->u_iv.iv, inbuf + blocksize, restbytes ); /* Save Cn. */
1087
1088       c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
1089       for (ivp=c->u_iv.iv,i=0; i < restbytes; i++ )
1090         outbuf[i] ^= *ivp++;
1091       
1092       memcpy(outbuf + blocksize, outbuf, restbytes);
1093       for(i=restbytes; i < blocksize; i++)
1094         c->u_iv.iv[i] = outbuf[i];
1095       c->cipher->decrypt (&c->context.c, outbuf, c->u_iv.iv);
1096       for(ivp=c->lastiv,i=0; i < blocksize; i++ )
1097         outbuf[i] ^= *ivp++;
1098       /* c->lastiv is now really lastlastiv, does this matter? */
1099     }
1100 }
1101
1102
1103 static void
1104 do_cfb_encrypt( gcry_cipher_hd_t c, unsigned char *outbuf, 
1105                 const unsigned char *inbuf, unsigned int nbytes )
1106 {
1107   unsigned char *ivp;
1108   size_t blocksize = c->cipher->blocksize;
1109   size_t blocksize_x_2 = blocksize + blocksize;
1110   
1111   if ( nbytes <= c->unused )
1112     {
1113       /* Short enough to be encoded by the remaining XOR mask. */
1114       /* XOR the input with the IV and store input into IV. */
1115       for (ivp=c->u_iv.iv+c->cipher->blocksize - c->unused;
1116            nbytes;
1117            nbytes--, c->unused-- )
1118         *outbuf++ = (*ivp++ ^= *inbuf++);
1119       return;
1120     }
1121
1122   if ( c->unused )
1123     {
1124       /* XOR the input with the IV and store input into IV */
1125       nbytes -= c->unused;
1126       for(ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1127         *outbuf++ = (*ivp++ ^= *inbuf++);
1128     }
1129
1130   /* Now we can process complete blocks.  We use a loop as long as we
1131      have at least 2 blocks and use conditions for the rest.  This
1132      also allows to use a bulk encryption function if available.  */
1133   if (nbytes >= blocksize_x_2 && c->bulk.cfb_enc)
1134     {
1135       unsigned int nblocks = nbytes / blocksize;
1136       c->bulk.cfb_enc (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1137       outbuf += nblocks * blocksize;
1138       inbuf  += nblocks * blocksize;
1139       nbytes -= nblocks * blocksize;
1140     }
1141   else
1142     {
1143       while ( nbytes >= blocksize_x_2 )
1144         {
1145           int i;
1146           /* Encrypt the IV. */
1147           c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1148           /* XOR the input with the IV and store input into IV.  */
1149           for(ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1150             *outbuf++ = (*ivp++ ^= *inbuf++);
1151           nbytes -= blocksize;
1152         }
1153     }
1154
1155   if ( nbytes >= blocksize )
1156     {
1157       int i;
1158       /* Save the current IV and then encrypt the IV. */
1159       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1160       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1161       /* XOR the input with the IV and store input into IV */
1162       for(ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1163         *outbuf++ = (*ivp++ ^= *inbuf++);
1164       nbytes -= blocksize;
1165     }
1166   if ( nbytes ) 
1167     {
1168       /* Save the current IV and then encrypt the IV. */
1169       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1170       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1171       c->unused = blocksize;
1172       /* Apply the XOR. */
1173       c->unused -= nbytes;
1174       for(ivp=c->u_iv.iv; nbytes; nbytes-- )
1175         *outbuf++ = (*ivp++ ^= *inbuf++);
1176     }
1177 }
1178
1179
1180 static void
1181 do_cfb_decrypt( gcry_cipher_hd_t c, unsigned char *outbuf, 
1182                 const unsigned char *inbuf, unsigned int nbytes )
1183 {
1184   unsigned char *ivp;
1185   unsigned long temp;
1186   int i;
1187   size_t blocksize = c->cipher->blocksize;
1188   size_t blocksize_x_2 = blocksize + blocksize;
1189   
1190   if (nbytes <= c->unused)
1191     {
1192       /* Short enough to be encoded by the remaining XOR mask. */
1193       /* XOR the input with the IV and store input into IV. */
1194       for (ivp=c->u_iv.iv+blocksize - c->unused;
1195            nbytes; 
1196            nbytes--, c->unused--)
1197         {
1198           temp = *inbuf++;
1199           *outbuf++ = *ivp ^ temp;
1200           *ivp++ = temp;
1201         }
1202       return;
1203     }
1204   
1205   if (c->unused)
1206     {
1207       /* XOR the input with the IV and store input into IV. */
1208       nbytes -= c->unused;
1209       for (ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1210         {
1211           temp = *inbuf++;
1212           *outbuf++ = *ivp ^ temp;
1213           *ivp++ = temp;
1214         }
1215     }
1216   
1217   /* Now we can process complete blocks.  We use a loop as long as we
1218      have at least 2 blocks and use conditions for the rest.  This
1219      also allows to use a bulk encryption function if available.  */
1220   if (nbytes >= blocksize_x_2 && c->bulk.cfb_dec)
1221     {
1222       unsigned int nblocks = nbytes / blocksize;
1223       c->bulk.cfb_dec (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1224       outbuf += nblocks * blocksize;
1225       inbuf  += nblocks * blocksize;
1226       nbytes -= nblocks * blocksize;
1227     }
1228   else
1229     {
1230       while (nbytes >= blocksize_x_2 )
1231         {
1232           /* Encrypt the IV. */
1233           c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1234           /* XOR the input with the IV and store input into IV. */
1235           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1236             {
1237               temp = *inbuf++;
1238               *outbuf++ = *ivp ^ temp;
1239               *ivp++ = temp;
1240             }
1241           nbytes -= blocksize;
1242         }
1243     }
1244
1245   if (nbytes >= blocksize )
1246     {
1247       /* Save the current IV and then encrypt the IV. */
1248       memcpy ( c->lastiv, c->u_iv.iv, blocksize);
1249       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1250       /* XOR the input with the IV and store input into IV */
1251       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1252         {
1253           temp = *inbuf++;
1254           *outbuf++ = *ivp ^ temp;
1255           *ivp++ = temp;
1256         }
1257       nbytes -= blocksize;
1258     }
1259
1260   if (nbytes)
1261     { 
1262       /* Save the current IV and then encrypt the IV. */
1263       memcpy ( c->lastiv, c->u_iv.iv, blocksize );
1264       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1265       c->unused = blocksize;
1266       /* Apply the XOR. */
1267       c->unused -= nbytes;
1268       for (ivp=c->u_iv.iv; nbytes; nbytes-- )
1269         {
1270           temp = *inbuf++;
1271           *outbuf++ = *ivp ^ temp;
1272           *ivp++ = temp;
1273         }
1274     }
1275 }
1276
1277
1278 static void
1279 do_ofb_encrypt( gcry_cipher_hd_t c,
1280                 byte *outbuf, const byte *inbuf, unsigned nbytes )
1281 {
1282   byte *ivp;
1283   size_t blocksize = c->cipher->blocksize;
1284
1285   if ( nbytes <= c->unused )
1286     {
1287       /* Short enough to be encoded by the remaining XOR mask. */
1288       /* XOR the input with the IV */
1289       for (ivp=c->u_iv.iv+c->cipher->blocksize - c->unused;
1290            nbytes;
1291            nbytes--, c->unused-- )
1292         *outbuf++ = (*ivp++ ^ *inbuf++);
1293       return;
1294     }
1295
1296   if( c->unused )
1297     {
1298       nbytes -= c->unused;
1299       for(ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1300         *outbuf++ = (*ivp++ ^ *inbuf++);
1301     }
1302
1303   /* Now we can process complete blocks. */
1304   while ( nbytes >= blocksize )
1305     {
1306       int i;
1307       /* Encrypt the IV (and save the current one). */
1308       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1309       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1310       
1311       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1312         *outbuf++ = (*ivp++ ^ *inbuf++);
1313       nbytes -= blocksize;
1314     }
1315   if ( nbytes )
1316     { /* process the remaining bytes */
1317       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1318       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1319       c->unused = blocksize;
1320       c->unused -= nbytes;
1321       for(ivp=c->u_iv.iv; nbytes; nbytes-- )
1322         *outbuf++ = (*ivp++ ^ *inbuf++);
1323     }
1324 }
1325
1326 static void
1327 do_ofb_decrypt( gcry_cipher_hd_t c,
1328                 byte *outbuf, const byte *inbuf, unsigned int nbytes )
1329 {
1330   byte *ivp;
1331   size_t blocksize = c->cipher->blocksize;
1332   
1333   if( nbytes <= c->unused )
1334     {
1335       /* Short enough to be encoded by the remaining XOR mask. */
1336       for (ivp=c->u_iv.iv+blocksize - c->unused; nbytes; nbytes--,c->unused--)
1337         *outbuf++ = *ivp++ ^ *inbuf++;
1338       return;
1339     }
1340
1341   if ( c->unused )
1342     {
1343       nbytes -= c->unused;
1344       for (ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1345         *outbuf++ = *ivp++ ^ *inbuf++;
1346     }
1347
1348   /* Now we can process complete blocks. */
1349   while ( nbytes >= blocksize )
1350     {
1351       int i;
1352       /* Encrypt the IV (and save the current one). */
1353       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1354       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1355       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1356         *outbuf++ = *ivp++ ^ *inbuf++;
1357       nbytes -= blocksize;
1358     }
1359   if ( nbytes ) 
1360     { /* Process the remaining bytes. */
1361       /* Encrypt the IV (and save the current one). */
1362       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1363       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1364       c->unused = blocksize;
1365       c->unused -= nbytes;
1366       for (ivp=c->u_iv.iv; nbytes; nbytes-- )
1367         *outbuf++ = *ivp++ ^ *inbuf++;
1368     }
1369 }
1370
1371
1372 static void
1373 do_ctr_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1374                 unsigned int nbytes )
1375 {
1376   unsigned int n;
1377   byte tmp[MAX_BLOCKSIZE];
1378   int i;
1379
1380   for(n=0; n < nbytes; n++)
1381     {
1382       if ((n % c->cipher->blocksize) == 0)
1383         {
1384           c->cipher->encrypt (&c->context.c, tmp, c->ctr);
1385
1386           for (i = c->cipher->blocksize; i > 0; i--)
1387             {
1388               c->ctr[i-1]++;
1389               if (c->ctr[i-1] != 0)
1390                 break;
1391             }
1392         }
1393
1394       /* XOR input with encrypted counter and store in output. */
1395       outbuf[n] = inbuf[n] ^ tmp[n % c->cipher->blocksize];
1396     }
1397 }
1398
1399 static void
1400 do_ctr_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1401                 unsigned int nbytes )
1402 {
1403   do_ctr_encrypt (c, outbuf, inbuf, nbytes);
1404 }
1405
1406
1407 /* Perform the AES-Wrap algorithm as specified by RFC3394.  We
1408    implement this as a mode usable with any cipher algorithm of
1409    blocksize 128.  */
1410 static gcry_err_code_t
1411 do_aeswrap_encrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
1412                     const byte *inbuf, unsigned int inbuflen )
1413 {
1414   int j, x;
1415   unsigned int n, i;
1416   unsigned char *r, *a, *b;
1417   unsigned char t[8];
1418
1419 #if MAX_BLOCKSIZE < 8
1420 #error Invalid block size
1421 #endif
1422   /* We require a cipher with a 128 bit block length.  */
1423   if (c->cipher->blocksize != 16)
1424     return GPG_ERR_INV_LENGTH;  
1425   
1426   /* The output buffer must be able to hold the input data plus one
1427      additional block.  */
1428   if (outbuflen < inbuflen + 8)
1429     return GPG_ERR_BUFFER_TOO_SHORT;
1430   /* Input data must be multiple of 64 bits.  */
1431   if (inbuflen % 8)
1432     return GPG_ERR_INV_ARG;   
1433
1434   n = inbuflen / 8;
1435
1436   /* We need at least two 64 bit blocks.  */
1437   if (n < 2)
1438     return GPG_ERR_INV_ARG;
1439
1440   r = outbuf; 
1441   a = outbuf;  /* We store A directly in OUTBUF.  */
1442   b = c->ctr;  /* B is also used to concatenate stuff.  */
1443
1444   /* If an IV has been set we use that IV as the Alternative Initial
1445      Value; if it has not been set we use the standard value.  */
1446   if (c->marks.iv)
1447     memcpy (a, c->u_iv.iv, 8);
1448   else
1449     memset (a, 0xa6, 8);
1450
1451   /* Copy the inbuf to the outbuf. */
1452   memmove (r+8, inbuf, inbuflen);
1453
1454   memset (t, 0, sizeof t); /* t := 0.  */
1455
1456   for (j = 0; j <= 5; j++)
1457     {
1458       for (i = 1; i <= n; i++)
1459         {
1460           /* B := AES_k( A | R[i] ) */
1461           memcpy (b, a, 8);
1462           memcpy (b+8, r+i*8, 8);
1463           c->cipher->encrypt (&c->context.c, b, b);
1464           /* t := t + 1  */
1465           for (x = 7; x >= 0; x--)
1466             {
1467               t[x]++;
1468               if (t[x])
1469                 break;
1470             }
1471           /* A := MSB_64(B) ^ t */
1472           for (x=0; x < 8; x++)
1473             a[x] = b[x] ^ t[x];
1474           /* R[i] := LSB_64(B) */
1475           memcpy (r+i*8, b+8, 8);
1476         }
1477    }
1478   
1479   return 0;
1480 }
1481
1482 /* Perform the AES-Unwrap algorithm as specified by RFC3394.  We
1483    implement this as a mode usable with any cipher algorithm of
1484    blocksize 128.  */
1485 static gcry_err_code_t
1486 do_aeswrap_decrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
1487                     const byte *inbuf, unsigned int inbuflen)
1488 {
1489   int j, x;
1490   unsigned int n, i;
1491   unsigned char *r, *a, *b;
1492   unsigned char t[8];
1493
1494 #if MAX_BLOCKSIZE < 8
1495 #error Invalid block size
1496 #endif
1497   /* We require a cipher with a 128 bit block length.  */
1498   if (c->cipher->blocksize != 16)
1499     return GPG_ERR_INV_LENGTH;  
1500   
1501   /* The output buffer must be able to hold the input data minus one
1502      additional block.  Fixme: The caller has more restrictive checks
1503      - we may want to fix them for this mode.  */
1504   if (outbuflen + 8  < inbuflen)
1505     return GPG_ERR_BUFFER_TOO_SHORT;
1506   /* Input data must be multiple of 64 bits.  */
1507   if (inbuflen % 8)
1508     return GPG_ERR_INV_ARG;   
1509
1510   n = inbuflen / 8;
1511
1512   /* We need at least three 64 bit blocks.  */
1513   if (n < 3)
1514     return GPG_ERR_INV_ARG;
1515
1516   r = outbuf; 
1517   a = c->lastiv;  /* We use c->LASTIV as buffer for A.  */
1518   b = c->ctr;     /* B is also used to concatenate stuff.  */
1519
1520   /* Copy the inbuf to the outbuf and save A. */
1521   memcpy (a, inbuf, 8);
1522   memmove (r, inbuf+8, inbuflen-8);
1523   n--; /* Reduce to actual number of data blocks.  */
1524
1525   /* t := 6 * n  */
1526   i = n * 6;  /* The range is valid because: n = inbuflen / 8 - 1.  */
1527   for (x=0; x < 8 && x < sizeof (i); x++)
1528     t[7-x] = i >> (8*x);
1529   for (; x < 8; x++)
1530     t[7-x] = 0;
1531
1532   for (j = 5; j >= 0; j--)
1533     {
1534       for (i = n; i >= 1; i--)
1535         {
1536           /* B := AES_k^1( (A ^ t)| R[i] ) */
1537           for (x = 0; x < 8; x++)
1538             b[x] = a[x] ^ t[x];
1539           memcpy (b+8, r+(i-1)*8, 8);
1540           c->cipher->decrypt (&c->context.c, b, b);
1541           /* t := t - 1  */
1542           for (x = 7; x >= 0; x--)
1543             {
1544               t[x]--;
1545               if (t[x] != 0xff)
1546                 break;
1547             }
1548           /* A := MSB_64(B) */
1549           memcpy (a, b, 8);
1550           /* R[i] := LSB_64(B) */
1551           memcpy (r+(i-1)*8, b+8, 8);
1552         }
1553    }
1554
1555   /* If an IV has been set we compare against this Alternative Initial
1556      Value; if it has not been set we compare against the standard IV.  */
1557   if (c->marks.iv)
1558     j = memcmp (a, c->u_iv.iv, 8);
1559   else
1560     {
1561       for (j=0, x=0; x < 8; x++)
1562         if (a[x] != 0xa6)
1563           {
1564             j=1;
1565             break;
1566           }
1567     }
1568   return j? GPG_ERR_CHECKSUM : 0;
1569 }
1570
1571
1572 /****************
1573  * Encrypt INBUF to OUTBUF with the mode selected at open.
1574  * inbuf and outbuf may overlap or be the same.
1575  * Depending on the mode some constraints apply to INBUFLEN.
1576  */
1577 static gcry_err_code_t
1578 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
1579                 const byte *inbuf, unsigned int inbuflen)
1580 {
1581   gcry_err_code_t rc = 0;
1582
1583   switch (c->mode)
1584     {
1585     case GCRY_CIPHER_MODE_ECB:
1586       if (!(inbuflen % c->cipher->blocksize))
1587         do_ecb_encrypt(c, outbuf, inbuf, inbuflen/c->cipher->blocksize );
1588       else 
1589         rc = GPG_ERR_INV_ARG;
1590       break;
1591
1592     case GCRY_CIPHER_MODE_CBC:
1593       if (!(inbuflen % c->cipher->blocksize)
1594           || (inbuflen > c->cipher->blocksize
1595               && (c->flags & GCRY_CIPHER_CBC_CTS)))
1596         do_cbc_encrypt(c, outbuf, inbuf, inbuflen );
1597       else 
1598         rc = GPG_ERR_INV_ARG;
1599       break;
1600       
1601     case GCRY_CIPHER_MODE_CFB:
1602       do_cfb_encrypt(c, outbuf, inbuf, inbuflen );
1603       break;
1604
1605     case GCRY_CIPHER_MODE_OFB:
1606       do_ofb_encrypt(c, outbuf, inbuf, inbuflen );
1607       break;
1608
1609     case GCRY_CIPHER_MODE_CTR:
1610       do_ctr_encrypt(c, outbuf, inbuf, inbuflen );
1611       break;
1612
1613     case GCRY_CIPHER_MODE_AESWRAP:
1614       rc = do_aeswrap_encrypt (c, outbuf, outbuflen, inbuf, inbuflen );
1615       break;
1616
1617     case GCRY_CIPHER_MODE_STREAM:
1618       c->cipher->stencrypt (&c->context.c,
1619                             outbuf, (byte*)/*arggg*/inbuf, inbuflen );
1620       break;
1621
1622     case GCRY_CIPHER_MODE_NONE:
1623       if (fips_mode () || !_gcry_get_debug_flag (0))
1624         {
1625           fips_signal_error ("cipher mode NONE used");
1626           rc = GPG_ERR_INV_CIPHER_MODE;
1627         }
1628       else
1629         {
1630           if ( inbuf != outbuf )
1631             memmove (outbuf, inbuf, inbuflen);
1632         }
1633       break;
1634       
1635     default:
1636       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
1637       rc = GPG_ERR_INV_CIPHER_MODE;
1638       break;
1639     }
1640
1641   return rc;
1642 }
1643
1644
1645 /****************
1646  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
1647  * been requested.
1648  */
1649 gcry_error_t
1650 gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1651                      const void *in, size_t inlen)
1652 {
1653   gcry_err_code_t err;
1654
1655   if (!in)
1656     {
1657       /* Caller requested in-place encryption.  */
1658       err = cipher_encrypt (h, out, outsize, out, outsize);
1659     }
1660   else if (outsize < ((h->flags & GCRY_CIPHER_CBC_MAC) ?
1661                       h->cipher->blocksize : inlen))
1662     err = GPG_ERR_BUFFER_TOO_SHORT;
1663   else if ((h->mode == GCRY_CIPHER_MODE_ECB
1664             || (h->mode == GCRY_CIPHER_MODE_CBC
1665                 && (! ((h->flags & GCRY_CIPHER_CBC_CTS)
1666                        && (inlen > h->cipher->blocksize)))))
1667            && (inlen % h->cipher->blocksize))
1668     err = GPG_ERR_INV_ARG;
1669   else
1670     err = cipher_encrypt (h, out, outsize, in, inlen);
1671
1672   /* Failsafe: Make sure that the plaintext will never make it into
1673      OUT if the encryption returned an error.  */
1674   if (err && out)
1675     memset (out, 0x42, outsize); 
1676
1677   return gcry_error (err);
1678 }
1679
1680
1681
1682 /****************
1683  * Decrypt INBUF to OUTBUF with the mode selected at open.
1684  * inbuf and outbuf may overlap or be the same.
1685  * Depending on the mode some some contraints apply to NBYTES.
1686  */
1687 static gcry_err_code_t
1688 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
1689                 const byte *inbuf, unsigned int inbuflen)
1690 {
1691   gcry_err_code_t rc = 0;
1692
1693   switch (c->mode)
1694     {
1695     case GCRY_CIPHER_MODE_ECB:
1696       if (!(inbuflen % c->cipher->blocksize))
1697         do_ecb_decrypt (c, outbuf, inbuf, inbuflen/c->cipher->blocksize );
1698       else 
1699         rc = GPG_ERR_INV_ARG;
1700       break;
1701
1702     case GCRY_CIPHER_MODE_CBC:
1703       if (!(inbuflen % c->cipher->blocksize)
1704           || (inbuflen > c->cipher->blocksize
1705               && (c->flags & GCRY_CIPHER_CBC_CTS)))
1706         do_cbc_decrypt (c, outbuf, inbuf, inbuflen );
1707       else 
1708         rc = GPG_ERR_INV_ARG;
1709       break;
1710
1711     case GCRY_CIPHER_MODE_CFB:
1712       do_cfb_decrypt (c, outbuf, inbuf, inbuflen );
1713
1714       break;
1715     case GCRY_CIPHER_MODE_OFB:
1716       do_ofb_decrypt (c, outbuf, inbuf, inbuflen );
1717       break;
1718
1719     case GCRY_CIPHER_MODE_CTR:
1720       do_ctr_decrypt (c, outbuf, inbuf, inbuflen );
1721       break;
1722
1723     case GCRY_CIPHER_MODE_AESWRAP:
1724       rc = do_aeswrap_decrypt (c, outbuf, outbuflen, inbuf, inbuflen );
1725       break;
1726
1727     case GCRY_CIPHER_MODE_STREAM:
1728       c->cipher->stdecrypt (&c->context.c,
1729                             outbuf, (byte*)/*arggg*/inbuf, inbuflen );
1730       break;
1731
1732     case GCRY_CIPHER_MODE_NONE:
1733       if (fips_mode () || !_gcry_get_debug_flag (0))
1734         {
1735           fips_signal_error ("cipher mode NONE used");
1736           rc = GPG_ERR_INV_CIPHER_MODE;
1737         }
1738       else
1739         {
1740           if (inbuf != outbuf)
1741             memmove (outbuf, inbuf, inbuflen);
1742         }
1743       break;
1744       
1745     default:
1746       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1747       rc = GPG_ERR_INV_CIPHER_MODE;
1748       break;
1749     }
1750
1751   return rc;
1752 }
1753
1754
1755 gcry_error_t
1756 gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1757                      const void *in, size_t inlen)
1758 {
1759   gcry_err_code_t err = 0;
1760
1761   if (!in)
1762     {
1763       /* Caller requested in-place encryption. */
1764       err = cipher_decrypt (h, out, outsize, out, outsize);
1765     }
1766   else if (outsize < inlen && h->mode != GCRY_CIPHER_MODE_AESWRAP)
1767     {
1768       /* Note that do_aeswrap_decrypt does its own length checking.
1769          Fixme: we should move all buffer length checkings to teh
1770          actual decryption functions.  */
1771       err = GPG_ERR_BUFFER_TOO_SHORT;
1772     }
1773   else if (((h->mode == GCRY_CIPHER_MODE_ECB)
1774             || ((h->mode == GCRY_CIPHER_MODE_CBC)
1775                 && (! ((h->flags & GCRY_CIPHER_CBC_CTS)
1776                        && (inlen > h->cipher->blocksize)))))
1777            && (inlen % h->cipher->blocksize) != 0)
1778     err = GPG_ERR_INV_ARG;
1779   else
1780     err = cipher_decrypt (h, out, outsize, in, inlen);
1781
1782   return gcry_error (err);
1783 }
1784
1785
1786
1787 /****************
1788  * Used for PGP's somewhat strange CFB mode. Only works if
1789  * the corresponding flag is set.
1790  */
1791 static void
1792 cipher_sync (gcry_cipher_hd_t c)
1793 {
1794   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1795     {
1796       memmove (c->u_iv.iv + c->unused,
1797                c->u_iv.iv, c->cipher->blocksize - c->unused);
1798       memcpy (c->u_iv.iv,
1799               c->lastiv + c->cipher->blocksize - c->unused, c->unused);
1800       c->unused = 0;
1801     }
1802 }
1803
1804
1805 gcry_error_t
1806 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
1807 {
1808   return cipher_setkey (hd, (void*)key, keylen);
1809 }
1810
1811
1812 gcry_error_t
1813 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
1814 {
1815   cipher_setiv (hd, iv, ivlen);
1816   return 0;
1817 }
1818
1819 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1820    block size length, or (NULL,0) to set the CTR to the all-zero
1821    block. */
1822 gpg_error_t
1823 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1824 {
1825   if (ctr && ctrlen == hd->cipher->blocksize)
1826     memcpy (hd->ctr, ctr, hd->cipher->blocksize);
1827   else if (!ctr || !ctrlen)
1828     memset (hd->ctr, 0, hd->cipher->blocksize);
1829   else
1830     return gpg_error (GPG_ERR_INV_ARG);
1831   return 0;
1832 }
1833
1834
1835 gcry_error_t
1836 gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1837 {
1838   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1839
1840   switch (cmd)
1841     {
1842     case GCRYCTL_SET_KEY:  /* Deprecated; use gcry_cipher_setkey.  */
1843       rc = cipher_setkey( h, buffer, buflen );
1844       break;
1845
1846     case GCRYCTL_SET_IV:   /* Deprecated; use gcry_cipher_setiv.  */
1847       cipher_setiv( h, buffer, buflen );
1848       break;
1849
1850     case GCRYCTL_RESET:
1851       cipher_reset (h);
1852       break;
1853
1854     case GCRYCTL_CFB_SYNC:
1855       cipher_sync( h );
1856       break;
1857
1858     case GCRYCTL_SET_CBC_CTS:
1859       if (buflen)
1860         if (h->flags & GCRY_CIPHER_CBC_MAC)
1861           rc = GPG_ERR_INV_FLAG;
1862         else
1863           h->flags |= GCRY_CIPHER_CBC_CTS;
1864       else
1865         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1866       break;
1867
1868     case GCRYCTL_SET_CBC_MAC:
1869       if (buflen)
1870         if (h->flags & GCRY_CIPHER_CBC_CTS)
1871           rc = GPG_ERR_INV_FLAG;
1872         else
1873           h->flags |= GCRY_CIPHER_CBC_MAC;
1874       else
1875         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1876       break;
1877
1878     case GCRYCTL_DISABLE_ALGO:
1879       /* This command expects NULL for H and BUFFER to point to an
1880          integer with the algo number.  */
1881       if( h || !buffer || buflen != sizeof(int) )
1882         return gcry_error (GPG_ERR_CIPHER_ALGO);
1883       disable_cipher_algo( *(int*)buffer );
1884       break;
1885
1886     case GCRYCTL_SET_CTR: /* Deprecated; use gcry_cipher_setctr.  */
1887       if (buffer && buflen == h->cipher->blocksize)
1888         memcpy (h->ctr, buffer, h->cipher->blocksize);
1889       else if (buffer == NULL || buflen == 0)
1890         memset (h->ctr, 0, h->cipher->blocksize);
1891       else
1892         rc = GPG_ERR_INV_ARG;
1893       break;
1894
1895     case 61:  /* Disable weak key detection (private).  */
1896       if (h->extraspec->set_extra_info)
1897         rc = h->extraspec->set_extra_info 
1898           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1899       else
1900         rc = GPG_ERR_NOT_SUPPORTED;
1901       break;
1902
1903     case 62: /* Return current input vector (private).  */
1904       /* This is the input block as used in CFB and OFB mode which has
1905          initially been set as IV.  The returned format is: 
1906            1 byte  Actual length of the block in bytes.
1907            n byte  The block.
1908          If the provided buffer is too short, an error is returned. */
1909       if (buflen < (1 + h->cipher->blocksize))
1910         rc = GPG_ERR_TOO_SHORT;
1911       else
1912         {
1913           unsigned char *ivp;
1914           unsigned char *dst = buffer;
1915           int n = h->unused;
1916           
1917           if (!n)
1918             n = h->cipher->blocksize;
1919           gcry_assert (n <= h->cipher->blocksize);
1920           *dst++ = n;
1921           ivp = h->u_iv.iv + h->cipher->blocksize - n;
1922           while (n--)
1923             *dst++ = *ivp++;
1924         }
1925       break;
1926
1927     default:
1928       rc = GPG_ERR_INV_OP;
1929     }
1930
1931   return gcry_error (rc);
1932 }
1933
1934
1935 /* Return information about the cipher handle H.  CMD is the kind of
1936    information requested.  BUFFER and NBYTES are reserved for now.
1937
1938    There are no values for CMD yet defined.  
1939
1940    The fucntion always returns GPG_ERR_INV_OP.
1941    
1942  */
1943 gcry_error_t
1944 gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1945 {
1946   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1947
1948   (void)h;
1949   (void)buffer;
1950   (void)nbytes;
1951
1952   switch (cmd)
1953     {
1954     default:
1955       err = GPG_ERR_INV_OP;
1956     }
1957
1958   return gcry_error (err);
1959 }
1960
1961 /* Return information about the given cipher algorithm ALGO.
1962
1963    WHAT select the kind of information returned:
1964
1965     GCRYCTL_GET_KEYLEN:
1966         Return the length of the key.  If the algorithm ALGO
1967         supports multiple key lengths, the maximum supported key length
1968         is returned.  The key length is returned as number of octets.
1969         BUFFER and NBYTES must be zero.
1970
1971     GCRYCTL_GET_BLKLEN:
1972         Return the blocklength of the algorithm ALGO counted in octets.
1973         BUFFER and NBYTES must be zero.
1974
1975     GCRYCTL_TEST_ALGO:
1976         Returns 0 if the specified algorithm ALGO is available for use.
1977         BUFFER and NBYTES must be zero.
1978   
1979    Note: Because this function is in most cases used to return an
1980    integer value, we can make it easier for the caller to just look at
1981    the return value.  The caller will in all cases consult the value
1982    and thereby detecting whether a error occured or not (i.e. while
1983    checking the block size)
1984  */
1985 gcry_error_t
1986 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1987 {
1988   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1989   unsigned int ui;
1990
1991   switch (what)
1992     {
1993     case GCRYCTL_GET_KEYLEN:
1994       if (buffer || (! nbytes))
1995         err = GPG_ERR_CIPHER_ALGO;
1996       else
1997         {
1998           ui = cipher_get_keylen (algo);
1999           if ((ui > 0) && (ui <= 512))
2000             *nbytes = (size_t) ui / 8;
2001           else
2002             /* The only reason is an invalid algo or a strange
2003                blocksize.  */
2004             err = GPG_ERR_CIPHER_ALGO;
2005         }
2006       break;
2007
2008     case GCRYCTL_GET_BLKLEN:
2009       if (buffer || (! nbytes))
2010         err = GPG_ERR_CIPHER_ALGO;
2011       else
2012         {
2013           ui = cipher_get_blocksize (algo);
2014           if ((ui > 0) && (ui < 10000))
2015             *nbytes = ui;
2016           else
2017             /* The only reason is an invalid algo or a strange
2018                blocksize.  */
2019             err = GPG_ERR_CIPHER_ALGO;
2020         }
2021       break;
2022
2023     case GCRYCTL_TEST_ALGO:
2024       if (buffer || nbytes)
2025         err = GPG_ERR_INV_ARG;
2026       else
2027         err = check_cipher_algo (algo);
2028       break;
2029
2030       default:
2031         err = GPG_ERR_INV_OP;
2032     }
2033
2034   return gcry_error (err);
2035 }
2036
2037
2038 /* This function returns length of the key for algorithm ALGO.  If the
2039    algorithm supports multiple key lengths, the maximum supported key
2040    length is returned.  On error 0 is returned.  The key length is
2041    returned as number of octets.
2042
2043    This is a convenience functions which should be preferred over
2044    gcry_cipher_algo_info because it allows for proper type
2045    checking.  */
2046 size_t
2047 gcry_cipher_get_algo_keylen (int algo) 
2048 {
2049   size_t n;
2050
2051   if (gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
2052     n = 0;
2053   return n;
2054 }
2055
2056 /* This functions returns the blocklength of the algorithm ALGO
2057    counted in octets.  On error 0 is returned.
2058
2059    This is a convenience functions which should be preferred over
2060    gcry_cipher_algo_info because it allows for proper type
2061    checking.  */
2062 size_t
2063 gcry_cipher_get_algo_blklen (int algo) 
2064 {
2065   size_t n;
2066
2067   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
2068     n = 0;
2069   return n;
2070 }
2071
2072 /* Explicitly initialize this module.  */
2073 gcry_err_code_t
2074 _gcry_cipher_init (void)
2075 {
2076   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2077
2078   REGISTER_DEFAULT_CIPHERS;
2079
2080   return err;
2081 }
2082
2083 /* Get a list consisting of the IDs of the loaded cipher modules.  If
2084    LIST is zero, write the number of loaded cipher modules to
2085    LIST_LENGTH and return.  If LIST is non-zero, the first
2086    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
2087    according size.  In case there are less cipher modules than
2088    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
2089 gcry_error_t
2090 gcry_cipher_list (int *list, int *list_length)
2091 {
2092   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2093
2094   ath_mutex_lock (&ciphers_registered_lock);
2095   err = _gcry_module_list (ciphers_registered, list, list_length);
2096   ath_mutex_unlock (&ciphers_registered_lock);
2097
2098   return err;
2099 }
2100
2101
2102 /* Run the selftests for cipher algorithm ALGO with optional reporting
2103    function REPORT.  */
2104 gpg_error_t
2105 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
2106 {
2107   gcry_module_t module = NULL;
2108   cipher_extra_spec_t *extraspec = NULL;
2109   gcry_err_code_t ec = 0;
2110
2111   REGISTER_DEFAULT_CIPHERS;
2112
2113   ath_mutex_lock (&ciphers_registered_lock);
2114   module = _gcry_module_lookup_id (ciphers_registered, algo);
2115   if (module && !(module->flags & FLAG_MODULE_DISABLED))
2116     extraspec = module->extraspec;
2117   ath_mutex_unlock (&ciphers_registered_lock);
2118   if (extraspec && extraspec->selftest)
2119     ec = extraspec->selftest (algo, extended, report);
2120   else
2121     {
2122       ec = GPG_ERR_CIPHER_ALGO;
2123       if (report)
2124         report ("cipher", algo, "module", 
2125                 module && !(module->flags & FLAG_MODULE_DISABLED)?
2126                 "no selftest available" :
2127                 module? "algorithm disabled" : "algorithm not found");
2128     }
2129
2130   if (module)
2131     {
2132       ath_mutex_lock (&ciphers_registered_lock);
2133       _gcry_module_release (module);
2134       ath_mutex_unlock (&ciphers_registered_lock);
2135     }
2136   return gpg_error (ec);
2137 }