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