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