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