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