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