Add support for Salsa20.
[libgcrypt.git] / cipher / cipher.c
1 /* cipher.c  -  cipher dispatcher
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *               2005, 2007, 2008, 2009, 2011 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 #include "./cipher-internal.h"
31
32 /* A dummy extraspec so that we do not need to tests the extraspec
33    field from the module specification against NULL and instead
34    directly test the respective fields of extraspecs.  */
35 static cipher_extra_spec_t dummy_extra_spec;
36
37 /* This is the list of the default ciphers, which are included in
38    libgcrypt.  */
39 static struct cipher_table_entry
40 {
41   gcry_cipher_spec_t *cipher;
42   cipher_extra_spec_t *extraspec;
43   unsigned int algorithm;
44   int fips_allowed;
45 } cipher_table[] =
46   {
47 #if USE_BLOWFISH
48     { &_gcry_cipher_spec_blowfish,
49       &dummy_extra_spec,                  GCRY_CIPHER_BLOWFISH },
50 #endif
51 #if USE_DES
52     { &_gcry_cipher_spec_des,
53       &dummy_extra_spec,                  GCRY_CIPHER_DES },
54     { &_gcry_cipher_spec_tripledes,
55       &_gcry_cipher_extraspec_tripledes,  GCRY_CIPHER_3DES, 1 },
56 #endif
57 #if USE_ARCFOUR
58     { &_gcry_cipher_spec_arcfour,
59       &dummy_extra_spec,                  GCRY_CIPHER_ARCFOUR },
60 #endif
61 #if USE_CAST5
62     { &_gcry_cipher_spec_cast5,
63       &dummy_extra_spec,                  GCRY_CIPHER_CAST5 },
64 #endif
65 #if USE_AES
66     { &_gcry_cipher_spec_aes,
67       &_gcry_cipher_extraspec_aes,        GCRY_CIPHER_AES,    1 },
68     { &_gcry_cipher_spec_aes192,
69       &_gcry_cipher_extraspec_aes192,     GCRY_CIPHER_AES192, 1 },
70     { &_gcry_cipher_spec_aes256,
71       &_gcry_cipher_extraspec_aes256,     GCRY_CIPHER_AES256, 1 },
72 #endif
73 #if USE_TWOFISH
74     { &_gcry_cipher_spec_twofish,
75       &dummy_extra_spec,                  GCRY_CIPHER_TWOFISH },
76     { &_gcry_cipher_spec_twofish128,
77       &dummy_extra_spec,                  GCRY_CIPHER_TWOFISH128 },
78 #endif
79 #if USE_SERPENT
80     { &_gcry_cipher_spec_serpent128,
81       &dummy_extra_spec,                  GCRY_CIPHER_SERPENT128 },
82     { &_gcry_cipher_spec_serpent192,
83       &dummy_extra_spec,                  GCRY_CIPHER_SERPENT192 },
84     { &_gcry_cipher_spec_serpent256,
85       &dummy_extra_spec,                  GCRY_CIPHER_SERPENT256 },
86 #endif
87 #if USE_RFC2268
88     { &_gcry_cipher_spec_rfc2268_40,
89       &dummy_extra_spec,                  GCRY_CIPHER_RFC2268_40 },
90 #endif
91 #if USE_SEED
92     { &_gcry_cipher_spec_seed,
93       &dummy_extra_spec,                  GCRY_CIPHER_SEED },
94 #endif
95 #if USE_CAMELLIA
96     { &_gcry_cipher_spec_camellia128,
97       &dummy_extra_spec,                  GCRY_CIPHER_CAMELLIA128 },
98     { &_gcry_cipher_spec_camellia192,
99       &dummy_extra_spec,                  GCRY_CIPHER_CAMELLIA192 },
100     { &_gcry_cipher_spec_camellia256,
101       &dummy_extra_spec,                  GCRY_CIPHER_CAMELLIA256 },
102 #endif
103 #ifdef USE_IDEA
104     { &_gcry_cipher_spec_idea,
105       &dummy_extra_spec,                  GCRY_CIPHER_IDEA },
106 #endif
107 #if USE_SALSA20
108     { &_gcry_cipher_spec_salsa20,
109       &_gcry_cipher_extraspec_salsa20,    GCRY_CIPHER_SALSA20 },
110 #endif
111     { NULL                    }
112   };
113
114 /* List of registered ciphers.  */
115 static gcry_module_t ciphers_registered;
116
117 /* This is the lock protecting CIPHERS_REGISTERED.  It is initialized
118    by _gcry_cipher_init.  */
119 static ath_mutex_t ciphers_registered_lock;
120
121 /* Flag to check whether 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 \f
141 /* These dummy functions are used in case a cipher implementation
142    refuses to provide it's own functions.  */
143
144 static gcry_err_code_t
145 dummy_setkey (void *c, const unsigned char *key, unsigned int keylen)
146 {
147   (void)c;
148   (void)key;
149   (void)keylen;
150   return GPG_ERR_NO_ERROR;
151 }
152
153 static void
154 dummy_encrypt_block (void *c,
155                      unsigned char *outbuf, const unsigned char *inbuf)
156 {
157   (void)c;
158   (void)outbuf;
159   (void)inbuf;
160   BUG();
161 }
162
163 static void
164 dummy_decrypt_block (void *c,
165                      unsigned char *outbuf, const unsigned char *inbuf)
166 {
167   (void)c;
168   (void)outbuf;
169   (void)inbuf;
170   BUG();
171 }
172
173 static void
174 dummy_encrypt_stream (void *c,
175                       unsigned char *outbuf, const unsigned char *inbuf,
176                       unsigned int n)
177 {
178   (void)c;
179   (void)outbuf;
180   (void)inbuf;
181   (void)n;
182   BUG();
183 }
184
185 static void
186 dummy_decrypt_stream (void *c,
187                       unsigned char *outbuf, const unsigned char *inbuf,
188                       unsigned int n)
189 {
190   (void)c;
191   (void)outbuf;
192   (void)inbuf;
193   (void)n;
194   BUG();
195 }
196
197 \f
198 /* Internal function.  Register all the ciphers included in
199    CIPHER_TABLE.  Note, that this function gets only used by the macro
200    REGISTER_DEFAULT_CIPHERS which protects it using a mutex. */
201 static void
202 cipher_register_default (void)
203 {
204   gcry_err_code_t err = GPG_ERR_NO_ERROR;
205   int i;
206
207   for (i = 0; !err && cipher_table[i].cipher; i++)
208     {
209       if (! cipher_table[i].cipher->setkey)
210         cipher_table[i].cipher->setkey = dummy_setkey;
211       if (! cipher_table[i].cipher->encrypt)
212         cipher_table[i].cipher->encrypt = dummy_encrypt_block;
213       if (! cipher_table[i].cipher->decrypt)
214         cipher_table[i].cipher->decrypt = dummy_decrypt_block;
215       if (! cipher_table[i].cipher->stencrypt)
216         cipher_table[i].cipher->stencrypt = dummy_encrypt_stream;
217       if (! cipher_table[i].cipher->stdecrypt)
218         cipher_table[i].cipher->stdecrypt = dummy_decrypt_stream;
219
220       if ( fips_mode () && !cipher_table[i].fips_allowed )
221         continue;
222
223       err = _gcry_module_add (&ciphers_registered,
224                               cipher_table[i].algorithm,
225                               (void *) cipher_table[i].cipher,
226                               (void *) cipher_table[i].extraspec,
227                               NULL);
228     }
229
230   if (err)
231     BUG ();
232 }
233
234 /* Internal callback function.  Used via _gcry_module_lookup.  */
235 static int
236 gcry_cipher_lookup_func_name (void *spec, void *data)
237 {
238   gcry_cipher_spec_t *cipher = (gcry_cipher_spec_t *) spec;
239   char *name = (char *) data;
240   const char **aliases = cipher->aliases;
241   int i, ret = ! stricmp (name, cipher->name);
242
243   if (aliases)
244     for (i = 0; aliases[i] && (! ret); i++)
245       ret = ! stricmp (name, aliases[i]);
246
247   return ret;
248 }
249
250 /* Internal callback function.  Used via _gcry_module_lookup.  */
251 static int
252 gcry_cipher_lookup_func_oid (void *spec, void *data)
253 {
254   gcry_cipher_spec_t *cipher = (gcry_cipher_spec_t *) spec;
255   char *oid = (char *) data;
256   gcry_cipher_oid_spec_t *oid_specs = cipher->oids;
257   int ret = 0, i;
258
259   if (oid_specs)
260     for (i = 0; oid_specs[i].oid && (! ret); i++)
261       if (! stricmp (oid, oid_specs[i].oid))
262         ret = 1;
263
264   return ret;
265 }
266
267 /* Internal function.  Lookup a cipher entry by it's name.  */
268 static gcry_module_t
269 gcry_cipher_lookup_name (const char *name)
270 {
271   gcry_module_t cipher;
272
273   cipher = _gcry_module_lookup (ciphers_registered, (void *) name,
274                                 gcry_cipher_lookup_func_name);
275
276   return cipher;
277 }
278
279 /* Internal function.  Lookup a cipher entry by it's oid.  */
280 static gcry_module_t
281 gcry_cipher_lookup_oid (const char *oid)
282 {
283   gcry_module_t cipher;
284
285   cipher = _gcry_module_lookup (ciphers_registered, (void *) oid,
286                                 gcry_cipher_lookup_func_oid);
287
288   return cipher;
289 }
290
291 /* Register a new cipher module whose specification can be found in
292    CIPHER.  On success, a new algorithm ID is stored in ALGORITHM_ID
293    and a pointer representhing this module is stored in MODULE.  */
294 gcry_error_t
295 _gcry_cipher_register (gcry_cipher_spec_t *cipher,
296                        cipher_extra_spec_t *extraspec,
297                        int *algorithm_id,
298                        gcry_module_t *module)
299 {
300   gcry_err_code_t err = 0;
301   gcry_module_t mod;
302
303   /* We do not support module loading in fips mode.  */
304   if (fips_mode ())
305     return gpg_error (GPG_ERR_NOT_SUPPORTED);
306
307   ath_mutex_lock (&ciphers_registered_lock);
308   err = _gcry_module_add (&ciphers_registered, 0,
309                           (void *)cipher,
310                           (void *)(extraspec? extraspec : &dummy_extra_spec),
311                           &mod);
312   ath_mutex_unlock (&ciphers_registered_lock);
313
314   if (! err)
315     {
316       *module = mod;
317       *algorithm_id = mod->mod_id;
318     }
319
320   return gcry_error (err);
321 }
322
323 /* Unregister the cipher identified by MODULE, which must have been
324    registered with gcry_cipher_register.  */
325 void
326 _gcry_cipher_unregister (gcry_module_t module)
327 {
328   ath_mutex_lock (&ciphers_registered_lock);
329   _gcry_module_release (module);
330   ath_mutex_unlock (&ciphers_registered_lock);
331 }
332
333 /* Locate the OID in the oid table and return the index or -1 when not
334    found.  An opitonal "oid." or "OID." prefix in OID is ignored, the
335    OID is expected to be in standard IETF dotted notation.  The
336    internal algorithm number is returned in ALGORITHM unless it
337    ispassed as NULL.  A pointer to the specification of the module
338    implementing this algorithm is return in OID_SPEC unless passed as
339    NULL.*/
340 static int
341 search_oid (const char *oid, int *algorithm, gcry_cipher_oid_spec_t *oid_spec)
342 {
343   gcry_module_t module;
344   int ret = 0;
345
346   if (oid && ((! strncmp (oid, "oid.", 4))
347               || (! strncmp (oid, "OID.", 4))))
348     oid += 4;
349
350   module = gcry_cipher_lookup_oid (oid);
351   if (module)
352     {
353       gcry_cipher_spec_t *cipher = module->spec;
354       int i;
355
356       for (i = 0; cipher->oids[i].oid && !ret; i++)
357         if (! stricmp (oid, cipher->oids[i].oid))
358           {
359             if (algorithm)
360               *algorithm = module->mod_id;
361             if (oid_spec)
362               *oid_spec = cipher->oids[i];
363             ret = 1;
364           }
365       _gcry_module_release (module);
366     }
367
368   return ret;
369 }
370
371 /* Map STRING to the cipher algorithm identifier.  Returns the
372    algorithm ID of the cipher for the given name or 0 if the name is
373    not known.  It is valid to pass NULL for STRING which results in a
374    return value of 0. */
375 int
376 gcry_cipher_map_name (const char *string)
377 {
378   gcry_module_t cipher;
379   int ret, algorithm = 0;
380
381   if (! string)
382     return 0;
383
384   REGISTER_DEFAULT_CIPHERS;
385
386   /* If the string starts with a digit (optionally prefixed with
387      either "OID." or "oid."), we first look into our table of ASN.1
388      object identifiers to figure out the algorithm */
389
390   ath_mutex_lock (&ciphers_registered_lock);
391
392   ret = search_oid (string, &algorithm, NULL);
393   if (! ret)
394     {
395       cipher = gcry_cipher_lookup_name (string);
396       if (cipher)
397         {
398           algorithm = cipher->mod_id;
399           _gcry_module_release (cipher);
400         }
401     }
402
403   ath_mutex_unlock (&ciphers_registered_lock);
404
405   return algorithm;
406 }
407
408
409 /* Given a STRING with an OID in dotted decimal notation, this
410    function returns the cipher mode (GCRY_CIPHER_MODE_*) associated
411    with that OID or 0 if no mode is known.  Passing NULL for string
412    yields a return value of 0. */
413 int
414 gcry_cipher_mode_from_oid (const char *string)
415 {
416   gcry_cipher_oid_spec_t oid_spec;
417   int ret = 0, mode = 0;
418
419   if (!string)
420     return 0;
421
422   ath_mutex_lock (&ciphers_registered_lock);
423   ret = search_oid (string, NULL, &oid_spec);
424   if (ret)
425     mode = oid_spec.mode;
426   ath_mutex_unlock (&ciphers_registered_lock);
427
428   return mode;
429 }
430
431
432 /* Map the cipher algorithm whose ID is contained in ALGORITHM to a
433    string representation of the algorithm name.  For unknown algorithm
434    IDs this function returns "?".  */
435 static const char *
436 cipher_algo_to_string (int algorithm)
437 {
438   gcry_module_t cipher;
439   const char *name;
440
441   REGISTER_DEFAULT_CIPHERS;
442
443   ath_mutex_lock (&ciphers_registered_lock);
444   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
445   if (cipher)
446     {
447       name = ((gcry_cipher_spec_t *) cipher->spec)->name;
448       _gcry_module_release (cipher);
449     }
450   else
451     name = "?";
452   ath_mutex_unlock (&ciphers_registered_lock);
453
454   return name;
455 }
456
457 /* Map the cipher algorithm identifier ALGORITHM to a string
458    representing this algorithm.  This string is the default name as
459    used by Libgcrypt.  An pointer to an empty string is returned for
460    an unknown algorithm.  NULL is never returned. */
461 const char *
462 gcry_cipher_algo_name (int algorithm)
463 {
464   return cipher_algo_to_string (algorithm);
465 }
466
467
468 /* Flag the cipher algorithm with the identifier ALGORITHM as
469    disabled.  There is no error return, the function does nothing for
470    unknown algorithms.  Disabled algorithms are vitually not available
471    in Libgcrypt. */
472 static void
473 disable_cipher_algo (int algorithm)
474 {
475   gcry_module_t cipher;
476
477   REGISTER_DEFAULT_CIPHERS;
478
479   ath_mutex_lock (&ciphers_registered_lock);
480   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
481   if (cipher)
482     {
483       if (! (cipher->flags & FLAG_MODULE_DISABLED))
484         cipher->flags |= FLAG_MODULE_DISABLED;
485       _gcry_module_release (cipher);
486     }
487   ath_mutex_unlock (&ciphers_registered_lock);
488 }
489
490
491 /* Return 0 if the cipher algorithm with identifier ALGORITHM is
492    available. Returns a basic error code value if it is not
493    available.  */
494 static gcry_err_code_t
495 check_cipher_algo (int algorithm)
496 {
497   gcry_err_code_t err = GPG_ERR_NO_ERROR;
498   gcry_module_t cipher;
499
500   REGISTER_DEFAULT_CIPHERS;
501
502   ath_mutex_lock (&ciphers_registered_lock);
503   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
504   if (cipher)
505     {
506       if (cipher->flags & FLAG_MODULE_DISABLED)
507         err = GPG_ERR_CIPHER_ALGO;
508       _gcry_module_release (cipher);
509     }
510   else
511     err = GPG_ERR_CIPHER_ALGO;
512   ath_mutex_unlock (&ciphers_registered_lock);
513
514   return err;
515 }
516
517
518 /* Return the standard length in bits of the key for the cipher
519    algorithm with the identifier ALGORITHM.  */
520 static unsigned int
521 cipher_get_keylen (int algorithm)
522 {
523   gcry_module_t cipher;
524   unsigned len = 0;
525
526   REGISTER_DEFAULT_CIPHERS;
527
528   ath_mutex_lock (&ciphers_registered_lock);
529   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
530   if (cipher)
531     {
532       len = ((gcry_cipher_spec_t *) cipher->spec)->keylen;
533       if (!len)
534         log_bug ("cipher %d w/o key length\n", algorithm);
535       _gcry_module_release (cipher);
536     }
537   ath_mutex_unlock (&ciphers_registered_lock);
538
539   return len;
540 }
541
542 /* Return the block length of the cipher algorithm with the identifier
543    ALGORITHM.  This function return 0 for an invalid algorithm.  */
544 static unsigned int
545 cipher_get_blocksize (int algorithm)
546 {
547   gcry_module_t cipher;
548   unsigned len = 0;
549
550   REGISTER_DEFAULT_CIPHERS;
551
552   ath_mutex_lock (&ciphers_registered_lock);
553   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
554   if (cipher)
555     {
556       len = ((gcry_cipher_spec_t *) cipher->spec)->blocksize;
557       if (! len)
558           log_bug ("cipher %d w/o blocksize\n", algorithm);
559       _gcry_module_release (cipher);
560     }
561   ath_mutex_unlock (&ciphers_registered_lock);
562
563   return len;
564 }
565
566
567 /*
568    Open a cipher handle for use with cipher algorithm ALGORITHM, using
569    the cipher mode MODE (one of the GCRY_CIPHER_MODE_*) and return a
570    handle in HANDLE.  Put NULL into HANDLE and return an error code if
571    something goes wrong.  FLAGS may be used to modify the
572    operation.  The defined flags are:
573
574    GCRY_CIPHER_SECURE:  allocate all internal buffers in secure memory.
575    GCRY_CIPHER_ENABLE_SYNC:  Enable the sync operation as used in OpenPGP.
576    GCRY_CIPHER_CBC_CTS:  Enable CTS mode.
577    GCRY_CIPHER_CBC_MAC:  Enable MAC mode.
578
579    Values for these flags may be combined using OR.
580  */
581 gcry_error_t
582 gcry_cipher_open (gcry_cipher_hd_t *handle,
583                   int algo, int mode, unsigned int flags)
584 {
585   int secure = (flags & GCRY_CIPHER_SECURE);
586   gcry_cipher_spec_t *cipher = NULL;
587   cipher_extra_spec_t *extraspec = NULL;
588   gcry_module_t module = NULL;
589   gcry_cipher_hd_t h = NULL;
590   gcry_err_code_t err = 0;
591
592   /* If the application missed to call the random poll function, we do
593      it here to ensure that it is used once in a while. */
594   _gcry_fast_random_poll ();
595
596   REGISTER_DEFAULT_CIPHERS;
597
598   /* Fetch the according module and check whether the cipher is marked
599      available for use.  */
600   ath_mutex_lock (&ciphers_registered_lock);
601   module = _gcry_module_lookup_id (ciphers_registered, algo);
602   if (module)
603     {
604       /* Found module.  */
605
606       if (module->flags & FLAG_MODULE_DISABLED)
607         {
608           /* Not available for use.  */
609           err = GPG_ERR_CIPHER_ALGO;
610         }
611       else
612         {
613           cipher = (gcry_cipher_spec_t *) module->spec;
614           extraspec = module->extraspec;
615         }
616     }
617   else
618     err = GPG_ERR_CIPHER_ALGO;
619   ath_mutex_unlock (&ciphers_registered_lock);
620
621   /* check flags */
622   if ((! err)
623       && ((flags & ~(0
624                      | GCRY_CIPHER_SECURE
625                      | GCRY_CIPHER_ENABLE_SYNC
626                      | GCRY_CIPHER_CBC_CTS
627                      | GCRY_CIPHER_CBC_MAC))
628           || (flags & GCRY_CIPHER_CBC_CTS & GCRY_CIPHER_CBC_MAC)))
629     err = GPG_ERR_CIPHER_ALGO;
630
631   /* check that a valid mode has been requested */
632   if (! err)
633     switch (mode)
634       {
635       case GCRY_CIPHER_MODE_ECB:
636       case GCRY_CIPHER_MODE_CBC:
637       case GCRY_CIPHER_MODE_CFB:
638       case GCRY_CIPHER_MODE_OFB:
639       case GCRY_CIPHER_MODE_CTR:
640       case GCRY_CIPHER_MODE_AESWRAP:
641         if ((cipher->encrypt == dummy_encrypt_block)
642             || (cipher->decrypt == dummy_decrypt_block))
643           err = GPG_ERR_INV_CIPHER_MODE;
644         break;
645
646       case GCRY_CIPHER_MODE_STREAM:
647         if ((cipher->stencrypt == dummy_encrypt_stream)
648             || (cipher->stdecrypt == dummy_decrypt_stream))
649           err = GPG_ERR_INV_CIPHER_MODE;
650         break;
651
652       case GCRY_CIPHER_MODE_NONE:
653         /* This mode may be used for debugging.  It copies the main
654            text verbatim to the ciphertext.  We do not allow this in
655            fips mode or if no debug flag has been set.  */
656         if (fips_mode () || !_gcry_get_debug_flag (0))
657           err = GPG_ERR_INV_CIPHER_MODE;
658         break;
659
660       default:
661         err = GPG_ERR_INV_CIPHER_MODE;
662       }
663
664   /* Perform selftest here and mark this with a flag in cipher_table?
665      No, we should not do this as it takes too long.  Further it does
666      not make sense to exclude algorithms with failing selftests at
667      runtime: If a selftest fails there is something seriously wrong
668      with the system and thus we better die immediately. */
669
670   if (! err)
671     {
672       size_t size = (sizeof (*h)
673                      + 2 * cipher->contextsize
674                      - sizeof (cipher_context_alignment_t)
675 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
676                      + 15  /* Space for leading alignment gap.  */
677 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
678                      );
679
680       if (secure)
681         h = gcry_calloc_secure (1, size);
682       else
683         h = gcry_calloc (1, size);
684
685       if (! h)
686         err = gpg_err_code_from_syserror ();
687       else
688         {
689           size_t off = 0;
690
691 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
692           if ( ((unsigned long)h & 0x0f) )
693             {
694               /* The malloced block is not aligned on a 16 byte
695                  boundary.  Correct for this.  */
696               off = 16 - ((unsigned long)h & 0x0f);
697               h = (void*)((char*)h + off);
698             }
699 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
700
701           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
702           h->actual_handle_size = size - off;
703           h->handle_offset = off;
704           h->cipher = cipher;
705           h->extraspec = extraspec;
706           h->module = module;
707           h->algo = algo;
708           h->mode = mode;
709           h->flags = flags;
710
711           /* Setup bulk encryption routines.  */
712           switch (algo)
713             {
714 #ifdef USE_AES
715             case GCRY_CIPHER_AES128:
716             case GCRY_CIPHER_AES192:
717             case GCRY_CIPHER_AES256:
718               h->bulk.cfb_enc = _gcry_aes_cfb_enc;
719               h->bulk.cfb_dec = _gcry_aes_cfb_dec;
720               h->bulk.cbc_enc = _gcry_aes_cbc_enc;
721               h->bulk.cbc_dec = _gcry_aes_cbc_dec;
722               h->bulk.ctr_enc = _gcry_aes_ctr_enc;
723               break;
724 #endif /*USE_AES*/
725 #ifdef USE_BLOWFISH
726             case GCRY_CIPHER_BLOWFISH:
727               h->bulk.cfb_dec = _gcry_blowfish_cfb_dec;
728               h->bulk.cbc_dec = _gcry_blowfish_cbc_dec;
729               h->bulk.ctr_enc = _gcry_blowfish_ctr_enc;
730               break;
731 #endif /*USE_BLOWFISH*/
732 #ifdef USE_CAST5
733             case GCRY_CIPHER_CAST5:
734               h->bulk.cfb_dec = _gcry_cast5_cfb_dec;
735               h->bulk.cbc_dec = _gcry_cast5_cbc_dec;
736               h->bulk.ctr_enc = _gcry_cast5_ctr_enc;
737               break;
738 #endif /*USE_CAMELLIA*/
739 #ifdef USE_CAMELLIA
740             case GCRY_CIPHER_CAMELLIA128:
741             case GCRY_CIPHER_CAMELLIA192:
742             case GCRY_CIPHER_CAMELLIA256:
743               h->bulk.cbc_dec = _gcry_camellia_cbc_dec;
744               h->bulk.cfb_dec = _gcry_camellia_cfb_dec;
745               h->bulk.ctr_enc = _gcry_camellia_ctr_enc;
746               break;
747 #endif /*USE_CAMELLIA*/
748 #ifdef USE_SERPENT
749             case GCRY_CIPHER_SERPENT128:
750             case GCRY_CIPHER_SERPENT192:
751             case GCRY_CIPHER_SERPENT256:
752               h->bulk.cbc_dec = _gcry_serpent_cbc_dec;
753               h->bulk.cfb_dec = _gcry_serpent_cfb_dec;
754               h->bulk.ctr_enc = _gcry_serpent_ctr_enc;
755               break;
756 #endif /*USE_SERPENT*/
757 #ifdef USE_TWOFISH
758             case GCRY_CIPHER_TWOFISH:
759             case GCRY_CIPHER_TWOFISH128:
760               h->bulk.cbc_dec = _gcry_twofish_cbc_dec;
761               h->bulk.cfb_dec = _gcry_twofish_cfb_dec;
762               h->bulk.ctr_enc = _gcry_twofish_ctr_enc;
763               break;
764 #endif /*USE_TWOFISH*/
765
766             default:
767               break;
768             }
769         }
770     }
771
772   /* Done.  */
773
774   if (err)
775     {
776       if (module)
777         {
778           /* Release module.  */
779           ath_mutex_lock (&ciphers_registered_lock);
780           _gcry_module_release (module);
781           ath_mutex_unlock (&ciphers_registered_lock);
782         }
783     }
784
785   *handle = err ? NULL : h;
786
787   return gcry_error (err);
788 }
789
790
791 /* Release all resources associated with the cipher handle H. H may be
792    NULL in which case this is a no-operation. */
793 void
794 gcry_cipher_close (gcry_cipher_hd_t h)
795 {
796   size_t off;
797
798   if (!h)
799     return;
800
801   if ((h->magic != CTX_MAGIC_SECURE)
802       && (h->magic != CTX_MAGIC_NORMAL))
803     _gcry_fatal_error(GPG_ERR_INTERNAL,
804                       "gcry_cipher_close: already closed/invalid handle");
805   else
806     h->magic = 0;
807
808   /* Release module.  */
809   ath_mutex_lock (&ciphers_registered_lock);
810   _gcry_module_release (h->module);
811   ath_mutex_unlock (&ciphers_registered_lock);
812
813   /* We always want to wipe out the memory even when the context has
814      been allocated in secure memory.  The user might have disabled
815      secure memory or is using his own implementation which does not
816      do the wiping.  To accomplish this we need to keep track of the
817      actual size of this structure because we have no way to known
818      how large the allocated area was when using a standard malloc. */
819   off = h->handle_offset;
820   wipememory (h, h->actual_handle_size);
821
822   gcry_free ((char*)h - off);
823 }
824
825
826 /* Set the key to be used for the encryption context C to KEY with
827    length KEYLEN.  The length should match the required length. */
828 static gcry_error_t
829 cipher_setkey (gcry_cipher_hd_t c, byte *key, unsigned int keylen)
830 {
831   gcry_err_code_t ret;
832
833   ret = (*c->cipher->setkey) (&c->context.c, key, keylen);
834   if (!ret)
835     {
836       /* Duplicate initial context.  */
837       memcpy ((void *) ((char *) &c->context.c + c->cipher->contextsize),
838               (void *) &c->context.c,
839               c->cipher->contextsize);
840       c->marks.key = 1;
841     }
842   else
843     c->marks.key = 0;
844
845   return gcry_error (ret);
846 }
847
848
849 /* Set the IV to be used for the encryption context C to IV with
850    length IVLEN.  The length should match the required length. */
851 static void
852 cipher_setiv (gcry_cipher_hd_t c, const byte *iv, unsigned ivlen)
853 {
854   /* If the cipher has its own IV handler, we use only this one.  This
855      is currently used for stream ciphers requiring a nonce.  */
856   if (c->extraspec && c->extraspec->setiv)
857     {
858       c->extraspec->setiv (&c->context.c, iv, ivlen);
859       return;
860     }
861
862   memset (c->u_iv.iv, 0, c->cipher->blocksize);
863   if (iv)
864     {
865       if (ivlen != c->cipher->blocksize)
866         {
867           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
868                     ivlen, (unsigned int)c->cipher->blocksize);
869           fips_signal_error ("IV length does not match blocklength");
870         }
871       if (ivlen > c->cipher->blocksize)
872         ivlen = c->cipher->blocksize;
873       memcpy (c->u_iv.iv, iv, ivlen);
874       c->marks.iv = 1;
875     }
876   else
877       c->marks.iv = 0;
878   c->unused = 0;
879 }
880
881
882 /* Reset the cipher context to the initial context.  This is basically
883    the same as an release followed by a new. */
884 static void
885 cipher_reset (gcry_cipher_hd_t c)
886 {
887   memcpy (&c->context.c,
888           (char *) &c->context.c + c->cipher->contextsize,
889           c->cipher->contextsize);
890   memset (&c->marks, 0, sizeof c->marks);
891   memset (c->u_iv.iv, 0, c->cipher->blocksize);
892   memset (c->lastiv, 0, c->cipher->blocksize);
893   memset (c->u_ctr.ctr, 0, c->cipher->blocksize);
894 }
895
896
897 \f
898 static gcry_err_code_t
899 do_ecb_encrypt (gcry_cipher_hd_t c,
900                 unsigned char *outbuf, unsigned int outbuflen,
901                 const unsigned char *inbuf, unsigned int inbuflen)
902 {
903   unsigned int blocksize = c->cipher->blocksize;
904   unsigned int n, nblocks;
905
906   if (outbuflen < inbuflen)
907     return GPG_ERR_BUFFER_TOO_SHORT;
908   if ((inbuflen % blocksize))
909     return GPG_ERR_INV_LENGTH;
910
911   nblocks = inbuflen / c->cipher->blocksize;
912
913   for (n=0; n < nblocks; n++ )
914     {
915       c->cipher->encrypt (&c->context.c, outbuf, (byte*)/*arggg*/inbuf);
916       inbuf  += blocksize;
917       outbuf += blocksize;
918     }
919   return 0;
920 }
921
922 static gcry_err_code_t
923 do_ecb_decrypt (gcry_cipher_hd_t c,
924                 unsigned char *outbuf, unsigned int outbuflen,
925                 const unsigned char *inbuf, unsigned int inbuflen)
926 {
927   unsigned int blocksize = c->cipher->blocksize;
928   unsigned int n, nblocks;
929
930   if (outbuflen < inbuflen)
931     return GPG_ERR_BUFFER_TOO_SHORT;
932   if ((inbuflen % blocksize))
933     return GPG_ERR_INV_LENGTH;
934   nblocks = inbuflen / c->cipher->blocksize;
935
936   for (n=0; n < nblocks; n++ )
937     {
938       c->cipher->decrypt (&c->context.c, outbuf, (byte*)/*arggg*/inbuf );
939       inbuf  += blocksize;
940       outbuf += blocksize;
941     }
942
943   return 0;
944 }
945
946
947 /****************
948  * Encrypt INBUF to OUTBUF with the mode selected at open.
949  * inbuf and outbuf may overlap or be the same.
950  * Depending on the mode some constraints apply to INBUFLEN.
951  */
952 static gcry_err_code_t
953 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
954                 const byte *inbuf, unsigned int inbuflen)
955 {
956   gcry_err_code_t rc;
957
958   switch (c->mode)
959     {
960     case GCRY_CIPHER_MODE_ECB:
961       rc = do_ecb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
962       break;
963
964     case GCRY_CIPHER_MODE_CBC:
965       rc = _gcry_cipher_cbc_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
966       break;
967
968     case GCRY_CIPHER_MODE_CFB:
969       rc = _gcry_cipher_cfb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
970       break;
971
972     case GCRY_CIPHER_MODE_OFB:
973       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
974       break;
975
976     case GCRY_CIPHER_MODE_CTR:
977       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
978       break;
979
980     case GCRY_CIPHER_MODE_AESWRAP:
981       rc = _gcry_cipher_aeswrap_encrypt (c, outbuf, outbuflen,
982                                          inbuf, inbuflen);
983       break;
984
985     case GCRY_CIPHER_MODE_STREAM:
986       c->cipher->stencrypt (&c->context.c,
987                             outbuf, (byte*)/*arggg*/inbuf, inbuflen);
988       rc = 0;
989       break;
990
991     case GCRY_CIPHER_MODE_NONE:
992       if (fips_mode () || !_gcry_get_debug_flag (0))
993         {
994           fips_signal_error ("cipher mode NONE used");
995           rc = GPG_ERR_INV_CIPHER_MODE;
996         }
997       else
998         {
999           if (inbuf != outbuf)
1000             memmove (outbuf, inbuf, inbuflen);
1001           rc = 0;
1002         }
1003       break;
1004
1005     default:
1006       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
1007       rc = GPG_ERR_INV_CIPHER_MODE;
1008       break;
1009     }
1010
1011   return rc;
1012 }
1013
1014
1015 /****************
1016  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
1017  * been requested.
1018  */
1019 gcry_error_t
1020 gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1021                      const void *in, size_t inlen)
1022 {
1023   gcry_err_code_t err;
1024
1025   if (!in)  /* Caller requested in-place encryption.  */
1026     err = cipher_encrypt (h, out, outsize, out, outsize);
1027   else
1028     err = cipher_encrypt (h, out, outsize, in, inlen);
1029
1030   /* Failsafe: Make sure that the plaintext will never make it into
1031      OUT if the encryption returned an error.  */
1032   if (err && out)
1033     memset (out, 0x42, outsize);
1034
1035   return gcry_error (err);
1036 }
1037
1038
1039
1040 /****************
1041  * Decrypt INBUF to OUTBUF with the mode selected at open.
1042  * inbuf and outbuf may overlap or be the same.
1043  * Depending on the mode some some contraints apply to INBUFLEN.
1044  */
1045 static gcry_err_code_t
1046 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
1047                 const byte *inbuf, unsigned int inbuflen)
1048 {
1049   gcry_err_code_t rc;
1050
1051   switch (c->mode)
1052     {
1053     case GCRY_CIPHER_MODE_ECB:
1054       rc = do_ecb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1055       break;
1056
1057     case GCRY_CIPHER_MODE_CBC:
1058       rc = _gcry_cipher_cbc_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1059       break;
1060
1061     case GCRY_CIPHER_MODE_CFB:
1062       rc = _gcry_cipher_cfb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1063       break;
1064
1065     case GCRY_CIPHER_MODE_OFB:
1066       rc = _gcry_cipher_ofb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1067       break;
1068
1069     case GCRY_CIPHER_MODE_CTR:
1070       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1071       break;
1072
1073     case GCRY_CIPHER_MODE_AESWRAP:
1074       rc = _gcry_cipher_aeswrap_decrypt (c, outbuf, outbuflen,
1075                                          inbuf, inbuflen);
1076       break;
1077
1078     case GCRY_CIPHER_MODE_STREAM:
1079       c->cipher->stdecrypt (&c->context.c,
1080                             outbuf, (byte*)/*arggg*/inbuf, inbuflen);
1081       rc = 0;
1082       break;
1083
1084     case GCRY_CIPHER_MODE_NONE:
1085       if (fips_mode () || !_gcry_get_debug_flag (0))
1086         {
1087           fips_signal_error ("cipher mode NONE used");
1088           rc = GPG_ERR_INV_CIPHER_MODE;
1089         }
1090       else
1091         {
1092           if (inbuf != outbuf)
1093             memmove (outbuf, inbuf, inbuflen);
1094           rc = 0;
1095         }
1096       break;
1097
1098     default:
1099       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1100       rc = GPG_ERR_INV_CIPHER_MODE;
1101       break;
1102     }
1103
1104   return rc;
1105 }
1106
1107
1108 gcry_error_t
1109 gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1110                      const void *in, size_t inlen)
1111 {
1112   gcry_err_code_t err;
1113
1114   if (!in) /* Caller requested in-place encryption. */
1115     err = cipher_decrypt (h, out, outsize, out, outsize);
1116   else
1117     err = cipher_decrypt (h, out, outsize, in, inlen);
1118
1119   return gcry_error (err);
1120 }
1121
1122
1123
1124 /****************
1125  * Used for PGP's somewhat strange CFB mode. Only works if
1126  * the corresponding flag is set.
1127  */
1128 static void
1129 cipher_sync (gcry_cipher_hd_t c)
1130 {
1131   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1132     {
1133       memmove (c->u_iv.iv + c->unused,
1134                c->u_iv.iv, c->cipher->blocksize - c->unused);
1135       memcpy (c->u_iv.iv,
1136               c->lastiv + c->cipher->blocksize - c->unused, c->unused);
1137       c->unused = 0;
1138     }
1139 }
1140
1141
1142 gcry_error_t
1143 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
1144 {
1145   return cipher_setkey (hd, (void*)key, keylen);
1146 }
1147
1148
1149 gcry_error_t
1150 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
1151 {
1152   cipher_setiv (hd, iv, ivlen);
1153   return 0;
1154 }
1155
1156 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1157    block size length, or (NULL,0) to set the CTR to the all-zero
1158    block. */
1159 gpg_error_t
1160 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1161 {
1162   if (ctr && ctrlen == hd->cipher->blocksize)
1163     {
1164       memcpy (hd->u_ctr.ctr, ctr, hd->cipher->blocksize);
1165       hd->unused = 0;
1166     }
1167   else if (!ctr || !ctrlen)
1168     {
1169       memset (hd->u_ctr.ctr, 0, hd->cipher->blocksize);
1170       hd->unused = 0;
1171     }
1172   else
1173     return gpg_error (GPG_ERR_INV_ARG);
1174   return 0;
1175 }
1176
1177
1178 gcry_error_t
1179 gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1180 {
1181   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1182
1183   switch (cmd)
1184     {
1185     case GCRYCTL_SET_KEY:  /* Deprecated; use gcry_cipher_setkey.  */
1186       rc = cipher_setkey( h, buffer, buflen );
1187       break;
1188
1189     case GCRYCTL_SET_IV:   /* Deprecated; use gcry_cipher_setiv.  */
1190       cipher_setiv( h, buffer, buflen );
1191       break;
1192
1193     case GCRYCTL_RESET:
1194       cipher_reset (h);
1195       break;
1196
1197     case GCRYCTL_CFB_SYNC:
1198       cipher_sync( h );
1199       break;
1200
1201     case GCRYCTL_SET_CBC_CTS:
1202       if (buflen)
1203         if (h->flags & GCRY_CIPHER_CBC_MAC)
1204           rc = GPG_ERR_INV_FLAG;
1205         else
1206           h->flags |= GCRY_CIPHER_CBC_CTS;
1207       else
1208         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1209       break;
1210
1211     case GCRYCTL_SET_CBC_MAC:
1212       if (buflen)
1213         if (h->flags & GCRY_CIPHER_CBC_CTS)
1214           rc = GPG_ERR_INV_FLAG;
1215         else
1216           h->flags |= GCRY_CIPHER_CBC_MAC;
1217       else
1218         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1219       break;
1220
1221     case GCRYCTL_DISABLE_ALGO:
1222       /* This command expects NULL for H and BUFFER to point to an
1223          integer with the algo number.  */
1224       if( h || !buffer || buflen != sizeof(int) )
1225         return gcry_error (GPG_ERR_CIPHER_ALGO);
1226       disable_cipher_algo( *(int*)buffer );
1227       break;
1228
1229     case GCRYCTL_SET_CTR: /* Deprecated; use gcry_cipher_setctr.  */
1230       rc = gpg_err_code (_gcry_cipher_setctr (h, buffer, buflen));
1231       break;
1232
1233     case 61:  /* Disable weak key detection (private).  */
1234       if (h->extraspec->set_extra_info)
1235         rc = h->extraspec->set_extra_info
1236           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1237       else
1238         rc = GPG_ERR_NOT_SUPPORTED;
1239       break;
1240
1241     case 62: /* Return current input vector (private).  */
1242       /* This is the input block as used in CFB and OFB mode which has
1243          initially been set as IV.  The returned format is:
1244            1 byte  Actual length of the block in bytes.
1245            n byte  The block.
1246          If the provided buffer is too short, an error is returned. */
1247       if (buflen < (1 + h->cipher->blocksize))
1248         rc = GPG_ERR_TOO_SHORT;
1249       else
1250         {
1251           unsigned char *ivp;
1252           unsigned char *dst = buffer;
1253           int n = h->unused;
1254
1255           if (!n)
1256             n = h->cipher->blocksize;
1257           gcry_assert (n <= h->cipher->blocksize);
1258           *dst++ = n;
1259           ivp = h->u_iv.iv + h->cipher->blocksize - n;
1260           while (n--)
1261             *dst++ = *ivp++;
1262         }
1263       break;
1264
1265     default:
1266       rc = GPG_ERR_INV_OP;
1267     }
1268
1269   return gcry_error (rc);
1270 }
1271
1272
1273 /* Return information about the cipher handle H.  CMD is the kind of
1274    information requested.  BUFFER and NBYTES are reserved for now.
1275
1276    There are no values for CMD yet defined.
1277
1278    The function always returns GPG_ERR_INV_OP.
1279
1280  */
1281 gcry_error_t
1282 gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1283 {
1284   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1285
1286   (void)h;
1287   (void)buffer;
1288   (void)nbytes;
1289
1290   switch (cmd)
1291     {
1292     default:
1293       err = GPG_ERR_INV_OP;
1294     }
1295
1296   return gcry_error (err);
1297 }
1298
1299 /* Return information about the given cipher algorithm ALGO.
1300
1301    WHAT select the kind of information returned:
1302
1303     GCRYCTL_GET_KEYLEN:
1304         Return the length of the key.  If the algorithm ALGO
1305         supports multiple key lengths, the maximum supported key length
1306         is returned.  The key length is returned as number of octets.
1307         BUFFER and NBYTES must be zero.
1308
1309     GCRYCTL_GET_BLKLEN:
1310         Return the blocklength of the algorithm ALGO counted in octets.
1311         BUFFER and NBYTES must be zero.
1312
1313     GCRYCTL_TEST_ALGO:
1314         Returns 0 if the specified algorithm ALGO is available for use.
1315         BUFFER and NBYTES must be zero.
1316
1317    Note: Because this function is in most cases used to return an
1318    integer value, we can make it easier for the caller to just look at
1319    the return value.  The caller will in all cases consult the value
1320    and thereby detecting whether a error occurred or not (i.e. while
1321    checking the block size)
1322  */
1323 gcry_error_t
1324 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1325 {
1326   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1327   unsigned int ui;
1328
1329   switch (what)
1330     {
1331     case GCRYCTL_GET_KEYLEN:
1332       if (buffer || (! nbytes))
1333         err = GPG_ERR_CIPHER_ALGO;
1334       else
1335         {
1336           ui = cipher_get_keylen (algo);
1337           if ((ui > 0) && (ui <= 512))
1338             *nbytes = (size_t) ui / 8;
1339           else
1340             /* The only reason for an error is an invalid algo.  */
1341             err = GPG_ERR_CIPHER_ALGO;
1342         }
1343       break;
1344
1345     case GCRYCTL_GET_BLKLEN:
1346       if (buffer || (! nbytes))
1347         err = GPG_ERR_CIPHER_ALGO;
1348       else
1349         {
1350           ui = cipher_get_blocksize (algo);
1351           if ((ui > 0) && (ui < 10000))
1352             *nbytes = ui;
1353           else
1354             /* The only reason is an invalid algo or a strange
1355                blocksize.  */
1356             err = GPG_ERR_CIPHER_ALGO;
1357         }
1358       break;
1359
1360     case GCRYCTL_TEST_ALGO:
1361       if (buffer || nbytes)
1362         err = GPG_ERR_INV_ARG;
1363       else
1364         err = check_cipher_algo (algo);
1365       break;
1366
1367       default:
1368         err = GPG_ERR_INV_OP;
1369     }
1370
1371   return gcry_error (err);
1372 }
1373
1374
1375 /* This function returns length of the key for algorithm ALGO.  If the
1376    algorithm supports multiple key lengths, the maximum supported key
1377    length is returned.  On error 0 is returned.  The key length is
1378    returned as number of octets.
1379
1380    This is a convenience functions which should be preferred over
1381    gcry_cipher_algo_info because it allows for proper type
1382    checking.  */
1383 size_t
1384 gcry_cipher_get_algo_keylen (int algo)
1385 {
1386   size_t n;
1387
1388   if (gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1389     n = 0;
1390   return n;
1391 }
1392
1393 /* This functions returns the blocklength of the algorithm ALGO
1394    counted in octets.  On error 0 is returned.
1395
1396    This is a convenience functions which should be preferred over
1397    gcry_cipher_algo_info because it allows for proper type
1398    checking.  */
1399 size_t
1400 gcry_cipher_get_algo_blklen (int algo)
1401 {
1402   size_t n;
1403
1404   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1405     n = 0;
1406   return n;
1407 }
1408
1409 /* Explicitly initialize this module.  */
1410 gcry_err_code_t
1411 _gcry_cipher_init (void)
1412 {
1413   gcry_err_code_t err;
1414
1415   err = ath_mutex_init (&ciphers_registered_lock);
1416   if (err)
1417     return gpg_err_code_from_errno (err);
1418
1419   REGISTER_DEFAULT_CIPHERS;
1420
1421   return err;
1422 }
1423
1424
1425 /* Run the selftests for cipher algorithm ALGO with optional reporting
1426    function REPORT.  */
1427 gpg_error_t
1428 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
1429 {
1430   gcry_module_t module = NULL;
1431   cipher_extra_spec_t *extraspec = NULL;
1432   gcry_err_code_t ec = 0;
1433
1434   REGISTER_DEFAULT_CIPHERS;
1435
1436   ath_mutex_lock (&ciphers_registered_lock);
1437   module = _gcry_module_lookup_id (ciphers_registered, algo);
1438   if (module && !(module->flags & FLAG_MODULE_DISABLED))
1439     extraspec = module->extraspec;
1440   ath_mutex_unlock (&ciphers_registered_lock);
1441   if (extraspec && extraspec->selftest)
1442     ec = extraspec->selftest (algo, extended, report);
1443   else
1444     {
1445       ec = GPG_ERR_CIPHER_ALGO;
1446       if (report)
1447         report ("cipher", algo, "module",
1448                 module && !(module->flags & FLAG_MODULE_DISABLED)?
1449                 "no selftest available" :
1450                 module? "algorithm disabled" : "algorithm not found");
1451     }
1452
1453   if (module)
1454     {
1455       ath_mutex_lock (&ciphers_registered_lock);
1456       _gcry_module_release (module);
1457       ath_mutex_unlock (&ciphers_registered_lock);
1458     }
1459   return gpg_error (ec);
1460 }