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