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