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