43576fa7fabc8a67b4a23891dbf179454d2ed180
[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   return cipher_algo_to_string (algorithm);
435 }
436
437
438 /* Flag the cipher algorithm with the identifier ALGORITHM as
439    disabled.  There is no error return, the function does nothing for
440    unknown algorithms.  Disabled algorithms are vitually not available
441    in Libgcrypt. */
442 static void
443 disable_cipher_algo (int algorithm)
444 {
445   gcry_module_t cipher;
446
447   REGISTER_DEFAULT_CIPHERS;
448
449   ath_mutex_lock (&ciphers_registered_lock);
450   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
451   if (cipher)
452     {
453       if (! (cipher->flags & FLAG_MODULE_DISABLED))
454         cipher->flags |= FLAG_MODULE_DISABLED;
455       _gcry_module_release (cipher);
456     }
457   ath_mutex_unlock (&ciphers_registered_lock);
458 }
459
460
461 /* Return 0 if the cipher algorithm with indentifier ALGORITHM is
462    available. Returns a basic error code value if it is not available.  */
463 static gcry_err_code_t
464 check_cipher_algo (int algorithm)
465 {
466   gcry_err_code_t err = GPG_ERR_NO_ERROR;
467   gcry_module_t cipher;
468
469   REGISTER_DEFAULT_CIPHERS;
470
471   ath_mutex_lock (&ciphers_registered_lock);
472   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
473   if (cipher)
474     {
475       if (cipher->flags & FLAG_MODULE_DISABLED)
476         err = GPG_ERR_CIPHER_ALGO;
477       _gcry_module_release (cipher);
478     }
479   else
480     err = GPG_ERR_CIPHER_ALGO;
481   ath_mutex_unlock (&ciphers_registered_lock);
482   
483   return err;
484 }
485
486
487 /* Return the standard length of the key for the cipher algorithm with
488    the identifier ALGORITHM.  This function expects a valid algorithm
489    and will abort if the algorithm is not available or the length of
490    the key is not known. */
491 static unsigned int
492 cipher_get_keylen (int algorithm)
493 {
494   gcry_module_t cipher;
495   unsigned len = 0;
496
497   REGISTER_DEFAULT_CIPHERS;
498
499   ath_mutex_lock (&ciphers_registered_lock);
500   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
501   if (cipher)
502     {
503       len = ((gcry_cipher_spec_t *) cipher->spec)->keylen;
504       if (! len)
505         log_bug ("cipher %d w/o key length\n", algorithm);
506       _gcry_module_release (cipher);
507     }
508   else
509     log_bug ("cipher %d not found\n", algorithm);
510   ath_mutex_unlock (&ciphers_registered_lock);
511
512   return len;
513 }
514
515 /* Return the block length of the cipher algorithm with the identifier
516    ALGORITHM.  This function expects a valid algorithm and will abort
517    if the algorithm is not available or the length of the key is not
518    known. */
519 static unsigned int
520 cipher_get_blocksize (int algorithm)
521 {
522   gcry_module_t cipher;
523   unsigned len = 0;
524
525   REGISTER_DEFAULT_CIPHERS;
526
527   ath_mutex_lock (&ciphers_registered_lock);
528   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
529   if (cipher)
530     {
531       len = ((gcry_cipher_spec_t *) cipher->spec)->blocksize;
532       if (! len)
533           log_bug ("cipher %d w/o blocksize\n", algorithm);
534       _gcry_module_release (cipher);
535     }
536   else
537     log_bug ("cipher %d not found\n", algorithm);
538   ath_mutex_unlock (&ciphers_registered_lock);
539
540   return len;
541 }
542
543
544 /*
545    Open a cipher handle for use with cipher algorithm ALGORITHM, using
546    the cipher mode MODE (one of the GCRY_CIPHER_MODE_*) and return a
547    handle in HANDLE.  Put NULL into HANDLE and return an error code if
548    something goes wrong.  FLAGS may be used to modify the
549    operation.  The defined flags are:
550
551    GCRY_CIPHER_SECURE:  allocate all internal buffers in secure memory.
552    GCRY_CIPHER_ENABLE_SYNC:  Enable the sync operation as used in OpenPGP.
553    GCRY_CIPHER_CBC_CTS:  Enable CTS mode.
554    GCRY_CIPHER_CBC_MAC:  Enable MAC mode.
555
556    Values for these flags may be combined using OR.
557  */
558 gcry_error_t
559 gcry_cipher_open (gcry_cipher_hd_t *handle,
560                   int algo, int mode, unsigned int flags)
561 {
562   int secure = (flags & GCRY_CIPHER_SECURE);
563   gcry_cipher_spec_t *cipher = NULL;
564   gcry_module_t module = NULL;
565   gcry_cipher_hd_t h = NULL;
566   gcry_err_code_t err = 0;
567
568   /* If the application missed to call the random poll function, we do
569      it here to ensure that it is used once in a while. */
570   _gcry_fast_random_poll ();
571   
572   REGISTER_DEFAULT_CIPHERS;
573
574   /* Fetch the according module and check wether the cipher is marked
575      available for use.  */
576   ath_mutex_lock (&ciphers_registered_lock);
577   module = _gcry_module_lookup_id (ciphers_registered, algo);
578   if (module)
579     {
580       /* Found module.  */
581
582       if (module->flags & FLAG_MODULE_DISABLED)
583         {
584           /* Not available for use.  */
585           err = GPG_ERR_CIPHER_ALGO;
586           _gcry_module_release (module);
587         }
588       else
589         cipher = (gcry_cipher_spec_t *) module->spec;
590     }
591   else
592     err = GPG_ERR_CIPHER_ALGO;
593   ath_mutex_unlock (&ciphers_registered_lock);
594
595   /* check flags */
596   if ((! err)
597       && ((flags & ~(0 
598                      | GCRY_CIPHER_SECURE
599                      | GCRY_CIPHER_ENABLE_SYNC
600                      | GCRY_CIPHER_CBC_CTS
601                      | GCRY_CIPHER_CBC_MAC))
602           || (flags & GCRY_CIPHER_CBC_CTS & GCRY_CIPHER_CBC_MAC)))
603     err = GPG_ERR_CIPHER_ALGO;
604
605   /* check that a valid mode has been requested */
606   if (! err)
607     switch (mode)
608       {
609       case GCRY_CIPHER_MODE_ECB:
610       case GCRY_CIPHER_MODE_CBC:
611       case GCRY_CIPHER_MODE_CFB:
612       case GCRY_CIPHER_MODE_OFB:
613       case GCRY_CIPHER_MODE_CTR:
614         if ((cipher->encrypt == dummy_encrypt_block)
615             || (cipher->decrypt == dummy_decrypt_block))
616           err = GPG_ERR_INV_CIPHER_MODE;
617         break;
618
619       case GCRY_CIPHER_MODE_STREAM:
620         if ((cipher->stencrypt == dummy_encrypt_stream)
621             || (cipher->stdecrypt == dummy_decrypt_stream))
622           err = GPG_ERR_INV_CIPHER_MODE;
623         break;
624
625       case GCRY_CIPHER_MODE_NONE:
626         /* FIXME: issue a warning when this mode is used */
627         break;
628
629       default:
630         err = GPG_ERR_INV_CIPHER_MODE;
631       }
632
633   /* ? FIXME: perform selftest here and mark this with a flag in
634      cipher_table ? */
635
636   if (! err)
637     {
638       size_t size = (sizeof (*h)
639                      + 2 * cipher->contextsize
640                      - sizeof (PROPERLY_ALIGNED_TYPE));
641
642       if (secure)
643         h = gcry_calloc_secure (1, size);
644       else
645         h = gcry_calloc (1, size);
646
647       if (! h)
648         err = gpg_err_code_from_errno (errno);
649       else
650         {
651           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
652           h->actual_handle_size = size;
653           h->cipher = cipher;
654           h->module = module;
655           h->mode = mode;
656           h->flags = flags;
657         }
658     }
659
660   /* Done.  */
661
662   if (err)
663     {
664       if (module)
665         {
666           /* Release module.  */
667           ath_mutex_lock (&ciphers_registered_lock);
668           _gcry_module_release (module);
669           ath_mutex_unlock (&ciphers_registered_lock);
670         }
671     }
672
673   *handle = err ? NULL : h;
674
675   return gcry_error (err);
676 }
677
678
679 /* Release all resources associated with the cipher handle H. H may be
680    NULL in which case this is a no-operation. */
681 void
682 gcry_cipher_close (gcry_cipher_hd_t h)
683 {
684   if (! h)
685     return;
686
687   if ((h->magic != CTX_MAGIC_SECURE)
688       && (h->magic != CTX_MAGIC_NORMAL))
689     _gcry_fatal_error(GPG_ERR_INTERNAL,
690                       "gcry_cipher_close: already closed/invalid handle");
691   else
692     h->magic = 0;
693
694   /* Release module.  */
695   ath_mutex_lock (&ciphers_registered_lock);
696   _gcry_module_release (h->module);
697   ath_mutex_unlock (&ciphers_registered_lock);
698
699   /* We always want to wipe out the memory even when the context has
700      been allocated in secure memory.  The user might have disabled
701      secure memory or is using his own implementation which does not
702      do the wiping.  To accomplish this we need to keep track of the
703      actual size of this structure because we have no way to known
704      how large the allocated area was when using a standard malloc. */
705   wipememory (h, h->actual_handle_size);
706
707   gcry_free (h);
708 }
709
710
711 /* Set the key to be used for the encryption context C to KEY with
712    length KEYLEN.  The length should match the required length. */
713 static gcry_error_t
714 cipher_setkey (gcry_cipher_hd_t c, byte *key, unsigned keylen)
715 {
716   gcry_err_code_t ret;
717
718   ret = (*c->cipher->setkey) (&c->context.c, key, keylen);
719   if (! ret)
720     /* Duplicate initial context.  */
721     memcpy ((void *) ((char *) &c->context.c + c->cipher->contextsize),
722             (void *) &c->context.c,
723             c->cipher->contextsize);
724
725   return gcry_error (ret);
726 }
727
728
729 /* Set the IV to be used for the encryption context C to IV with
730    length IVLEN.  The length should match the required length. */
731 static void
732 cipher_setiv( gcry_cipher_hd_t c, const byte *iv, unsigned ivlen )
733 {
734     memset( c->iv, 0, c->cipher->blocksize );
735     if( iv ) {
736         if( ivlen != c->cipher->blocksize )
737             log_info("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
738                      ivlen, (unsigned) c->cipher->blocksize );
739         if (ivlen > c->cipher->blocksize)
740           ivlen = c->cipher->blocksize;
741         memcpy( c->iv, iv, ivlen );
742     }
743     c->unused = 0;
744 }
745
746
747 /* Reset the cipher context to the initial contex.  This is basically
748    the same as an release followed by a new. */
749 static void
750 cipher_reset (gcry_cipher_hd_t c)
751 {
752   memcpy (&c->context.c,
753           (char *) &c->context.c + c->cipher->contextsize,
754           c->cipher->contextsize);
755   memset (c->iv, 0, c->cipher->blocksize);
756   memset (c->lastiv, 0, c->cipher->blocksize);
757   memset (c->ctr, 0, c->cipher->blocksize);
758 }
759
760
761 static void
762 do_ecb_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
763                 unsigned int nblocks )
764 {
765     unsigned int n;
766
767     for(n=0; n < nblocks; n++ ) {
768         c->cipher->encrypt ( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
769         inbuf  += c->cipher->blocksize;
770         outbuf += c->cipher->blocksize;
771     }
772 }
773
774 static void
775 do_ecb_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
776                 unsigned int nblocks )
777 {
778     unsigned n;
779
780     for(n=0; n < nblocks; n++ ) {
781         c->cipher->decrypt ( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
782         inbuf  += c->cipher->blocksize;
783         outbuf += c->cipher->blocksize;
784     }
785 }
786
787 static void
788 do_cbc_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
789                 unsigned int nbytes )
790 {
791     unsigned int n;
792     byte *ivp;
793     int i;
794     size_t blocksize = c->cipher->blocksize;
795     unsigned nblocks = nbytes / blocksize;
796
797     if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) {
798       if ((nbytes % blocksize) == 0)
799         nblocks--;
800     }
801
802     for(n=0; n < nblocks; n++ ) {
803         /* fixme: the xor should work on words and not on
804          * bytes.  Maybe it is a good idea to enhance the cipher backend
805          * API to allow for CBC handling direct in the backend */
806         for(ivp=c->iv,i=0; i < blocksize; i++ )
807             outbuf[i] = inbuf[i] ^ *ivp++;
808         c->cipher->encrypt ( &c->context.c, outbuf, outbuf );
809         memcpy(c->iv, outbuf, blocksize );
810         inbuf  += blocksize;
811         if (!(c->flags & GCRY_CIPHER_CBC_MAC))
812           outbuf += blocksize;
813     }
814
815     if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize)
816       {
817         /* We have to be careful here, since outbuf might be equal to
818            inbuf.  */
819
820         int restbytes;
821         byte b;
822
823         if ((nbytes % blocksize) == 0)
824           restbytes = blocksize;
825         else
826           restbytes = nbytes % blocksize;
827
828         outbuf -= blocksize;
829         for (ivp = c->iv, i = 0; i < restbytes; i++)
830           {
831             b = inbuf[i];
832             outbuf[blocksize + i] = outbuf[i];
833             outbuf[i] = b ^ *ivp++;
834           }
835         for (; i < blocksize; i++)
836           outbuf[i] = 0 ^ *ivp++;
837
838         c->cipher->encrypt (&c->context.c, outbuf, outbuf);
839         memcpy (c->iv, outbuf, blocksize);
840       }
841 }
842
843 static void
844 do_cbc_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
845                 unsigned int nbytes )
846 {
847     unsigned int n;
848     byte *ivp;
849     int i;
850     size_t blocksize = c->cipher->blocksize;
851     unsigned int nblocks = nbytes / blocksize;
852
853     if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) {
854       nblocks--;
855       if ((nbytes % blocksize) == 0)
856         nblocks--;
857       memcpy(c->lastiv, c->iv, blocksize );
858     }
859
860     for(n=0; n < nblocks; n++ ) {
861         /* Because outbuf and inbuf might be the same, we have
862          * to save the original ciphertext block.  We use lastiv
863          * for this here because it is not used otherwise. */
864         memcpy(c->lastiv, inbuf, blocksize );
865         c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
866         for(ivp=c->iv,i=0; i < blocksize; i++ )
867             outbuf[i] ^= *ivp++;
868         memcpy(c->iv, c->lastiv, blocksize );
869         inbuf  += c->cipher->blocksize;
870         outbuf += c->cipher->blocksize;
871     }
872
873     if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) {
874         int restbytes;
875
876         if ((nbytes % blocksize) == 0)
877           restbytes = blocksize;
878         else
879           restbytes = nbytes % blocksize;
880
881         memcpy(c->lastiv, c->iv, blocksize ); /* save Cn-2 */
882         memcpy(c->iv, inbuf + blocksize, restbytes ); /* save Cn */
883
884         c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
885         for(ivp=c->iv,i=0; i < restbytes; i++ )
886             outbuf[i] ^= *ivp++;
887
888         memcpy(outbuf + blocksize, outbuf, restbytes);
889         for(i=restbytes; i < blocksize; i++)
890           c->iv[i] = outbuf[i];
891         c->cipher->decrypt ( &c->context.c, outbuf, c->iv );
892         for(ivp=c->lastiv,i=0; i < blocksize; i++ )
893             outbuf[i] ^= *ivp++;
894         /* c->lastiv is now really lastlastiv, does this matter? */
895     }
896 }
897
898
899 static void
900 do_cfb_encrypt( gcry_cipher_hd_t c,
901                 byte *outbuf, const byte *inbuf, unsigned nbytes )
902 {
903     byte *ivp;
904     size_t blocksize = c->cipher->blocksize;
905
906     if( nbytes <= c->unused ) {
907         /* Short enough to be encoded by the remaining XOR mask. */
908         /* XOR the input with the IV and store input into IV. */
909         for (ivp=c->iv+c->cipher->blocksize - c->unused;
910              nbytes;
911              nbytes--, c->unused-- )
912           *outbuf++ = (*ivp++ ^= *inbuf++);
913         return;
914     }
915
916     if( c->unused ) {
917         /* XOR the input with the IV and store input into IV */
918         nbytes -= c->unused;
919         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- )
920             *outbuf++ = (*ivp++ ^= *inbuf++);
921     }
922
923     /* Now we can process complete blocks. */
924     while( nbytes >= blocksize ) {
925         int i;
926         /* Encrypt the IV (and save the current one). */
927         memcpy( c->lastiv, c->iv, blocksize );
928         c->cipher->encrypt ( &c->context.c, c->iv, c->iv );
929         /* XOR the input with the IV and store input into IV */
930         for(ivp=c->iv,i=0; i < blocksize; i++ )
931             *outbuf++ = (*ivp++ ^= *inbuf++);
932         nbytes -= blocksize;
933     }
934     if( nbytes ) { /* process the remaining bytes */
935         /* encrypt the IV (and save the current one) */
936         memcpy( c->lastiv, c->iv, blocksize );
937         c->cipher->encrypt ( &c->context.c, c->iv, c->iv );
938         c->unused = blocksize;
939         /* and apply the xor */
940         c->unused -= nbytes;
941         for(ivp=c->iv; nbytes; nbytes-- )
942             *outbuf++ = (*ivp++ ^= *inbuf++);
943     }
944 }
945
946 static void
947 do_cfb_decrypt( gcry_cipher_hd_t c,
948                 byte *outbuf, const byte *inbuf, unsigned int nbytes )
949 {
950     byte *ivp;
951     ulong temp;
952     size_t blocksize = c->cipher->blocksize;
953
954     if( nbytes <= c->unused ) {
955         /* Short enough to be encoded by the remaining XOR mask. */
956         /* XOR the input with the IV and store input into IV. */
957         for(ivp=c->iv+blocksize - c->unused; nbytes; nbytes--,c->unused--) {
958             temp = *inbuf++;
959             *outbuf++ = *ivp ^ temp;
960             *ivp++ = temp;
961         }
962         return;
963     }
964
965     if( c->unused ) {
966         /* XOR the input with the IV and store input into IV. */
967         nbytes -= c->unused;
968         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- ) {
969             temp = *inbuf++;
970             *outbuf++ = *ivp ^ temp;
971             *ivp++ = temp;
972         }
973     }
974
975     /* now we can process complete blocks */
976     while( nbytes >= blocksize ) {
977         int i;
978         /* encrypt the IV (and save the current one) */
979         memcpy( c->lastiv, c->iv, blocksize );
980         c->cipher->encrypt ( &c->context.c, c->iv, c->iv );
981         /* XOR the input with the IV and store input into IV */
982         for(ivp=c->iv,i=0; i < blocksize; i++ ) {
983             temp = *inbuf++;
984             *outbuf++ = *ivp ^ temp;
985             *ivp++ = temp;
986         }
987         nbytes -= blocksize;
988     }
989     if( nbytes ) { /* process the remaining bytes */
990         /* encrypt the IV (and save the current one) */
991         memcpy( c->lastiv, c->iv, blocksize );
992         c->cipher->encrypt ( &c->context.c, c->iv, c->iv );
993         c->unused = blocksize;
994         /* and apply the xor */
995         c->unused -= nbytes;
996         for(ivp=c->iv; nbytes; nbytes-- ) {
997             temp = *inbuf++;
998             *outbuf++ = *ivp ^ temp;
999             *ivp++ = temp;
1000         }
1001     }
1002 }
1003
1004
1005 static void
1006 do_ofb_encrypt( gcry_cipher_hd_t c,
1007                 byte *outbuf, const byte *inbuf, unsigned nbytes )
1008 {
1009   byte *ivp;
1010   size_t blocksize = c->cipher->blocksize;
1011
1012   if ( nbytes <= c->unused )
1013     {
1014       /* Short enough to be encoded by the remaining XOR mask. */
1015       /* XOR the input with the IV */
1016       for (ivp=c->iv+c->cipher->blocksize - c->unused;
1017            nbytes;
1018            nbytes--, c->unused-- )
1019         *outbuf++ = (*ivp++ ^ *inbuf++);
1020       return;
1021     }
1022
1023   if( c->unused )
1024     {
1025       nbytes -= c->unused;
1026       for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- )
1027         *outbuf++ = (*ivp++ ^ *inbuf++);
1028     }
1029
1030   /* Now we can process complete blocks. */
1031   while ( nbytes >= blocksize )
1032     {
1033       int i;
1034       /* Encrypt the IV (and save the current one). */
1035       memcpy( c->lastiv, c->iv, blocksize );
1036       c->cipher->encrypt ( &c->context.c, c->iv, c->iv );
1037       
1038       for (ivp=c->iv,i=0; i < blocksize; i++ )
1039         *outbuf++ = (*ivp++ ^ *inbuf++);
1040       nbytes -= blocksize;
1041     }
1042   if ( nbytes )
1043     { /* process the remaining bytes */
1044       memcpy( c->lastiv, c->iv, blocksize );
1045       c->cipher->encrypt ( &c->context.c, c->iv, c->iv );
1046       c->unused = blocksize;
1047       c->unused -= nbytes;
1048       for(ivp=c->iv; nbytes; nbytes-- )
1049         *outbuf++ = (*ivp++ ^ *inbuf++);
1050     }
1051 }
1052
1053 static void
1054 do_ofb_decrypt( gcry_cipher_hd_t c,
1055                 byte *outbuf, const byte *inbuf, unsigned int nbytes )
1056 {
1057   byte *ivp;
1058   size_t blocksize = c->cipher->blocksize;
1059   
1060   if( nbytes <= c->unused )
1061     {
1062       /* Short enough to be encoded by the remaining XOR mask. */
1063       for (ivp=c->iv+blocksize - c->unused; nbytes; nbytes--,c->unused--)
1064         *outbuf++ = *ivp++ ^ *inbuf++;
1065       return;
1066     }
1067
1068   if ( c->unused )
1069     {
1070       nbytes -= c->unused;
1071       for (ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- )
1072         *outbuf++ = *ivp++ ^ *inbuf++;
1073     }
1074
1075   /* Now we can process complete blocks. */
1076   while ( nbytes >= blocksize )
1077     {
1078       int i;
1079       /* Encrypt the IV (and save the current one). */
1080       memcpy( c->lastiv, c->iv, blocksize );
1081       c->cipher->encrypt ( &c->context.c, c->iv, c->iv );
1082       for (ivp=c->iv,i=0; i < blocksize; i++ )
1083         *outbuf++ = *ivp++ ^ *inbuf++;
1084       nbytes -= blocksize;
1085     }
1086   if ( nbytes ) 
1087     { /* Process the remaining bytes. */
1088       /* Encrypt the IV (and save the current one). */
1089       memcpy( c->lastiv, c->iv, blocksize );
1090       c->cipher->encrypt ( &c->context.c, c->iv, c->iv );
1091       c->unused = blocksize;
1092       c->unused -= nbytes;
1093       for (ivp=c->iv; nbytes; nbytes-- )
1094         *outbuf++ = *ivp++ ^ *inbuf++;
1095     }
1096 }
1097
1098
1099 static void
1100 do_ctr_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1101                 unsigned int nbytes )
1102 {
1103   unsigned int n;
1104   byte tmp[MAX_BLOCKSIZE];
1105   int i;
1106
1107   for(n=0; n < nbytes; n++)
1108     {
1109       if ((n % c->cipher->blocksize) == 0)
1110         {
1111           c->cipher->encrypt (&c->context.c, tmp, c->ctr);
1112
1113           for (i = c->cipher->blocksize; i > 0; i--)
1114             {
1115               c->ctr[i-1]++;
1116               if (c->ctr[i-1] != 0)
1117                 break;
1118             }
1119         }
1120
1121       /* XOR input with encrypted counter and store in output. */
1122       outbuf[n] = inbuf[n] ^ tmp[n % c->cipher->blocksize];
1123     }
1124 }
1125
1126 static void
1127 do_ctr_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1128                 unsigned int nbytes )
1129 {
1130   do_ctr_encrypt (c, outbuf, inbuf, nbytes);
1131 }
1132
1133
1134 /****************
1135  * Encrypt INBUF to OUTBUF with the mode selected at open.
1136  * inbuf and outbuf may overlap or be the same.
1137  * Depending on the mode some contraints apply to NBYTES.
1138  */
1139 static gcry_err_code_t
1140 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf,
1141                 const byte *inbuf, unsigned int nbytes)
1142 {
1143     gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1144
1145     switch( c->mode ) {
1146       case GCRY_CIPHER_MODE_ECB:
1147         if (!(nbytes%c->cipher->blocksize))
1148             do_ecb_encrypt(c, outbuf, inbuf, nbytes/c->cipher->blocksize );
1149         else 
1150             rc = GPG_ERR_INV_ARG;
1151         break;
1152       case GCRY_CIPHER_MODE_CBC:
1153         if (!(nbytes%c->cipher->blocksize)
1154             || (nbytes > c->cipher->blocksize
1155                 && (c->flags & GCRY_CIPHER_CBC_CTS)))
1156             do_cbc_encrypt(c, outbuf, inbuf, nbytes );
1157         else 
1158             rc = GPG_ERR_INV_ARG;
1159         break;
1160       case GCRY_CIPHER_MODE_CFB:
1161         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
1162         break;
1163       case GCRY_CIPHER_MODE_OFB:
1164         do_ofb_encrypt(c, outbuf, inbuf, nbytes );
1165         break;
1166       case GCRY_CIPHER_MODE_CTR:
1167         do_ctr_encrypt(c, outbuf, inbuf, nbytes );
1168         break;
1169       case GCRY_CIPHER_MODE_STREAM:
1170         c->cipher->stencrypt ( &c->context.c,
1171                                outbuf, (byte*)/*arggg*/inbuf, nbytes );
1172         break;
1173       case GCRY_CIPHER_MODE_NONE:
1174         if( inbuf != outbuf )
1175             memmove( outbuf, inbuf, nbytes );
1176         break;
1177       default:
1178         log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
1179         rc = GPG_ERR_INV_CIPHER_MODE;
1180         break;
1181     }
1182     return rc;
1183 }
1184
1185
1186 /****************
1187  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
1188  * been requested.
1189  */
1190 gcry_error_t
1191 gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1192                      const void *in, size_t inlen)
1193 {
1194   gcry_err_code_t err;
1195
1196   if (!in)
1197     /* Caller requested in-place encryption. */
1198     /* Actually cipher_encrypt() does not need to know about it, but
1199      * we may change it in the future to get better performance.  */
1200     err = cipher_encrypt (h, out, out, outsize);
1201   else if (outsize < ((h->flags & GCRY_CIPHER_CBC_MAC) ?
1202                       h->cipher->blocksize : inlen))
1203     err = GPG_ERR_TOO_SHORT;
1204   else if ((h->mode == GCRY_CIPHER_MODE_ECB
1205             || (h->mode == GCRY_CIPHER_MODE_CBC
1206                 && (! ((h->flags & GCRY_CIPHER_CBC_CTS)
1207                        && (inlen > h->cipher->blocksize)))))
1208            && (inlen % h->cipher->blocksize))
1209     err = GPG_ERR_INV_ARG;
1210   else
1211     err = cipher_encrypt (h, out, in, inlen);
1212
1213   if (err && out)
1214     memset (out, 0x42, outsize); /* Failsafe: Make sure that the
1215                                     plaintext will never make it into
1216                                     OUT. */
1217
1218   return gcry_error (err);
1219 }
1220
1221
1222
1223 /****************
1224  * Decrypt INBUF to OUTBUF with the mode selected at open.
1225  * inbuf and outbuf may overlap or be the same.
1226  * Depending on the mode some some contraints apply to NBYTES.
1227  */
1228 static gcry_err_code_t
1229 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1230                 unsigned int nbytes)
1231 {
1232     gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1233
1234     switch( c->mode ) {
1235       case GCRY_CIPHER_MODE_ECB:
1236         if (!(nbytes%c->cipher->blocksize))
1237             do_ecb_decrypt(c, outbuf, inbuf, nbytes/c->cipher->blocksize );
1238         else 
1239             rc = GPG_ERR_INV_ARG;
1240         break;
1241       case GCRY_CIPHER_MODE_CBC:
1242         if (!(nbytes%c->cipher->blocksize)
1243             || (nbytes > c->cipher->blocksize
1244                 && (c->flags & GCRY_CIPHER_CBC_CTS)))
1245             do_cbc_decrypt(c, outbuf, inbuf, nbytes );
1246         else 
1247             rc = GPG_ERR_INV_ARG;
1248         break;
1249       case GCRY_CIPHER_MODE_CFB:
1250         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
1251         break;
1252       case GCRY_CIPHER_MODE_OFB:
1253         do_ofb_decrypt(c, outbuf, inbuf, nbytes );
1254         break;
1255       case GCRY_CIPHER_MODE_CTR:
1256         do_ctr_decrypt(c, outbuf, inbuf, nbytes );
1257         break;
1258       case GCRY_CIPHER_MODE_STREAM:
1259         c->cipher->stdecrypt ( &c->context.c,
1260                                outbuf, (byte*)/*arggg*/inbuf, nbytes );
1261         break;
1262       case GCRY_CIPHER_MODE_NONE:
1263         if( inbuf != outbuf )
1264             memmove( outbuf, inbuf, nbytes );
1265         break;
1266       default:
1267         log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1268         rc = GPG_ERR_INV_CIPHER_MODE;
1269         break;
1270     }
1271     return rc;
1272 }
1273
1274
1275 gcry_error_t
1276 gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1277                      const void *in, size_t inlen)
1278 {
1279   gcry_err_code_t err = 0;
1280
1281   if (!in)
1282     /* Caller requested in-place encryption. */
1283     /* Actually cipher_encrypt() does not need to know about it, but
1284      * we may change it in the future to get better performance.  */
1285     err = cipher_decrypt (h, out, out, outsize);
1286   else if (outsize < inlen)
1287     err = GPG_ERR_TOO_SHORT;
1288   else if (((h->mode == GCRY_CIPHER_MODE_ECB)
1289             || ((h->mode == GCRY_CIPHER_MODE_CBC)
1290                 && (! ((h->flags & GCRY_CIPHER_CBC_CTS)
1291                        && (inlen > h->cipher->blocksize)))))
1292            && (inlen % h->cipher->blocksize) != 0)
1293     err = GPG_ERR_INV_ARG;
1294   else
1295     err = cipher_decrypt (h, out, in, inlen);
1296
1297   return gcry_error (err);
1298 }
1299
1300
1301
1302 /****************
1303  * Used for PGP's somewhat strange CFB mode. Only works if
1304  * the corresponding flag is set.
1305  */
1306 static void
1307 cipher_sync( gcry_cipher_hd_t c )
1308 {
1309     if( (c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused ) {
1310         memmove(c->iv + c->unused, c->iv, c->cipher->blocksize - c->unused );
1311         memcpy(c->iv, c->lastiv + c->cipher->blocksize - c->unused, c->unused);
1312         c->unused = 0;
1313     }
1314 }
1315
1316
1317 gcry_error_t
1318 gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1319 {
1320   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1321
1322   switch (cmd)
1323     {
1324     case GCRYCTL_SET_KEY:
1325       rc = cipher_setkey( h, buffer, buflen );
1326       break;
1327     case GCRYCTL_SET_IV:
1328       cipher_setiv( h, buffer, buflen );
1329       break;
1330     case GCRYCTL_RESET:
1331       cipher_reset (h);
1332       break;
1333     case GCRYCTL_CFB_SYNC:
1334       cipher_sync( h );
1335       break;
1336     case GCRYCTL_SET_CBC_CTS:
1337       if (buflen)
1338         if (h->flags & GCRY_CIPHER_CBC_MAC)
1339           rc = GPG_ERR_INV_FLAG;
1340         else
1341           h->flags |= GCRY_CIPHER_CBC_CTS;
1342       else
1343         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1344       break;
1345     case GCRYCTL_SET_CBC_MAC:
1346       if (buflen)
1347         if (h->flags & GCRY_CIPHER_CBC_CTS)
1348           rc = GPG_ERR_INV_FLAG;
1349         else
1350           h->flags |= GCRY_CIPHER_CBC_MAC;
1351       else
1352         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1353       break;
1354     case GCRYCTL_DISABLE_ALGO:
1355       /* this one expects a NULL handle and buffer pointing to an
1356        * integer with the algo number.
1357        */
1358       if( h || !buffer || buflen != sizeof(int) )
1359         return gcry_error (GPG_ERR_CIPHER_ALGO);
1360       disable_cipher_algo( *(int*)buffer );
1361       break;
1362     case GCRYCTL_SET_CTR:
1363       if (buffer && buflen == h->cipher->blocksize)
1364         memcpy (h->ctr, buffer, h->cipher->blocksize);
1365       else if (buffer == NULL || buflen == 0)
1366         memset (h->ctr, 0, h->cipher->blocksize);
1367       else
1368         rc = GPG_ERR_INV_ARG;
1369       break;
1370
1371     default:
1372       rc = GPG_ERR_INV_OP;
1373     }
1374
1375   return gcry_error (rc);
1376 }
1377
1378
1379 /****************
1380  * Return information about the cipher handle.
1381  */
1382 gcry_error_t
1383 gcry_cipher_info( gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1384 {
1385   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1386
1387   (void)h;
1388   (void)buffer;
1389   (void)nbytes;
1390
1391   switch (cmd)
1392     {
1393     default:
1394       err = GPG_ERR_INV_OP;
1395     }
1396
1397   return gcry_error (err);
1398 }
1399
1400 /****************
1401  * Return information about the given cipher algorithm
1402  * WHAT select the kind of information returned:
1403  *  GCRYCTL_GET_KEYLEN:
1404  *      Return the length of the key, if the algorithm
1405  *      supports multiple key length, the maximum supported value
1406  *      is returnd.  The length is return as number of octets.
1407  *      buffer and nbytes must be zero.
1408  *      The keylength is returned in _bytes_.
1409  *  GCRYCTL_GET_BLKLEN:
1410  *      Return the blocklength of the algorithm counted in octets.
1411  *      buffer and nbytes must be zero.
1412  *  GCRYCTL_TEST_ALGO:
1413  *      Returns 0 when the specified algorithm is available for use.
1414  *      buffer and nbytes must be zero.
1415  *
1416  * Note:  Because this function is in most cases used to return an
1417  * integer value, we can make it easier for the caller to just look at
1418  * the return value.  The caller will in all cases consult the value
1419  * and thereby detecting whether a error occured or not (i.e. while checking
1420  * the block size)
1421  */
1422 gcry_error_t
1423 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1424 {
1425   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1426   unsigned int ui;
1427
1428   switch (what)
1429     {
1430     case GCRYCTL_GET_KEYLEN:
1431       if (buffer || (! nbytes))
1432         err = GPG_ERR_CIPHER_ALGO;
1433       else
1434         {
1435           ui = cipher_get_keylen (algo);
1436           if ((ui > 0) && (ui <= 512))
1437             *nbytes = (size_t) ui / 8;
1438           else
1439             /* The only reason is an invalid algo or a strange
1440                blocksize.  */
1441             err = GPG_ERR_CIPHER_ALGO;
1442         }
1443       break;
1444
1445     case GCRYCTL_GET_BLKLEN:
1446       if (buffer || (! nbytes))
1447         err = GPG_ERR_CIPHER_ALGO;
1448       else
1449         {
1450           ui = cipher_get_blocksize (algo);
1451           if ((ui > 0) && (ui < 10000))
1452             *nbytes = ui;
1453           else
1454             /* The only reason is an invalid algo or a strange
1455                blocksize.  */
1456             err = GPG_ERR_CIPHER_ALGO;
1457         }
1458       break;
1459
1460     case GCRYCTL_TEST_ALGO:
1461       if (buffer || nbytes)
1462         err = GPG_ERR_INV_ARG;
1463       else
1464         err = check_cipher_algo (algo);
1465       break;
1466
1467       default:
1468         err = GPG_ERR_INV_OP;
1469     }
1470
1471   return gcry_error (err);
1472 }
1473
1474
1475 size_t
1476 gcry_cipher_get_algo_keylen (int algo) 
1477 {
1478   size_t n;
1479
1480   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1481     n = 0;
1482   return n;
1483 }
1484
1485
1486 size_t
1487 gcry_cipher_get_algo_blklen (int algo) 
1488 {
1489   size_t n;
1490
1491   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1492     n = 0;
1493   return n;
1494 }
1495
1496
1497 gcry_err_code_t
1498 _gcry_cipher_init (void)
1499 {
1500   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1501
1502   REGISTER_DEFAULT_CIPHERS;
1503
1504   return err;
1505 }
1506
1507 /* Get a list consisting of the IDs of the loaded cipher modules.  If
1508    LIST is zero, write the number of loaded cipher modules to
1509    LIST_LENGTH and return.  If LIST is non-zero, the first
1510    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
1511    according size.  In case there are less cipher modules than
1512    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
1513 gcry_error_t
1514 gcry_cipher_list (int *list, int *list_length)
1515 {
1516   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1517
1518   ath_mutex_lock (&ciphers_registered_lock);
1519   err = _gcry_module_list (ciphers_registered, list, list_length);
1520   ath_mutex_unlock (&ciphers_registered_lock);
1521
1522   return err;
1523 }