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