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