389bf7a6a14460c9b99af61e8072300ff84b4d49
[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
722             default:
723               break;
724             }
725         }
726     }
727
728   /* Done.  */
729
730   if (err)
731     {
732       if (module)
733         {
734           /* Release module.  */
735           ath_mutex_lock (&ciphers_registered_lock);
736           _gcry_module_release (module);
737           ath_mutex_unlock (&ciphers_registered_lock);
738         }
739     }
740
741   *handle = err ? NULL : h;
742
743   return gcry_error (err);
744 }
745
746
747 /* Release all resources associated with the cipher handle H. H may be
748    NULL in which case this is a no-operation. */
749 void
750 gcry_cipher_close (gcry_cipher_hd_t h)
751 {
752   size_t off;
753
754   if (!h)
755     return;
756
757   if ((h->magic != CTX_MAGIC_SECURE)
758       && (h->magic != CTX_MAGIC_NORMAL))
759     _gcry_fatal_error(GPG_ERR_INTERNAL,
760                       "gcry_cipher_close: already closed/invalid handle");
761   else
762     h->magic = 0;
763
764   /* Release module.  */
765   ath_mutex_lock (&ciphers_registered_lock);
766   _gcry_module_release (h->module);
767   ath_mutex_unlock (&ciphers_registered_lock);
768
769   /* We always want to wipe out the memory even when the context has
770      been allocated in secure memory.  The user might have disabled
771      secure memory or is using his own implementation which does not
772      do the wiping.  To accomplish this we need to keep track of the
773      actual size of this structure because we have no way to known
774      how large the allocated area was when using a standard malloc. */
775   off = h->handle_offset;
776   wipememory (h, h->actual_handle_size);
777
778   gcry_free ((char*)h - off);
779 }
780
781
782 /* Set the key to be used for the encryption context C to KEY with
783    length KEYLEN.  The length should match the required length. */
784 static gcry_error_t
785 cipher_setkey (gcry_cipher_hd_t c, byte *key, unsigned int keylen)
786 {
787   gcry_err_code_t ret;
788
789   ret = (*c->cipher->setkey) (&c->context.c, key, keylen);
790   if (!ret)
791     {
792       /* Duplicate initial context.  */
793       memcpy ((void *) ((char *) &c->context.c + c->cipher->contextsize),
794               (void *) &c->context.c,
795               c->cipher->contextsize);
796       c->marks.key = 1;
797     }
798   else
799     c->marks.key = 0;
800
801   return gcry_error (ret);
802 }
803
804
805 /* Set the IV to be used for the encryption context C to IV with
806    length IVLEN.  The length should match the required length. */
807 static void
808 cipher_setiv( gcry_cipher_hd_t c, const byte *iv, unsigned ivlen )
809 {
810   memset (c->u_iv.iv, 0, c->cipher->blocksize);
811   if (iv)
812     {
813       if (ivlen != c->cipher->blocksize)
814         {
815           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
816                     ivlen, (unsigned int)c->cipher->blocksize);
817           fips_signal_error ("IV length does not match blocklength");
818         }
819       if (ivlen > c->cipher->blocksize)
820         ivlen = c->cipher->blocksize;
821       memcpy (c->u_iv.iv, iv, ivlen);
822       c->marks.iv = 1;
823     }
824   else
825       c->marks.iv = 0;
826   c->unused = 0;
827 }
828
829
830 /* Reset the cipher context to the initial context.  This is basically
831    the same as an release followed by a new. */
832 static void
833 cipher_reset (gcry_cipher_hd_t c)
834 {
835   memcpy (&c->context.c,
836           (char *) &c->context.c + c->cipher->contextsize,
837           c->cipher->contextsize);
838   memset (&c->marks, 0, sizeof c->marks);
839   memset (c->u_iv.iv, 0, c->cipher->blocksize);
840   memset (c->lastiv, 0, c->cipher->blocksize);
841   memset (c->u_ctr.ctr, 0, c->cipher->blocksize);
842 }
843
844
845 \f
846 static gcry_err_code_t
847 do_ecb_encrypt (gcry_cipher_hd_t c,
848                 unsigned char *outbuf, unsigned int outbuflen,
849                 const unsigned char *inbuf, unsigned int inbuflen)
850 {
851   unsigned int blocksize = c->cipher->blocksize;
852   unsigned int n, nblocks;
853
854   if (outbuflen < inbuflen)
855     return GPG_ERR_BUFFER_TOO_SHORT;
856   if ((inbuflen % blocksize))
857     return GPG_ERR_INV_LENGTH;
858
859   nblocks = inbuflen / c->cipher->blocksize;
860
861   for (n=0; n < nblocks; n++ )
862     {
863       c->cipher->encrypt (&c->context.c, outbuf, (byte*)/*arggg*/inbuf);
864       inbuf  += blocksize;
865       outbuf += blocksize;
866     }
867   return 0;
868 }
869
870 static gcry_err_code_t
871 do_ecb_decrypt (gcry_cipher_hd_t c,
872                 unsigned char *outbuf, unsigned int outbuflen,
873                 const unsigned char *inbuf, unsigned int inbuflen)
874 {
875   unsigned int blocksize = c->cipher->blocksize;
876   unsigned int n, nblocks;
877
878   if (outbuflen < inbuflen)
879     return GPG_ERR_BUFFER_TOO_SHORT;
880   if ((inbuflen % blocksize))
881     return GPG_ERR_INV_LENGTH;
882   nblocks = inbuflen / c->cipher->blocksize;
883
884   for (n=0; n < nblocks; n++ )
885     {
886       c->cipher->decrypt (&c->context.c, outbuf, (byte*)/*arggg*/inbuf );
887       inbuf  += blocksize;
888       outbuf += blocksize;
889     }
890
891   return 0;
892 }
893
894
895 /****************
896  * Encrypt INBUF to OUTBUF with the mode selected at open.
897  * inbuf and outbuf may overlap or be the same.
898  * Depending on the mode some constraints apply to INBUFLEN.
899  */
900 static gcry_err_code_t
901 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
902                 const byte *inbuf, unsigned int inbuflen)
903 {
904   gcry_err_code_t rc;
905
906   switch (c->mode)
907     {
908     case GCRY_CIPHER_MODE_ECB:
909       rc = do_ecb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
910       break;
911
912     case GCRY_CIPHER_MODE_CBC:
913       rc = _gcry_cipher_cbc_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
914       break;
915
916     case GCRY_CIPHER_MODE_CFB:
917       rc = _gcry_cipher_cfb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
918       break;
919
920     case GCRY_CIPHER_MODE_OFB:
921       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
922       break;
923
924     case GCRY_CIPHER_MODE_CTR:
925       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
926       break;
927
928     case GCRY_CIPHER_MODE_AESWRAP:
929       rc = _gcry_cipher_aeswrap_encrypt (c, outbuf, outbuflen,
930                                          inbuf, inbuflen);
931       break;
932
933     case GCRY_CIPHER_MODE_STREAM:
934       c->cipher->stencrypt (&c->context.c,
935                             outbuf, (byte*)/*arggg*/inbuf, inbuflen);
936       rc = 0;
937       break;
938
939     case GCRY_CIPHER_MODE_NONE:
940       if (fips_mode () || !_gcry_get_debug_flag (0))
941         {
942           fips_signal_error ("cipher mode NONE used");
943           rc = GPG_ERR_INV_CIPHER_MODE;
944         }
945       else
946         {
947           if (inbuf != outbuf)
948             memmove (outbuf, inbuf, inbuflen);
949           rc = 0;
950         }
951       break;
952
953     default:
954       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
955       rc = GPG_ERR_INV_CIPHER_MODE;
956       break;
957     }
958
959   return rc;
960 }
961
962
963 /****************
964  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
965  * been requested.
966  */
967 gcry_error_t
968 gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
969                      const void *in, size_t inlen)
970 {
971   gcry_err_code_t err;
972
973   if (!in)  /* Caller requested in-place encryption.  */
974     err = cipher_encrypt (h, out, outsize, out, outsize);
975   else
976     err = cipher_encrypt (h, out, outsize, in, inlen);
977
978   /* Failsafe: Make sure that the plaintext will never make it into
979      OUT if the encryption returned an error.  */
980   if (err && out)
981     memset (out, 0x42, outsize);
982
983   return gcry_error (err);
984 }
985
986
987
988 /****************
989  * Decrypt INBUF to OUTBUF with the mode selected at open.
990  * inbuf and outbuf may overlap or be the same.
991  * Depending on the mode some some contraints apply to INBUFLEN.
992  */
993 static gcry_err_code_t
994 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
995                 const byte *inbuf, unsigned int inbuflen)
996 {
997   gcry_err_code_t rc;
998
999   switch (c->mode)
1000     {
1001     case GCRY_CIPHER_MODE_ECB:
1002       rc = do_ecb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1003       break;
1004
1005     case GCRY_CIPHER_MODE_CBC:
1006       rc = _gcry_cipher_cbc_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1007       break;
1008
1009     case GCRY_CIPHER_MODE_CFB:
1010       rc = _gcry_cipher_cfb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1011       break;
1012
1013     case GCRY_CIPHER_MODE_OFB:
1014       rc = _gcry_cipher_ofb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1015       break;
1016
1017     case GCRY_CIPHER_MODE_CTR:
1018       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1019       break;
1020
1021     case GCRY_CIPHER_MODE_AESWRAP:
1022       rc = _gcry_cipher_aeswrap_decrypt (c, outbuf, outbuflen,
1023                                          inbuf, inbuflen);
1024       break;
1025
1026     case GCRY_CIPHER_MODE_STREAM:
1027       c->cipher->stdecrypt (&c->context.c,
1028                             outbuf, (byte*)/*arggg*/inbuf, inbuflen);
1029       rc = 0;
1030       break;
1031
1032     case GCRY_CIPHER_MODE_NONE:
1033       if (fips_mode () || !_gcry_get_debug_flag (0))
1034         {
1035           fips_signal_error ("cipher mode NONE used");
1036           rc = GPG_ERR_INV_CIPHER_MODE;
1037         }
1038       else
1039         {
1040           if (inbuf != outbuf)
1041             memmove (outbuf, inbuf, inbuflen);
1042           rc = 0;
1043         }
1044       break;
1045
1046     default:
1047       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1048       rc = GPG_ERR_INV_CIPHER_MODE;
1049       break;
1050     }
1051
1052   return rc;
1053 }
1054
1055
1056 gcry_error_t
1057 gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1058                      const void *in, size_t inlen)
1059 {
1060   gcry_err_code_t err;
1061
1062   if (!in) /* Caller requested in-place encryption. */
1063     err = cipher_decrypt (h, out, outsize, out, outsize);
1064   else
1065     err = cipher_decrypt (h, out, outsize, in, inlen);
1066
1067   return gcry_error (err);
1068 }
1069
1070
1071
1072 /****************
1073  * Used for PGP's somewhat strange CFB mode. Only works if
1074  * the corresponding flag is set.
1075  */
1076 static void
1077 cipher_sync (gcry_cipher_hd_t c)
1078 {
1079   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1080     {
1081       memmove (c->u_iv.iv + c->unused,
1082                c->u_iv.iv, c->cipher->blocksize - c->unused);
1083       memcpy (c->u_iv.iv,
1084               c->lastiv + c->cipher->blocksize - c->unused, c->unused);
1085       c->unused = 0;
1086     }
1087 }
1088
1089
1090 gcry_error_t
1091 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
1092 {
1093   return cipher_setkey (hd, (void*)key, keylen);
1094 }
1095
1096
1097 gcry_error_t
1098 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
1099 {
1100   cipher_setiv (hd, iv, ivlen);
1101   return 0;
1102 }
1103
1104 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1105    block size length, or (NULL,0) to set the CTR to the all-zero
1106    block. */
1107 gpg_error_t
1108 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1109 {
1110   if (ctr && ctrlen == hd->cipher->blocksize)
1111     {
1112       memcpy (hd->u_ctr.ctr, ctr, hd->cipher->blocksize);
1113       hd->unused = 0;
1114     }
1115   else if (!ctr || !ctrlen)
1116     {
1117       memset (hd->u_ctr.ctr, 0, hd->cipher->blocksize);
1118       hd->unused = 0;
1119     }
1120   else
1121     return gpg_error (GPG_ERR_INV_ARG);
1122   return 0;
1123 }
1124
1125
1126 gcry_error_t
1127 gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1128 {
1129   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1130
1131   switch (cmd)
1132     {
1133     case GCRYCTL_SET_KEY:  /* Deprecated; use gcry_cipher_setkey.  */
1134       rc = cipher_setkey( h, buffer, buflen );
1135       break;
1136
1137     case GCRYCTL_SET_IV:   /* Deprecated; use gcry_cipher_setiv.  */
1138       cipher_setiv( h, buffer, buflen );
1139       break;
1140
1141     case GCRYCTL_RESET:
1142       cipher_reset (h);
1143       break;
1144
1145     case GCRYCTL_CFB_SYNC:
1146       cipher_sync( h );
1147       break;
1148
1149     case GCRYCTL_SET_CBC_CTS:
1150       if (buflen)
1151         if (h->flags & GCRY_CIPHER_CBC_MAC)
1152           rc = GPG_ERR_INV_FLAG;
1153         else
1154           h->flags |= GCRY_CIPHER_CBC_CTS;
1155       else
1156         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1157       break;
1158
1159     case GCRYCTL_SET_CBC_MAC:
1160       if (buflen)
1161         if (h->flags & GCRY_CIPHER_CBC_CTS)
1162           rc = GPG_ERR_INV_FLAG;
1163         else
1164           h->flags |= GCRY_CIPHER_CBC_MAC;
1165       else
1166         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1167       break;
1168
1169     case GCRYCTL_DISABLE_ALGO:
1170       /* This command expects NULL for H and BUFFER to point to an
1171          integer with the algo number.  */
1172       if( h || !buffer || buflen != sizeof(int) )
1173         return gcry_error (GPG_ERR_CIPHER_ALGO);
1174       disable_cipher_algo( *(int*)buffer );
1175       break;
1176
1177     case GCRYCTL_SET_CTR: /* Deprecated; use gcry_cipher_setctr.  */
1178       rc = gpg_err_code (_gcry_cipher_setctr (h, buffer, buflen));
1179       break;
1180
1181     case 61:  /* Disable weak key detection (private).  */
1182       if (h->extraspec->set_extra_info)
1183         rc = h->extraspec->set_extra_info
1184           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1185       else
1186         rc = GPG_ERR_NOT_SUPPORTED;
1187       break;
1188
1189     case 62: /* Return current input vector (private).  */
1190       /* This is the input block as used in CFB and OFB mode which has
1191          initially been set as IV.  The returned format is:
1192            1 byte  Actual length of the block in bytes.
1193            n byte  The block.
1194          If the provided buffer is too short, an error is returned. */
1195       if (buflen < (1 + h->cipher->blocksize))
1196         rc = GPG_ERR_TOO_SHORT;
1197       else
1198         {
1199           unsigned char *ivp;
1200           unsigned char *dst = buffer;
1201           int n = h->unused;
1202
1203           if (!n)
1204             n = h->cipher->blocksize;
1205           gcry_assert (n <= h->cipher->blocksize);
1206           *dst++ = n;
1207           ivp = h->u_iv.iv + h->cipher->blocksize - n;
1208           while (n--)
1209             *dst++ = *ivp++;
1210         }
1211       break;
1212
1213     default:
1214       rc = GPG_ERR_INV_OP;
1215     }
1216
1217   return gcry_error (rc);
1218 }
1219
1220
1221 /* Return information about the cipher handle H.  CMD is the kind of
1222    information requested.  BUFFER and NBYTES are reserved for now.
1223
1224    There are no values for CMD yet defined.
1225
1226    The function always returns GPG_ERR_INV_OP.
1227
1228  */
1229 gcry_error_t
1230 gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1231 {
1232   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1233
1234   (void)h;
1235   (void)buffer;
1236   (void)nbytes;
1237
1238   switch (cmd)
1239     {
1240     default:
1241       err = GPG_ERR_INV_OP;
1242     }
1243
1244   return gcry_error (err);
1245 }
1246
1247 /* Return information about the given cipher algorithm ALGO.
1248
1249    WHAT select the kind of information returned:
1250
1251     GCRYCTL_GET_KEYLEN:
1252         Return the length of the key.  If the algorithm ALGO
1253         supports multiple key lengths, the maximum supported key length
1254         is returned.  The key length is returned as number of octets.
1255         BUFFER and NBYTES must be zero.
1256
1257     GCRYCTL_GET_BLKLEN:
1258         Return the blocklength of the algorithm ALGO counted in octets.
1259         BUFFER and NBYTES must be zero.
1260
1261     GCRYCTL_TEST_ALGO:
1262         Returns 0 if the specified algorithm ALGO is available for use.
1263         BUFFER and NBYTES must be zero.
1264
1265    Note: Because this function is in most cases used to return an
1266    integer value, we can make it easier for the caller to just look at
1267    the return value.  The caller will in all cases consult the value
1268    and thereby detecting whether a error occurred or not (i.e. while
1269    checking the block size)
1270  */
1271 gcry_error_t
1272 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1273 {
1274   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1275   unsigned int ui;
1276
1277   switch (what)
1278     {
1279     case GCRYCTL_GET_KEYLEN:
1280       if (buffer || (! nbytes))
1281         err = GPG_ERR_CIPHER_ALGO;
1282       else
1283         {
1284           ui = cipher_get_keylen (algo);
1285           if ((ui > 0) && (ui <= 512))
1286             *nbytes = (size_t) ui / 8;
1287           else
1288             /* The only reason for an error is an invalid algo.  */
1289             err = GPG_ERR_CIPHER_ALGO;
1290         }
1291       break;
1292
1293     case GCRYCTL_GET_BLKLEN:
1294       if (buffer || (! nbytes))
1295         err = GPG_ERR_CIPHER_ALGO;
1296       else
1297         {
1298           ui = cipher_get_blocksize (algo);
1299           if ((ui > 0) && (ui < 10000))
1300             *nbytes = ui;
1301           else
1302             /* The only reason is an invalid algo or a strange
1303                blocksize.  */
1304             err = GPG_ERR_CIPHER_ALGO;
1305         }
1306       break;
1307
1308     case GCRYCTL_TEST_ALGO:
1309       if (buffer || nbytes)
1310         err = GPG_ERR_INV_ARG;
1311       else
1312         err = check_cipher_algo (algo);
1313       break;
1314
1315       default:
1316         err = GPG_ERR_INV_OP;
1317     }
1318
1319   return gcry_error (err);
1320 }
1321
1322
1323 /* This function returns length of the key for algorithm ALGO.  If the
1324    algorithm supports multiple key lengths, the maximum supported key
1325    length is returned.  On error 0 is returned.  The key length is
1326    returned as number of octets.
1327
1328    This is a convenience functions which should be preferred over
1329    gcry_cipher_algo_info because it allows for proper type
1330    checking.  */
1331 size_t
1332 gcry_cipher_get_algo_keylen (int algo)
1333 {
1334   size_t n;
1335
1336   if (gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1337     n = 0;
1338   return n;
1339 }
1340
1341 /* This functions returns the blocklength of the algorithm ALGO
1342    counted in octets.  On error 0 is returned.
1343
1344    This is a convenience functions which should be preferred over
1345    gcry_cipher_algo_info because it allows for proper type
1346    checking.  */
1347 size_t
1348 gcry_cipher_get_algo_blklen (int algo)
1349 {
1350   size_t n;
1351
1352   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1353     n = 0;
1354   return n;
1355 }
1356
1357 /* Explicitly initialize this module.  */
1358 gcry_err_code_t
1359 _gcry_cipher_init (void)
1360 {
1361   gcry_err_code_t err;
1362
1363   err = ath_mutex_init (&ciphers_registered_lock);
1364   if (err)
1365     return gpg_err_code_from_errno (err);
1366
1367   REGISTER_DEFAULT_CIPHERS;
1368
1369   return err;
1370 }
1371
1372
1373 /* Run the selftests for cipher algorithm ALGO with optional reporting
1374    function REPORT.  */
1375 gpg_error_t
1376 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
1377 {
1378   gcry_module_t module = NULL;
1379   cipher_extra_spec_t *extraspec = NULL;
1380   gcry_err_code_t ec = 0;
1381
1382   REGISTER_DEFAULT_CIPHERS;
1383
1384   ath_mutex_lock (&ciphers_registered_lock);
1385   module = _gcry_module_lookup_id (ciphers_registered, algo);
1386   if (module && !(module->flags & FLAG_MODULE_DISABLED))
1387     extraspec = module->extraspec;
1388   ath_mutex_unlock (&ciphers_registered_lock);
1389   if (extraspec && extraspec->selftest)
1390     ec = extraspec->selftest (algo, extended, report);
1391   else
1392     {
1393       ec = GPG_ERR_CIPHER_ALGO;
1394       if (report)
1395         report ("cipher", algo, "module",
1396                 module && !(module->flags & FLAG_MODULE_DISABLED)?
1397                 "no selftest available" :
1398                 module? "algorithm disabled" : "algorithm not found");
1399     }
1400
1401   if (module)
1402     {
1403       ath_mutex_lock (&ciphers_registered_lock);
1404       _gcry_module_release (module);
1405       ath_mutex_unlock (&ciphers_registered_lock);
1406     }
1407   return gpg_error (ec);
1408 }