Insert sys/select.h to be POSIXly correct.
[libgcrypt.git] / cipher / cipher.c
1 /* cipher.c  -  cipher dispatcher
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *               2005, 2007, 2008, 2009 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, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26
27 #include "g10lib.h"
28 #include "cipher.h"
29 #include "ath.h"
30
31 #define MAX_BLOCKSIZE 16
32 #define TABLE_SIZE 14
33 #define CTX_MAGIC_NORMAL 0x24091964
34 #define CTX_MAGIC_SECURE 0x46919042
35
36 #undef NEED_16BYTE_ALIGNED_CONTEXT
37 #if defined (__i386__) && SIZEOF_UNSIGNED_LONG == 4 && defined (__GNUC__)
38 #define NEED_16BYTE_ALIGNED_CONTEXT 1
39 #endif
40
41 /* A dummy extraspec so that we do not need to tests the extraspec
42    field from the module specification against NULL and instead
43    directly test the respective fields of extraspecs.  */
44 static cipher_extra_spec_t dummy_extra_spec;
45
46 /* This is the list of the default ciphers, which are included in
47    libgcrypt.  */
48 static struct cipher_table_entry
49 {
50   gcry_cipher_spec_t *cipher;
51   cipher_extra_spec_t *extraspec;
52   unsigned int algorithm;
53   int fips_allowed;
54 } cipher_table[] =
55   {
56 #if USE_BLOWFISH
57     { &_gcry_cipher_spec_blowfish,
58       &dummy_extra_spec,                  GCRY_CIPHER_BLOWFISH },
59 #endif
60 #if USE_DES
61     { &_gcry_cipher_spec_des,       
62       &dummy_extra_spec,                  GCRY_CIPHER_DES },
63     { &_gcry_cipher_spec_tripledes,
64       &_gcry_cipher_extraspec_tripledes,  GCRY_CIPHER_3DES, 1 },
65 #endif
66 #if USE_ARCFOUR
67     { &_gcry_cipher_spec_arcfour,    
68       &dummy_extra_spec,                  GCRY_CIPHER_ARCFOUR },
69 #endif
70 #if USE_CAST5
71     { &_gcry_cipher_spec_cast5,      
72       &dummy_extra_spec,                  GCRY_CIPHER_CAST5 },
73 #endif
74 #if USE_AES
75     { &_gcry_cipher_spec_aes,        
76       &_gcry_cipher_extraspec_aes,        GCRY_CIPHER_AES,    1 },
77     { &_gcry_cipher_spec_aes192,     
78       &_gcry_cipher_extraspec_aes192,     GCRY_CIPHER_AES192, 1 },
79     { &_gcry_cipher_spec_aes256,     
80       &_gcry_cipher_extraspec_aes256,     GCRY_CIPHER_AES256, 1 },
81 #endif
82 #if USE_TWOFISH
83     { &_gcry_cipher_spec_twofish,
84       &dummy_extra_spec,                  GCRY_CIPHER_TWOFISH },
85     { &_gcry_cipher_spec_twofish128,     
86       &dummy_extra_spec,                  GCRY_CIPHER_TWOFISH128 },
87 #endif
88 #if USE_SERPENT
89     { &_gcry_cipher_spec_serpent128, 
90       &dummy_extra_spec,                  GCRY_CIPHER_SERPENT128 },
91     { &_gcry_cipher_spec_serpent192,
92       &dummy_extra_spec,                  GCRY_CIPHER_SERPENT192 },
93     { &_gcry_cipher_spec_serpent256, 
94       &dummy_extra_spec,                  GCRY_CIPHER_SERPENT256 },
95 #endif
96 #if USE_RFC2268
97     { &_gcry_cipher_spec_rfc2268_40,
98       &dummy_extra_spec,                  GCRY_CIPHER_RFC2268_40 },
99 #endif
100 #if USE_SEED
101     { &_gcry_cipher_spec_seed, 
102       &dummy_extra_spec,                  GCRY_CIPHER_SEED },
103 #endif
104 #if USE_CAMELLIA
105     { &_gcry_cipher_spec_camellia128,
106       &dummy_extra_spec,                  GCRY_CIPHER_CAMELLIA128 },
107     { &_gcry_cipher_spec_camellia192, 
108       &dummy_extra_spec,                  GCRY_CIPHER_CAMELLIA192 },
109     { &_gcry_cipher_spec_camellia256,
110       &dummy_extra_spec,                  GCRY_CIPHER_CAMELLIA256 },
111 #endif
112     { NULL                    }
113   };
114
115 /* List of registered ciphers.  */
116 static gcry_module_t ciphers_registered;
117
118 /* This is the lock protecting CIPHERS_REGISTERED.  */
119 static ath_mutex_t ciphers_registered_lock = ATH_MUTEX_INITIALIZER;
120
121 /* Flag to check whether the default ciphers have already been
122    registered.  */
123 static int default_ciphers_registered;
124
125 /* Convenient macro for registering the default ciphers.  */
126 #define REGISTER_DEFAULT_CIPHERS                   \
127   do                                               \
128     {                                              \
129       ath_mutex_lock (&ciphers_registered_lock);   \
130       if (! default_ciphers_registered)            \
131         {                                          \
132           cipher_register_default ();              \
133           default_ciphers_registered = 1;          \
134         }                                          \
135       ath_mutex_unlock (&ciphers_registered_lock); \
136     }                                              \
137   while (0)
138
139
140 /* A VIA processor with the Padlock engine requires an alignment of
141    most data on a 16 byte boundary.  Because we trick out the compiler
142    while allocating the context, the align attribute as used in
143    rijndael.c does not work on its own.  Thus we need to make sure
144    that the entire context structure is a aligned on that boundary.
145    We achieve this by defining a new type and use that instead of our
146    usual alignment type.  */
147 typedef union 
148 {
149   PROPERLY_ALIGNED_TYPE foo;
150 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
151   char bar[16] __attribute__ ((aligned (16)));
152 #endif  
153   char c[1];
154 } cipher_context_alignment_t;
155
156
157 /* The handle structure.  */
158 struct gcry_cipher_handle
159 {
160   int magic;
161   size_t actual_handle_size;     /* Allocated size of this handle. */
162   size_t handle_offset;          /* Offset to the malloced block.  */
163   gcry_cipher_spec_t *cipher;
164   cipher_extra_spec_t *extraspec;
165   gcry_module_t module;
166
167   /* The algorithm id.  This is a hack required because the module
168      interface does not easily allow to retrieve this value. */
169   int algo;  
170
171   /* A structure with function pointers for bulk operations.  Due to
172      limitations of the module system (we don't want to change the
173      API) we need to keep these function pointers here.  The cipher
174      open function intializes them and the actual encryption routines
175      use them if they are not NULL.  */
176   struct {
177     void (*cfb_enc)(void *context, unsigned char *iv, 
178                     void *outbuf_arg, const void *inbuf_arg,
179                     unsigned int nblocks);
180     void (*cfb_dec)(void *context, unsigned char *iv, 
181                     void *outbuf_arg, const void *inbuf_arg,
182                     unsigned int nblocks);
183     void (*cbc_enc)(void *context, unsigned char *iv, 
184                     void *outbuf_arg, const void *inbuf_arg,
185                     unsigned int nblocks, int cbc_mac);
186     void (*cbc_dec)(void *context, unsigned char *iv, 
187                     void *outbuf_arg, const void *inbuf_arg,
188                     unsigned int nblocks);
189   } bulk;
190
191
192   int mode;
193   unsigned int flags;
194
195   struct {
196     unsigned int key:1; /* Set to 1 if a key has been set.  */
197     unsigned int iv:1;  /* Set to 1 if a IV has been set.  */
198   } marks;
199
200   /* The initialization vector.  To help code optimization we make
201      sure that it is aligned on an unsigned long and u32 boundary.  */
202   union {
203     unsigned long dummy_iv;         
204     u32 dummy_u32_iv;
205     unsigned char iv[MAX_BLOCKSIZE];    
206   } u_iv;
207
208   unsigned char lastiv[MAX_BLOCKSIZE];
209   int unused;  /* Number of unused bytes in the IV. */
210
211   unsigned char ctr[MAX_BLOCKSIZE];     /* For Counter (CTR) mode. */
212
213
214   /* What follows are two contexts of the cipher in use.  The first
215      one needs to be aligned well enough for the cipher operation
216      whereas the second one is a copy created by cipher_setkey and
217      used by cipher_reset.  That second copy has no need for proper
218      aligment because it is only accessed by memcpy.  */
219   cipher_context_alignment_t context;
220 };
221
222
223 \f
224 /* These dummy functions are used in case a cipher implementation
225    refuses to provide it's own functions.  */
226
227 static gcry_err_code_t
228 dummy_setkey (void *c, const unsigned char *key, unsigned int keylen)
229 {
230   (void)c; 
231   (void)key;
232   (void)keylen;
233   return GPG_ERR_NO_ERROR;
234 }
235
236 static void
237 dummy_encrypt_block (void *c,
238                      unsigned char *outbuf, const unsigned char *inbuf)
239 {
240   (void)c;
241   (void)outbuf;
242   (void)inbuf;
243   BUG();
244 }
245
246 static void
247 dummy_decrypt_block (void *c,
248                      unsigned char *outbuf, const unsigned char *inbuf)
249 {
250   (void)c;
251   (void)outbuf;
252   (void)inbuf;
253   BUG();
254 }
255
256 static void
257 dummy_encrypt_stream (void *c,
258                       unsigned char *outbuf, const unsigned char *inbuf,
259                       unsigned int n)
260 {
261   (void)c;
262   (void)outbuf;
263   (void)inbuf;
264   (void)n;
265   BUG();
266 }
267
268 static void
269 dummy_decrypt_stream (void *c,
270                       unsigned char *outbuf, const unsigned char *inbuf,
271                       unsigned int n)
272 {
273   (void)c;
274   (void)outbuf;
275   (void)inbuf;
276   (void)n;
277   BUG();
278 }
279
280 \f
281 /* Internal function.  Register all the ciphers included in
282    CIPHER_TABLE.  Note, that this function gets only used by the macro
283    REGISTER_DEFAULT_CIPHERS which protects it using a mutex. */
284 static void
285 cipher_register_default (void)
286 {
287   gcry_err_code_t err = GPG_ERR_NO_ERROR;
288   int i;
289   
290   for (i = 0; !err && cipher_table[i].cipher; i++)
291     {
292       if (! cipher_table[i].cipher->setkey)
293         cipher_table[i].cipher->setkey = dummy_setkey;
294       if (! cipher_table[i].cipher->encrypt)
295         cipher_table[i].cipher->encrypt = dummy_encrypt_block;
296       if (! cipher_table[i].cipher->decrypt)
297         cipher_table[i].cipher->decrypt = dummy_decrypt_block;
298       if (! cipher_table[i].cipher->stencrypt)
299         cipher_table[i].cipher->stencrypt = dummy_encrypt_stream;
300       if (! cipher_table[i].cipher->stdecrypt)
301         cipher_table[i].cipher->stdecrypt = dummy_decrypt_stream;
302
303       if ( fips_mode () && !cipher_table[i].fips_allowed )
304         continue;
305
306       err = _gcry_module_add (&ciphers_registered,
307                               cipher_table[i].algorithm,
308                               (void *) cipher_table[i].cipher,
309                               (void *) cipher_table[i].extraspec,
310                               NULL);
311     }
312
313   if (err)
314     BUG ();
315 }
316
317 /* Internal callback function.  Used via _gcry_module_lookup.  */
318 static int
319 gcry_cipher_lookup_func_name (void *spec, void *data)
320 {
321   gcry_cipher_spec_t *cipher = (gcry_cipher_spec_t *) spec;
322   char *name = (char *) data;
323   const char **aliases = cipher->aliases;
324   int i, ret = ! stricmp (name, cipher->name);
325
326   if (aliases)
327     for (i = 0; aliases[i] && (! ret); i++)
328       ret = ! stricmp (name, aliases[i]);
329
330   return ret;
331 }
332
333 /* Internal callback function.  Used via _gcry_module_lookup.  */
334 static int
335 gcry_cipher_lookup_func_oid (void *spec, void *data)
336 {
337   gcry_cipher_spec_t *cipher = (gcry_cipher_spec_t *) spec;
338   char *oid = (char *) data;
339   gcry_cipher_oid_spec_t *oid_specs = cipher->oids;
340   int ret = 0, i;
341
342   if (oid_specs)
343     for (i = 0; oid_specs[i].oid && (! ret); i++)
344       if (! stricmp (oid, oid_specs[i].oid))
345         ret = 1;
346
347   return ret;
348 }
349
350 /* Internal function.  Lookup a cipher entry by it's name.  */
351 static gcry_module_t
352 gcry_cipher_lookup_name (const char *name)
353 {
354   gcry_module_t cipher;
355
356   cipher = _gcry_module_lookup (ciphers_registered, (void *) name,
357                                 gcry_cipher_lookup_func_name);
358
359   return cipher;
360 }
361
362 /* Internal function.  Lookup a cipher entry by it's oid.  */
363 static gcry_module_t
364 gcry_cipher_lookup_oid (const char *oid)
365 {
366   gcry_module_t cipher;
367
368   cipher = _gcry_module_lookup (ciphers_registered, (void *) oid,
369                                 gcry_cipher_lookup_func_oid);
370
371   return cipher;
372 }
373
374 /* Register a new cipher module whose specification can be found in
375    CIPHER.  On success, a new algorithm ID is stored in ALGORITHM_ID
376    and a pointer representhing this module is stored in MODULE.  */
377 gcry_error_t
378 _gcry_cipher_register (gcry_cipher_spec_t *cipher,
379                        cipher_extra_spec_t *extraspec,
380                        int *algorithm_id,
381                        gcry_module_t *module)
382 {
383   gcry_err_code_t err = 0;
384   gcry_module_t mod;
385
386   /* We do not support module loading in fips mode.  */
387   if (fips_mode ())
388     return gpg_error (GPG_ERR_NOT_SUPPORTED);
389
390   ath_mutex_lock (&ciphers_registered_lock);
391   err = _gcry_module_add (&ciphers_registered, 0,
392                           (void *)cipher, 
393                           (void *)(extraspec? extraspec : &dummy_extra_spec), 
394                           &mod);
395   ath_mutex_unlock (&ciphers_registered_lock);
396
397   if (! err)
398     {
399       *module = mod;
400       *algorithm_id = mod->mod_id;
401     }
402
403   return gcry_error (err);
404 }
405
406 /* Unregister the cipher identified by MODULE, which must have been
407    registered with gcry_cipher_register.  */
408 void
409 gcry_cipher_unregister (gcry_module_t module)
410 {
411   ath_mutex_lock (&ciphers_registered_lock);
412   _gcry_module_release (module);
413   ath_mutex_unlock (&ciphers_registered_lock);
414 }
415
416 /* Locate the OID in the oid table and return the index or -1 when not
417    found.  An opitonal "oid." or "OID." prefix in OID is ignored, the
418    OID is expected to be in standard IETF dotted notation.  The
419    internal algorithm number is returned in ALGORITHM unless it
420    ispassed as NULL.  A pointer to the specification of the module
421    implementing this algorithm is return in OID_SPEC unless passed as
422    NULL.*/
423 static int 
424 search_oid (const char *oid, int *algorithm, gcry_cipher_oid_spec_t *oid_spec)
425 {
426   gcry_module_t module;
427   int ret = 0;
428
429   if (oid && ((! strncmp (oid, "oid.", 4))
430               || (! strncmp (oid, "OID.", 4))))
431     oid += 4;
432
433   module = gcry_cipher_lookup_oid (oid);
434   if (module)
435     {
436       gcry_cipher_spec_t *cipher = module->spec;
437       int i;
438
439       for (i = 0; cipher->oids[i].oid && !ret; i++)
440         if (! stricmp (oid, cipher->oids[i].oid))
441           {
442             if (algorithm)
443               *algorithm = module->mod_id;
444             if (oid_spec)
445               *oid_spec = cipher->oids[i];
446             ret = 1;
447           }
448       _gcry_module_release (module);
449     }
450
451   return ret;
452 }
453
454 /* Map STRING to the cipher algorithm identifier.  Returns the
455    algorithm ID of the cipher for the given name or 0 if the name is
456    not known.  It is valid to pass NULL for STRING which results in a
457    return value of 0. */
458 int
459 gcry_cipher_map_name (const char *string)
460 {
461   gcry_module_t cipher;
462   int ret, algorithm = 0;
463
464   if (! string)
465     return 0;
466
467   REGISTER_DEFAULT_CIPHERS;
468
469   /* If the string starts with a digit (optionally prefixed with
470      either "OID." or "oid."), we first look into our table of ASN.1
471      object identifiers to figure out the algorithm */
472
473   ath_mutex_lock (&ciphers_registered_lock);
474
475   ret = search_oid (string, &algorithm, NULL);
476   if (! ret)
477     {
478       cipher = gcry_cipher_lookup_name (string);
479       if (cipher)
480         {
481           algorithm = cipher->mod_id;
482           _gcry_module_release (cipher);
483         }
484     }
485
486   ath_mutex_unlock (&ciphers_registered_lock);
487   
488   return algorithm;
489 }
490
491
492 /* Given a STRING with an OID in dotted decimal notation, this
493    function returns the cipher mode (GCRY_CIPHER_MODE_*) associated
494    with that OID or 0 if no mode is known.  Passing NULL for string
495    yields a return value of 0. */
496 int
497 gcry_cipher_mode_from_oid (const char *string)
498 {
499   gcry_cipher_oid_spec_t oid_spec;
500   int ret = 0, mode = 0;
501
502   if (!string)
503     return 0;
504
505   ath_mutex_lock (&ciphers_registered_lock);
506   ret = search_oid (string, NULL, &oid_spec);
507   if (ret)
508     mode = oid_spec.mode;
509   ath_mutex_unlock (&ciphers_registered_lock);
510
511   return mode;
512 }
513
514
515 /* Map the cipher algorithm whose ID is contained in ALGORITHM to a
516    string representation of the algorithm name.  For unknown algorithm
517    IDs this function returns "?".  */
518 static const char *
519 cipher_algo_to_string (int algorithm)
520 {
521   gcry_module_t cipher;
522   const char *name;
523
524   REGISTER_DEFAULT_CIPHERS;
525
526   ath_mutex_lock (&ciphers_registered_lock);
527   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
528   if (cipher)
529     {
530       name = ((gcry_cipher_spec_t *) cipher->spec)->name;
531       _gcry_module_release (cipher);
532     }
533   else
534     name = "?";
535   ath_mutex_unlock (&ciphers_registered_lock);
536
537   return name;
538 }
539
540 /* Map the cipher algorithm identifier ALGORITHM to a string
541    representing this algorithm.  This string is the default name as
542    used by Libgcrypt.  An pointer to an empty string is returned for
543    an unknown algorithm.  NULL is never returned. */
544 const char *
545 gcry_cipher_algo_name (int algorithm)
546 {
547   return cipher_algo_to_string (algorithm);
548 }
549
550
551 /* Flag the cipher algorithm with the identifier ALGORITHM as
552    disabled.  There is no error return, the function does nothing for
553    unknown algorithms.  Disabled algorithms are vitually not available
554    in Libgcrypt. */
555 static void
556 disable_cipher_algo (int algorithm)
557 {
558   gcry_module_t cipher;
559
560   REGISTER_DEFAULT_CIPHERS;
561
562   ath_mutex_lock (&ciphers_registered_lock);
563   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
564   if (cipher)
565     {
566       if (! (cipher->flags & FLAG_MODULE_DISABLED))
567         cipher->flags |= FLAG_MODULE_DISABLED;
568       _gcry_module_release (cipher);
569     }
570   ath_mutex_unlock (&ciphers_registered_lock);
571 }
572
573
574 /* Return 0 if the cipher algorithm with identifier ALGORITHM is
575    available. Returns a basic error code value if it is not
576    available.  */
577 static gcry_err_code_t
578 check_cipher_algo (int algorithm)
579 {
580   gcry_err_code_t err = GPG_ERR_NO_ERROR;
581   gcry_module_t cipher;
582
583   REGISTER_DEFAULT_CIPHERS;
584
585   ath_mutex_lock (&ciphers_registered_lock);
586   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
587   if (cipher)
588     {
589       if (cipher->flags & FLAG_MODULE_DISABLED)
590         err = GPG_ERR_CIPHER_ALGO;
591       _gcry_module_release (cipher);
592     }
593   else
594     err = GPG_ERR_CIPHER_ALGO;
595   ath_mutex_unlock (&ciphers_registered_lock);
596   
597   return err;
598 }
599
600
601 /* Return the standard length of the key for the cipher algorithm with
602    the identifier ALGORITHM.  This function expects a valid algorithm
603    and will abort if the algorithm is not available or the length of
604    the key is not known. */
605 static unsigned int
606 cipher_get_keylen (int algorithm)
607 {
608   gcry_module_t cipher;
609   unsigned len = 0;
610
611   REGISTER_DEFAULT_CIPHERS;
612
613   ath_mutex_lock (&ciphers_registered_lock);
614   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
615   if (cipher)
616     {
617       len = ((gcry_cipher_spec_t *) cipher->spec)->keylen;
618       if (!len)
619         log_bug ("cipher %d w/o key length\n", algorithm);
620       _gcry_module_release (cipher);
621     }
622   else
623     log_bug ("cipher %d not found\n", algorithm);
624   ath_mutex_unlock (&ciphers_registered_lock);
625
626   return len;
627 }
628
629 /* Return the block length of the cipher algorithm with the identifier
630    ALGORITHM.  This function expects a valid algorithm and will abort
631    if the algorithm is not available or the length of the key is not
632    known. */
633 static unsigned int
634 cipher_get_blocksize (int algorithm)
635 {
636   gcry_module_t cipher;
637   unsigned len = 0;
638
639   REGISTER_DEFAULT_CIPHERS;
640
641   ath_mutex_lock (&ciphers_registered_lock);
642   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
643   if (cipher)
644     {
645       len = ((gcry_cipher_spec_t *) cipher->spec)->blocksize;
646       if (! len)
647           log_bug ("cipher %d w/o blocksize\n", algorithm);
648       _gcry_module_release (cipher);
649     }
650   else
651     log_bug ("cipher %d not found\n", algorithm);
652   ath_mutex_unlock (&ciphers_registered_lock);
653
654   return len;
655 }
656
657
658 /*
659    Open a cipher handle for use with cipher algorithm ALGORITHM, using
660    the cipher mode MODE (one of the GCRY_CIPHER_MODE_*) and return a
661    handle in HANDLE.  Put NULL into HANDLE and return an error code if
662    something goes wrong.  FLAGS may be used to modify the
663    operation.  The defined flags are:
664
665    GCRY_CIPHER_SECURE:  allocate all internal buffers in secure memory.
666    GCRY_CIPHER_ENABLE_SYNC:  Enable the sync operation as used in OpenPGP.
667    GCRY_CIPHER_CBC_CTS:  Enable CTS mode.
668    GCRY_CIPHER_CBC_MAC:  Enable MAC mode.
669
670    Values for these flags may be combined using OR.
671  */
672 gcry_error_t
673 gcry_cipher_open (gcry_cipher_hd_t *handle,
674                   int algo, int mode, unsigned int flags)
675 {
676   int secure = (flags & GCRY_CIPHER_SECURE);
677   gcry_cipher_spec_t *cipher = NULL;
678   cipher_extra_spec_t *extraspec = NULL;
679   gcry_module_t module = NULL;
680   gcry_cipher_hd_t h = NULL;
681   gcry_err_code_t err = 0;
682
683   /* If the application missed to call the random poll function, we do
684      it here to ensure that it is used once in a while. */
685   _gcry_fast_random_poll ();
686   
687   REGISTER_DEFAULT_CIPHERS;
688
689   /* Fetch the according module and check whether the cipher is marked
690      available for use.  */
691   ath_mutex_lock (&ciphers_registered_lock);
692   module = _gcry_module_lookup_id (ciphers_registered, algo);
693   if (module)
694     {
695       /* Found module.  */
696
697       if (module->flags & FLAG_MODULE_DISABLED)
698         {
699           /* Not available for use.  */
700           err = GPG_ERR_CIPHER_ALGO;
701           _gcry_module_release (module);
702         }
703       else
704         {
705           cipher = (gcry_cipher_spec_t *) module->spec;
706           extraspec = module->extraspec;
707         }
708     }
709   else
710     err = GPG_ERR_CIPHER_ALGO;
711   ath_mutex_unlock (&ciphers_registered_lock);
712
713   /* check flags */
714   if ((! err)
715       && ((flags & ~(0 
716                      | GCRY_CIPHER_SECURE
717                      | GCRY_CIPHER_ENABLE_SYNC
718                      | GCRY_CIPHER_CBC_CTS
719                      | GCRY_CIPHER_CBC_MAC))
720           || (flags & GCRY_CIPHER_CBC_CTS & GCRY_CIPHER_CBC_MAC)))
721     err = GPG_ERR_CIPHER_ALGO;
722
723   /* check that a valid mode has been requested */
724   if (! err)
725     switch (mode)
726       {
727       case GCRY_CIPHER_MODE_ECB:
728       case GCRY_CIPHER_MODE_CBC:
729       case GCRY_CIPHER_MODE_CFB:
730       case GCRY_CIPHER_MODE_OFB:
731       case GCRY_CIPHER_MODE_CTR:
732       case GCRY_CIPHER_MODE_AESWRAP:
733         if ((cipher->encrypt == dummy_encrypt_block)
734             || (cipher->decrypt == dummy_decrypt_block))
735           err = GPG_ERR_INV_CIPHER_MODE;
736         break;
737
738       case GCRY_CIPHER_MODE_STREAM:
739         if ((cipher->stencrypt == dummy_encrypt_stream)
740             || (cipher->stdecrypt == dummy_decrypt_stream))
741           err = GPG_ERR_INV_CIPHER_MODE;
742         break;
743
744       case GCRY_CIPHER_MODE_NONE:
745         /* This mode may be used for debugging.  It copies the main
746            text verbatim to the ciphertext.  We do not allow this in
747            fips mode or if no debug flag has been set.  */
748         if (fips_mode () || !_gcry_get_debug_flag (0))
749           err = GPG_ERR_INV_CIPHER_MODE;
750         break;
751
752       default:
753         err = GPG_ERR_INV_CIPHER_MODE;
754       }
755
756   /* Perform selftest here and mark this with a flag in cipher_table?
757      No, we should not do this as it takes too long.  Further it does
758      not make sense to exclude algorithms with failing selftests at
759      runtime: If a selftest fails there is something seriously wrong
760      with the system and thus we better die immediately. */
761
762   if (! err)
763     {
764       size_t size = (sizeof (*h)
765                      + 2 * cipher->contextsize
766                      - sizeof (cipher_context_alignment_t)
767 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
768                      + 15  /* Space for leading alignment gap.  */
769 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
770                      );
771
772       if (secure)
773         h = gcry_calloc_secure (1, size);
774       else
775         h = gcry_calloc (1, size);
776
777       if (! h)
778         err = gpg_err_code_from_errno (errno);
779       else
780         {
781           size_t off = 0;
782
783 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
784           if ( ((unsigned long)h & 0x0f) )
785             {
786               /* The malloced block is not aligned on a 16 byte
787                  boundary.  Correct for this.  */
788               off = 16 - ((unsigned long)h & 0x0f);
789               h = (void*)((char*)h + off);
790             }
791 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
792
793           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
794           h->actual_handle_size = size - off;
795           h->handle_offset = off;
796           h->cipher = cipher;
797           h->extraspec = extraspec;
798           h->module = module;
799           h->algo = algo;
800           h->mode = mode;
801           h->flags = flags;
802
803           /* Setup bulk encryption routines.  */
804           switch (algo)
805             {
806 #ifdef USE_AES
807             case GCRY_CIPHER_AES128:
808             case GCRY_CIPHER_AES192:
809             case GCRY_CIPHER_AES256:
810               h->bulk.cfb_enc = _gcry_aes_cfb_enc;
811               h->bulk.cfb_dec = _gcry_aes_cfb_dec;
812               h->bulk.cbc_enc = _gcry_aes_cbc_enc;
813               h->bulk.cbc_dec = _gcry_aes_cbc_dec;
814               break;
815 #endif /*USE_AES*/
816               
817             default:
818               break;
819             }
820         }
821     }
822
823   /* Done.  */
824
825   if (err)
826     {
827       if (module)
828         {
829           /* Release module.  */
830           ath_mutex_lock (&ciphers_registered_lock);
831           _gcry_module_release (module);
832           ath_mutex_unlock (&ciphers_registered_lock);
833         }
834     }
835
836   *handle = err ? NULL : h;
837
838   return gcry_error (err);
839 }
840
841
842 /* Release all resources associated with the cipher handle H. H may be
843    NULL in which case this is a no-operation. */
844 void
845 gcry_cipher_close (gcry_cipher_hd_t h)
846 {
847   size_t off;
848
849   if (!h)
850     return;
851
852   if ((h->magic != CTX_MAGIC_SECURE)
853       && (h->magic != CTX_MAGIC_NORMAL))
854     _gcry_fatal_error(GPG_ERR_INTERNAL,
855                       "gcry_cipher_close: already closed/invalid handle");
856   else
857     h->magic = 0;
858
859   /* Release module.  */
860   ath_mutex_lock (&ciphers_registered_lock);
861   _gcry_module_release (h->module);
862   ath_mutex_unlock (&ciphers_registered_lock);
863
864   /* We always want to wipe out the memory even when the context has
865      been allocated in secure memory.  The user might have disabled
866      secure memory or is using his own implementation which does not
867      do the wiping.  To accomplish this we need to keep track of the
868      actual size of this structure because we have no way to known
869      how large the allocated area was when using a standard malloc. */
870   off = h->handle_offset;
871   wipememory (h, h->actual_handle_size);
872
873   gcry_free ((char*)h - off);
874 }
875
876
877 /* Set the key to be used for the encryption context C to KEY with
878    length KEYLEN.  The length should match the required length. */
879 static gcry_error_t
880 cipher_setkey (gcry_cipher_hd_t c, byte *key, unsigned int keylen)
881 {
882   gcry_err_code_t ret;
883
884   ret = (*c->cipher->setkey) (&c->context.c, key, keylen);
885   if (!ret)
886     {
887       /* Duplicate initial context.  */
888       memcpy ((void *) ((char *) &c->context.c + c->cipher->contextsize),
889               (void *) &c->context.c,
890               c->cipher->contextsize);
891       c->marks.key = 1;
892     }
893   else
894     c->marks.key = 0;
895
896   return gcry_error (ret);
897 }
898
899
900 /* Set the IV to be used for the encryption context C to IV with
901    length IVLEN.  The length should match the required length. */
902 static void
903 cipher_setiv( gcry_cipher_hd_t c, const byte *iv, unsigned ivlen )
904 {
905   memset (c->u_iv.iv, 0, c->cipher->blocksize);
906   if (iv) 
907     {
908       if (ivlen != c->cipher->blocksize)
909         {
910           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
911                     ivlen, (unsigned int)c->cipher->blocksize);
912           fips_signal_error ("IV length does not match blocklength");
913         }
914       if (ivlen > c->cipher->blocksize)
915         ivlen = c->cipher->blocksize;
916       memcpy (c->u_iv.iv, iv, ivlen);
917       c->marks.iv = 1;
918     }
919   else
920       c->marks.iv = 0;
921   c->unused = 0;
922 }
923
924
925 /* Reset the cipher context to the initial context.  This is basically
926    the same as an release followed by a new. */
927 static void
928 cipher_reset (gcry_cipher_hd_t c)
929 {
930   memcpy (&c->context.c,
931           (char *) &c->context.c + c->cipher->contextsize,
932           c->cipher->contextsize);
933   memset (&c->marks, 0, sizeof c->marks);
934   memset (c->u_iv.iv, 0, c->cipher->blocksize);
935   memset (c->lastiv, 0, c->cipher->blocksize);
936   memset (c->ctr, 0, c->cipher->blocksize);
937 }
938
939
940 \f
941 static gcry_err_code_t
942 do_ecb_encrypt (gcry_cipher_hd_t c,
943                 unsigned char *outbuf, unsigned int outbuflen,
944                 const unsigned char *inbuf, unsigned int inbuflen)
945 {
946   unsigned int blocksize = c->cipher->blocksize;
947   unsigned int n, nblocks;
948   
949   if (outbuflen < inbuflen)
950     return GPG_ERR_BUFFER_TOO_SHORT;
951   if ((inbuflen % blocksize))
952     return GPG_ERR_INV_LENGTH;
953
954   nblocks = inbuflen / c->cipher->blocksize;
955
956   for (n=0; n < nblocks; n++ )
957     {
958       c->cipher->encrypt (&c->context.c, outbuf, (byte*)/*arggg*/inbuf);
959       inbuf  += blocksize;
960       outbuf += blocksize;
961     }
962   return 0;
963 }
964
965 static gcry_err_code_t
966 do_ecb_decrypt (gcry_cipher_hd_t c,
967                 unsigned char *outbuf, unsigned int outbuflen,
968                 const unsigned char *inbuf, unsigned int inbuflen)
969 {
970   unsigned int blocksize = c->cipher->blocksize;
971   unsigned int n, nblocks;
972
973   if (outbuflen < inbuflen)
974     return GPG_ERR_BUFFER_TOO_SHORT;
975   if ((inbuflen % blocksize))
976     return GPG_ERR_INV_LENGTH;
977   nblocks = inbuflen / c->cipher->blocksize;
978
979   for (n=0; n < nblocks; n++ ) 
980     {
981       c->cipher->decrypt (&c->context.c, outbuf, (byte*)/*arggg*/inbuf );
982       inbuf  += blocksize;
983       outbuf += blocksize;
984     }
985
986   return 0;
987 }
988
989
990 static gcry_err_code_t
991 do_cbc_encrypt (gcry_cipher_hd_t c,
992                 unsigned char *outbuf, unsigned int outbuflen,
993                 const unsigned char *inbuf, unsigned int inbuflen)
994 {
995   unsigned int n;
996   unsigned char *ivp;
997   int i;
998   size_t blocksize = c->cipher->blocksize;
999   unsigned nblocks = inbuflen / blocksize;
1000
1001   if (outbuflen < ((c->flags & GCRY_CIPHER_CBC_MAC)? blocksize : inbuflen))
1002     return GPG_ERR_BUFFER_TOO_SHORT;
1003
1004   if ((inbuflen % c->cipher->blocksize)
1005       && !(inbuflen > c->cipher->blocksize
1006            && (c->flags & GCRY_CIPHER_CBC_CTS)))
1007     return GPG_ERR_INV_LENGTH;
1008
1009   if ((c->flags & GCRY_CIPHER_CBC_CTS) && inbuflen > blocksize) 
1010     {
1011       if ((inbuflen % blocksize) == 0)
1012         nblocks--;
1013     }
1014
1015   if (c->bulk.cbc_enc)
1016     {
1017       c->bulk.cbc_enc (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks,
1018                        (c->flags & GCRY_CIPHER_CBC_MAC)); 
1019       inbuf  += nblocks * blocksize;
1020       if (!(c->flags & GCRY_CIPHER_CBC_MAC))
1021         outbuf += nblocks * blocksize;
1022     }
1023   else
1024     {
1025       for (n=0; n < nblocks; n++ )
1026         {
1027           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1028             outbuf[i] = inbuf[i] ^ *ivp++;
1029           c->cipher->encrypt ( &c->context.c, outbuf, outbuf );
1030           memcpy (c->u_iv.iv, outbuf, blocksize );
1031           inbuf  += blocksize;
1032           if (!(c->flags & GCRY_CIPHER_CBC_MAC))
1033             outbuf += blocksize;
1034         }
1035     }
1036
1037   if ((c->flags & GCRY_CIPHER_CBC_CTS) && inbuflen > blocksize)
1038     {
1039       /* We have to be careful here, since outbuf might be equal to
1040          inbuf.  */
1041       int restbytes;
1042       unsigned char b;
1043
1044       if ((inbuflen % blocksize) == 0)
1045         restbytes = blocksize;
1046       else
1047         restbytes = inbuflen % blocksize;
1048
1049       outbuf -= blocksize;
1050       for (ivp = c->u_iv.iv, i = 0; i < restbytes; i++)
1051         {
1052           b = inbuf[i];
1053           outbuf[blocksize + i] = outbuf[i];
1054           outbuf[i] = b ^ *ivp++;
1055         }
1056       for (; i < blocksize; i++)
1057         outbuf[i] = 0 ^ *ivp++;
1058       
1059       c->cipher->encrypt (&c->context.c, outbuf, outbuf);
1060       memcpy (c->u_iv.iv, outbuf, blocksize);
1061     }
1062
1063   return 0;
1064 }
1065
1066
1067 static gcry_err_code_t
1068 do_cbc_decrypt (gcry_cipher_hd_t c,
1069                 unsigned char *outbuf, unsigned int outbuflen,
1070                 const unsigned char *inbuf, unsigned int inbuflen)
1071 {
1072   unsigned int n;
1073   unsigned char *ivp;
1074   int i;
1075   size_t blocksize = c->cipher->blocksize;
1076   unsigned int nblocks = inbuflen / blocksize;
1077
1078   if (outbuflen < inbuflen)
1079     return GPG_ERR_BUFFER_TOO_SHORT;
1080
1081   if ((inbuflen % c->cipher->blocksize)
1082       && !(inbuflen > c->cipher->blocksize
1083            && (c->flags & GCRY_CIPHER_CBC_CTS)))
1084     return GPG_ERR_INV_LENGTH;
1085
1086   if ((c->flags & GCRY_CIPHER_CBC_CTS) && inbuflen > blocksize)
1087     {
1088       nblocks--;
1089       if ((inbuflen % blocksize) == 0)
1090         nblocks--;
1091       memcpy (c->lastiv, c->u_iv.iv, blocksize);
1092     }
1093
1094   if (c->bulk.cbc_dec)
1095     {
1096       c->bulk.cbc_dec (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1097       inbuf  += nblocks * blocksize;
1098       outbuf += nblocks * blocksize;
1099     }
1100   else
1101     {
1102       for (n=0; n < nblocks; n++ ) 
1103         {
1104           /* Because outbuf and inbuf might be the same, we have to
1105            * save the original ciphertext block.  We use LASTIV for
1106            * this here because it is not used otherwise. */
1107           memcpy (c->lastiv, inbuf, blocksize);
1108           c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
1109           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1110             outbuf[i] ^= *ivp++;
1111           memcpy(c->u_iv.iv, c->lastiv, blocksize );
1112           inbuf  += c->cipher->blocksize;
1113           outbuf += c->cipher->blocksize;
1114         }
1115     }
1116
1117   if ((c->flags & GCRY_CIPHER_CBC_CTS) && inbuflen > blocksize) 
1118     {
1119       int restbytes;
1120       
1121       if ((inbuflen % blocksize) == 0)
1122         restbytes = blocksize;
1123       else
1124         restbytes = inbuflen % blocksize;
1125       
1126       memcpy (c->lastiv, c->u_iv.iv, blocksize );         /* Save Cn-2. */
1127       memcpy (c->u_iv.iv, inbuf + blocksize, restbytes ); /* Save Cn. */
1128
1129       c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
1130       for (ivp=c->u_iv.iv,i=0; i < restbytes; i++ )
1131         outbuf[i] ^= *ivp++;
1132       
1133       memcpy(outbuf + blocksize, outbuf, restbytes);
1134       for(i=restbytes; i < blocksize; i++)
1135         c->u_iv.iv[i] = outbuf[i];
1136       c->cipher->decrypt (&c->context.c, outbuf, c->u_iv.iv);
1137       for(ivp=c->lastiv,i=0; i < blocksize; i++ )
1138         outbuf[i] ^= *ivp++;
1139       /* c->lastiv is now really lastlastiv, does this matter? */
1140     }
1141
1142   return 0;
1143 }
1144
1145
1146 static gcry_err_code_t
1147 do_cfb_encrypt (gcry_cipher_hd_t c,
1148                 unsigned char *outbuf, unsigned int outbuflen,
1149                 const unsigned char *inbuf, unsigned int inbuflen)
1150 {
1151   unsigned char *ivp;
1152   size_t blocksize = c->cipher->blocksize;
1153   size_t blocksize_x_2 = blocksize + blocksize;
1154   
1155   if (outbuflen < inbuflen)
1156     return GPG_ERR_BUFFER_TOO_SHORT;
1157
1158   if ( inbuflen <= c->unused )
1159     {
1160       /* Short enough to be encoded by the remaining XOR mask. */
1161       /* XOR the input with the IV and store input into IV. */
1162       for (ivp=c->u_iv.iv+c->cipher->blocksize - c->unused;
1163            inbuflen;
1164            inbuflen--, c->unused-- )
1165         *outbuf++ = (*ivp++ ^= *inbuf++);
1166       return 0;
1167     }
1168
1169   if ( c->unused )
1170     {
1171       /* XOR the input with the IV and store input into IV */
1172       inbuflen -= c->unused;
1173       for(ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1174         *outbuf++ = (*ivp++ ^= *inbuf++);
1175     }
1176
1177   /* Now we can process complete blocks.  We use a loop as long as we
1178      have at least 2 blocks and use conditions for the rest.  This
1179      also allows to use a bulk encryption function if available.  */
1180   if (inbuflen >= blocksize_x_2 && c->bulk.cfb_enc)
1181     {
1182       unsigned int nblocks = inbuflen / blocksize;
1183       c->bulk.cfb_enc (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1184       outbuf += nblocks * blocksize;
1185       inbuf  += nblocks * blocksize;
1186       inbuflen -= nblocks * blocksize;
1187     }
1188   else
1189     {
1190       while ( inbuflen >= blocksize_x_2 )
1191         {
1192           int i;
1193           /* Encrypt the IV. */
1194           c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1195           /* XOR the input with the IV and store input into IV.  */
1196           for(ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1197             *outbuf++ = (*ivp++ ^= *inbuf++);
1198           inbuflen -= blocksize;
1199         }
1200     }
1201
1202   if ( inbuflen >= blocksize )
1203     {
1204       int i;
1205       /* Save the current IV and then encrypt the IV. */
1206       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1207       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1208       /* XOR the input with the IV and store input into IV */
1209       for(ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1210         *outbuf++ = (*ivp++ ^= *inbuf++);
1211       inbuflen -= blocksize;
1212     }
1213   if ( inbuflen ) 
1214     {
1215       /* Save the current IV and then encrypt the IV. */
1216       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1217       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1218       c->unused = blocksize;
1219       /* Apply the XOR. */
1220       c->unused -= inbuflen;
1221       for(ivp=c->u_iv.iv; inbuflen; inbuflen-- )
1222         *outbuf++ = (*ivp++ ^= *inbuf++);
1223     }
1224   return 0;
1225 }
1226
1227
1228 static gcry_err_code_t
1229 do_cfb_decrypt (gcry_cipher_hd_t c,
1230                 unsigned char *outbuf, unsigned int outbuflen,
1231                 const unsigned char *inbuf, unsigned int inbuflen)
1232 {
1233   unsigned char *ivp;
1234   unsigned long temp;
1235   int i;
1236   size_t blocksize = c->cipher->blocksize;
1237   size_t blocksize_x_2 = blocksize + blocksize;
1238   
1239   if (outbuflen < inbuflen)
1240     return GPG_ERR_BUFFER_TOO_SHORT;
1241
1242   if (inbuflen <= c->unused)
1243     {
1244       /* Short enough to be encoded by the remaining XOR mask. */
1245       /* XOR the input with the IV and store input into IV. */
1246       for (ivp=c->u_iv.iv+blocksize - c->unused;
1247            inbuflen; 
1248            inbuflen--, c->unused--)
1249         {
1250           temp = *inbuf++;
1251           *outbuf++ = *ivp ^ temp;
1252           *ivp++ = temp;
1253         }
1254       return 0;
1255     }
1256   
1257   if (c->unused)
1258     {
1259       /* XOR the input with the IV and store input into IV. */
1260       inbuflen -= c->unused;
1261       for (ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1262         {
1263           temp = *inbuf++;
1264           *outbuf++ = *ivp ^ temp;
1265           *ivp++ = temp;
1266         }
1267     }
1268   
1269   /* Now we can process complete blocks.  We use a loop as long as we
1270      have at least 2 blocks and use conditions for the rest.  This
1271      also allows to use a bulk encryption function if available.  */
1272   if (inbuflen >= blocksize_x_2 && c->bulk.cfb_dec)
1273     {
1274       unsigned int nblocks = inbuflen / blocksize;
1275       c->bulk.cfb_dec (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1276       outbuf += nblocks * blocksize;
1277       inbuf  += nblocks * blocksize;
1278       inbuflen -= nblocks * blocksize;
1279     }
1280   else
1281     {
1282       while (inbuflen >= blocksize_x_2 )
1283         {
1284           /* Encrypt the IV. */
1285           c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1286           /* XOR the input with the IV and store input into IV. */
1287           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1288             {
1289               temp = *inbuf++;
1290               *outbuf++ = *ivp ^ temp;
1291               *ivp++ = temp;
1292             }
1293           inbuflen -= blocksize;
1294         }
1295     }
1296
1297   if (inbuflen >= blocksize )
1298     {
1299       /* Save the current IV and then encrypt the IV. */
1300       memcpy ( c->lastiv, c->u_iv.iv, blocksize);
1301       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1302       /* XOR the input with the IV and store input into IV */
1303       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1304         {
1305           temp = *inbuf++;
1306           *outbuf++ = *ivp ^ temp;
1307           *ivp++ = temp;
1308         }
1309       inbuflen -= blocksize;
1310     }
1311
1312   if (inbuflen)
1313     { 
1314       /* Save the current IV and then encrypt the IV. */
1315       memcpy ( c->lastiv, c->u_iv.iv, blocksize );
1316       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1317       c->unused = blocksize;
1318       /* Apply the XOR. */
1319       c->unused -= inbuflen;
1320       for (ivp=c->u_iv.iv; inbuflen; inbuflen-- )
1321         {
1322           temp = *inbuf++;
1323           *outbuf++ = *ivp ^ temp;
1324           *ivp++ = temp;
1325         }
1326     }
1327   return 0;
1328 }
1329
1330
1331 static gcry_err_code_t
1332 do_ofb_encrypt (gcry_cipher_hd_t c,
1333                 unsigned char *outbuf, unsigned int outbuflen,
1334                 const unsigned char *inbuf, unsigned int inbuflen)
1335 {
1336   unsigned char *ivp;
1337   size_t blocksize = c->cipher->blocksize;
1338
1339   if (outbuflen < inbuflen)
1340     return GPG_ERR_BUFFER_TOO_SHORT;
1341
1342   if ( inbuflen <= c->unused )
1343     {
1344       /* Short enough to be encoded by the remaining XOR mask. */
1345       /* XOR the input with the IV */
1346       for (ivp=c->u_iv.iv+c->cipher->blocksize - c->unused;
1347            inbuflen;
1348            inbuflen--, c->unused-- )
1349         *outbuf++ = (*ivp++ ^ *inbuf++);
1350       return 0;
1351     }
1352
1353   if( c->unused )
1354     {
1355       inbuflen -= c->unused;
1356       for(ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1357         *outbuf++ = (*ivp++ ^ *inbuf++);
1358     }
1359
1360   /* Now we can process complete blocks. */
1361   while ( inbuflen >= blocksize )
1362     {
1363       int i;
1364       /* Encrypt the IV (and save the current one). */
1365       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1366       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1367       
1368       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1369         *outbuf++ = (*ivp++ ^ *inbuf++);
1370       inbuflen -= blocksize;
1371     }
1372   if ( inbuflen )
1373     { /* process the remaining bytes */
1374       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1375       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1376       c->unused = blocksize;
1377       c->unused -= inbuflen;
1378       for(ivp=c->u_iv.iv; inbuflen; inbuflen-- )
1379         *outbuf++ = (*ivp++ ^ *inbuf++);
1380     }
1381   return 0;
1382 }
1383
1384 static gcry_err_code_t
1385 do_ofb_decrypt (gcry_cipher_hd_t c,
1386                 unsigned char *outbuf, unsigned int outbuflen,
1387                 const unsigned char *inbuf, unsigned int inbuflen)
1388 {
1389   unsigned char *ivp;
1390   size_t blocksize = c->cipher->blocksize;
1391   
1392   if (outbuflen < inbuflen)
1393     return GPG_ERR_BUFFER_TOO_SHORT;
1394
1395   if( inbuflen <= c->unused )
1396     {
1397       /* Short enough to be encoded by the remaining XOR mask. */
1398       for (ivp=c->u_iv.iv+blocksize - c->unused; inbuflen; inbuflen--,c->unused--)
1399         *outbuf++ = *ivp++ ^ *inbuf++;
1400       return 0;
1401     }
1402
1403   if ( c->unused )
1404     {
1405       inbuflen -= c->unused;
1406       for (ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1407         *outbuf++ = *ivp++ ^ *inbuf++;
1408     }
1409
1410   /* Now we can process complete blocks. */
1411   while ( inbuflen >= blocksize )
1412     {
1413       int i;
1414       /* Encrypt the IV (and save the current one). */
1415       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1416       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1417       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1418         *outbuf++ = *ivp++ ^ *inbuf++;
1419       inbuflen -= blocksize;
1420     }
1421   if ( inbuflen ) 
1422     { /* Process the remaining bytes. */
1423       /* Encrypt the IV (and save the current one). */
1424       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1425       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1426       c->unused = blocksize;
1427       c->unused -= inbuflen;
1428       for (ivp=c->u_iv.iv; inbuflen; inbuflen-- )
1429         *outbuf++ = *ivp++ ^ *inbuf++;
1430     }
1431   return 0;
1432 }
1433
1434
1435 static gcry_err_code_t
1436 do_ctr_encrypt (gcry_cipher_hd_t c,
1437                 unsigned char *outbuf, unsigned int outbuflen,
1438                 const unsigned char *inbuf, unsigned int inbuflen)
1439 {
1440   unsigned int n;
1441   unsigned char tmp[MAX_BLOCKSIZE];
1442   int i;
1443   unsigned int blocksize = c->cipher->blocksize;
1444
1445   if (outbuflen < inbuflen)
1446     return GPG_ERR_BUFFER_TOO_SHORT;
1447
1448   if ((inbuflen % blocksize))
1449     return GPG_ERR_INV_LENGTH;
1450
1451   for (n=0; n < inbuflen; n++)
1452     {
1453       if ((n % blocksize) == 0)
1454         {
1455           c->cipher->encrypt (&c->context.c, tmp, c->ctr);
1456
1457           for (i = blocksize; i > 0; i--)
1458             {
1459               c->ctr[i-1]++;
1460               if (c->ctr[i-1] != 0)
1461                 break;
1462             }
1463         }
1464
1465       /* XOR input with encrypted counter and store in output.  */
1466       outbuf[n] = inbuf[n] ^ tmp[n % blocksize];
1467     }
1468
1469   wipememory (tmp, sizeof tmp);
1470   return 0;
1471 }
1472
1473 static gcry_err_code_t
1474 do_ctr_decrypt (gcry_cipher_hd_t c,
1475                 unsigned char *outbuf, unsigned int outbuflen,
1476                 const unsigned char *inbuf, unsigned int inbuflen)
1477 {
1478   return do_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1479 }
1480
1481
1482 /* Perform the AES-Wrap algorithm as specified by RFC3394.  We
1483    implement this as a mode usable with any cipher algorithm of
1484    blocksize 128.  */
1485 static gcry_err_code_t
1486 do_aeswrap_encrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
1487                     const byte *inbuf, unsigned int inbuflen )
1488 {
1489   int j, x;
1490   unsigned int n, i;
1491   unsigned char *r, *a, *b;
1492   unsigned char t[8];
1493
1494 #if MAX_BLOCKSIZE < 8
1495 #error Invalid block size
1496 #endif
1497   /* We require a cipher with a 128 bit block length.  */
1498   if (c->cipher->blocksize != 16)
1499     return GPG_ERR_INV_LENGTH;  
1500   
1501   /* The output buffer must be able to hold the input data plus one
1502      additional block.  */
1503   if (outbuflen < inbuflen + 8)
1504     return GPG_ERR_BUFFER_TOO_SHORT;
1505   /* Input data must be multiple of 64 bits.  */
1506   if (inbuflen % 8)
1507     return GPG_ERR_INV_ARG;   
1508
1509   n = inbuflen / 8;
1510
1511   /* We need at least two 64 bit blocks.  */
1512   if (n < 2)
1513     return GPG_ERR_INV_ARG;
1514
1515   r = outbuf; 
1516   a = outbuf;  /* We store A directly in OUTBUF.  */
1517   b = c->ctr;  /* B is also used to concatenate stuff.  */
1518
1519   /* If an IV has been set we use that IV as the Alternative Initial
1520      Value; if it has not been set we use the standard value.  */
1521   if (c->marks.iv)
1522     memcpy (a, c->u_iv.iv, 8);
1523   else
1524     memset (a, 0xa6, 8);
1525
1526   /* Copy the inbuf to the outbuf. */
1527   memmove (r+8, inbuf, inbuflen);
1528
1529   memset (t, 0, sizeof t); /* t := 0.  */
1530
1531   for (j = 0; j <= 5; j++)
1532     {
1533       for (i = 1; i <= n; i++)
1534         {
1535           /* B := AES_k( A | R[i] ) */
1536           memcpy (b, a, 8);
1537           memcpy (b+8, r+i*8, 8);
1538           c->cipher->encrypt (&c->context.c, b, b);
1539           /* t := t + 1  */
1540           for (x = 7; x >= 0; x--)
1541             {
1542               t[x]++;
1543               if (t[x])
1544                 break;
1545             }
1546           /* A := MSB_64(B) ^ t */
1547           for (x=0; x < 8; x++)
1548             a[x] = b[x] ^ t[x];
1549           /* R[i] := LSB_64(B) */
1550           memcpy (r+i*8, b+8, 8);
1551         }
1552    }
1553   
1554   return 0;
1555 }
1556
1557 /* Perform the AES-Unwrap algorithm as specified by RFC3394.  We
1558    implement this as a mode usable with any cipher algorithm of
1559    blocksize 128.  */
1560 static gcry_err_code_t
1561 do_aeswrap_decrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
1562                     const byte *inbuf, unsigned int inbuflen)
1563 {
1564   int j, x;
1565   unsigned int n, i;
1566   unsigned char *r, *a, *b;
1567   unsigned char t[8];
1568
1569 #if MAX_BLOCKSIZE < 8
1570 #error Invalid block size
1571 #endif
1572   /* We require a cipher with a 128 bit block length.  */
1573   if (c->cipher->blocksize != 16)
1574     return GPG_ERR_INV_LENGTH;  
1575   
1576   /* The output buffer must be able to hold the input data minus one
1577      additional block.  Fixme: The caller has more restrictive checks
1578      - we may want to fix them for this mode.  */
1579   if (outbuflen + 8  < inbuflen)
1580     return GPG_ERR_BUFFER_TOO_SHORT;
1581   /* Input data must be multiple of 64 bits.  */
1582   if (inbuflen % 8)
1583     return GPG_ERR_INV_ARG;   
1584
1585   n = inbuflen / 8;
1586
1587   /* We need at least three 64 bit blocks.  */
1588   if (n < 3)
1589     return GPG_ERR_INV_ARG;
1590
1591   r = outbuf; 
1592   a = c->lastiv;  /* We use c->LASTIV as buffer for A.  */
1593   b = c->ctr;     /* B is also used to concatenate stuff.  */
1594
1595   /* Copy the inbuf to the outbuf and save A. */
1596   memcpy (a, inbuf, 8);
1597   memmove (r, inbuf+8, inbuflen-8);
1598   n--; /* Reduce to actual number of data blocks.  */
1599
1600   /* t := 6 * n  */
1601   i = n * 6;  /* The range is valid because: n = inbuflen / 8 - 1.  */
1602   for (x=0; x < 8 && x < sizeof (i); x++)
1603     t[7-x] = i >> (8*x);
1604   for (; x < 8; x++)
1605     t[7-x] = 0;
1606
1607   for (j = 5; j >= 0; j--)
1608     {
1609       for (i = n; i >= 1; i--)
1610         {
1611           /* B := AES_k^1( (A ^ t)| R[i] ) */
1612           for (x = 0; x < 8; x++)
1613             b[x] = a[x] ^ t[x];
1614           memcpy (b+8, r+(i-1)*8, 8);
1615           c->cipher->decrypt (&c->context.c, b, b);
1616           /* t := t - 1  */
1617           for (x = 7; x >= 0; x--)
1618             {
1619               t[x]--;
1620               if (t[x] != 0xff)
1621                 break;
1622             }
1623           /* A := MSB_64(B) */
1624           memcpy (a, b, 8);
1625           /* R[i] := LSB_64(B) */
1626           memcpy (r+(i-1)*8, b+8, 8);
1627         }
1628    }
1629
1630   /* If an IV has been set we compare against this Alternative Initial
1631      Value; if it has not been set we compare against the standard IV.  */
1632   if (c->marks.iv)
1633     j = memcmp (a, c->u_iv.iv, 8);
1634   else
1635     {
1636       for (j=0, x=0; x < 8; x++)
1637         if (a[x] != 0xa6)
1638           {
1639             j=1;
1640             break;
1641           }
1642     }
1643   return j? GPG_ERR_CHECKSUM : 0;
1644 }
1645
1646
1647 /****************
1648  * Encrypt INBUF to OUTBUF with the mode selected at open.
1649  * inbuf and outbuf may overlap or be the same.
1650  * Depending on the mode some constraints apply to INBUFLEN.
1651  */
1652 static gcry_err_code_t
1653 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
1654                 const byte *inbuf, unsigned int inbuflen)
1655 {
1656   gcry_err_code_t rc;
1657
1658   switch (c->mode)
1659     {
1660     case GCRY_CIPHER_MODE_ECB:
1661       rc = do_ecb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1662       break;
1663
1664     case GCRY_CIPHER_MODE_CBC:
1665       rc = do_cbc_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1666       break;
1667       
1668     case GCRY_CIPHER_MODE_CFB:
1669       rc = do_cfb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1670       break;
1671
1672     case GCRY_CIPHER_MODE_OFB:
1673       rc = do_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1674       break;
1675
1676     case GCRY_CIPHER_MODE_CTR:
1677       rc = do_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1678       break;
1679
1680     case GCRY_CIPHER_MODE_AESWRAP:
1681       rc = do_aeswrap_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1682       break;
1683
1684     case GCRY_CIPHER_MODE_STREAM:
1685       c->cipher->stencrypt (&c->context.c,
1686                             outbuf, (byte*)/*arggg*/inbuf, inbuflen);
1687       rc = 0;
1688       break;
1689
1690     case GCRY_CIPHER_MODE_NONE:
1691       if (fips_mode () || !_gcry_get_debug_flag (0))
1692         {
1693           fips_signal_error ("cipher mode NONE used");
1694           rc = GPG_ERR_INV_CIPHER_MODE;
1695         }
1696       else
1697         {
1698           if (inbuf != outbuf)
1699             memmove (outbuf, inbuf, inbuflen);
1700           rc = 0;
1701         }
1702       break;
1703       
1704     default:
1705       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
1706       rc = GPG_ERR_INV_CIPHER_MODE;
1707       break;
1708     }
1709
1710   return rc;
1711 }
1712
1713
1714 /****************
1715  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
1716  * been requested.
1717  */
1718 gcry_error_t
1719 gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1720                      const void *in, size_t inlen)
1721 {
1722   gcry_err_code_t err;
1723
1724   if (!in)  /* Caller requested in-place encryption.  */
1725     err = cipher_encrypt (h, out, outsize, out, outsize);
1726   else
1727     err = cipher_encrypt (h, out, outsize, in, inlen);
1728
1729   /* Failsafe: Make sure that the plaintext will never make it into
1730      OUT if the encryption returned an error.  */
1731   if (err && out)
1732     memset (out, 0x42, outsize); 
1733
1734   return gcry_error (err);
1735 }
1736
1737
1738
1739 /****************
1740  * Decrypt INBUF to OUTBUF with the mode selected at open.
1741  * inbuf and outbuf may overlap or be the same.
1742  * Depending on the mode some some contraints apply to INBUFLEN.
1743  */
1744 static gcry_err_code_t
1745 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
1746                 const byte *inbuf, unsigned int inbuflen)
1747 {
1748   gcry_err_code_t rc;
1749
1750   switch (c->mode)
1751     {
1752     case GCRY_CIPHER_MODE_ECB:
1753       rc = do_ecb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1754       break;
1755
1756     case GCRY_CIPHER_MODE_CBC:
1757       rc = do_cbc_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1758       break;
1759
1760     case GCRY_CIPHER_MODE_CFB:
1761       rc = do_cfb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1762       break;
1763
1764     case GCRY_CIPHER_MODE_OFB:
1765       rc = do_ofb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1766       break;
1767
1768     case GCRY_CIPHER_MODE_CTR:
1769       rc = do_ctr_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1770       break;
1771
1772     case GCRY_CIPHER_MODE_AESWRAP:
1773       rc = do_aeswrap_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1774       break;
1775
1776     case GCRY_CIPHER_MODE_STREAM:
1777       c->cipher->stdecrypt (&c->context.c,
1778                             outbuf, (byte*)/*arggg*/inbuf, inbuflen);
1779       rc = 0;
1780       break;
1781
1782     case GCRY_CIPHER_MODE_NONE:
1783       if (fips_mode () || !_gcry_get_debug_flag (0))
1784         {
1785           fips_signal_error ("cipher mode NONE used");
1786           rc = GPG_ERR_INV_CIPHER_MODE;
1787         }
1788       else
1789         {
1790           if (inbuf != outbuf)
1791             memmove (outbuf, inbuf, inbuflen);
1792           rc = 0;
1793         }
1794       break;
1795       
1796     default:
1797       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1798       rc = GPG_ERR_INV_CIPHER_MODE;
1799       break;
1800     }
1801
1802   return rc;
1803 }
1804
1805
1806 gcry_error_t
1807 gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1808                      const void *in, size_t inlen)
1809 {
1810   gcry_err_code_t err;
1811
1812   if (!in) /* Caller requested in-place encryption. */
1813     err = cipher_decrypt (h, out, outsize, out, outsize);
1814   else
1815     err = cipher_decrypt (h, out, outsize, in, inlen);
1816
1817   return gcry_error (err);
1818 }
1819
1820
1821
1822 /****************
1823  * Used for PGP's somewhat strange CFB mode. Only works if
1824  * the corresponding flag is set.
1825  */
1826 static void
1827 cipher_sync (gcry_cipher_hd_t c)
1828 {
1829   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1830     {
1831       memmove (c->u_iv.iv + c->unused,
1832                c->u_iv.iv, c->cipher->blocksize - c->unused);
1833       memcpy (c->u_iv.iv,
1834               c->lastiv + c->cipher->blocksize - c->unused, c->unused);
1835       c->unused = 0;
1836     }
1837 }
1838
1839
1840 gcry_error_t
1841 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
1842 {
1843   return cipher_setkey (hd, (void*)key, keylen);
1844 }
1845
1846
1847 gcry_error_t
1848 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
1849 {
1850   cipher_setiv (hd, iv, ivlen);
1851   return 0;
1852 }
1853
1854 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1855    block size length, or (NULL,0) to set the CTR to the all-zero
1856    block. */
1857 gpg_error_t
1858 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1859 {
1860   if (ctr && ctrlen == hd->cipher->blocksize)
1861     memcpy (hd->ctr, ctr, hd->cipher->blocksize);
1862   else if (!ctr || !ctrlen)
1863     memset (hd->ctr, 0, hd->cipher->blocksize);
1864   else
1865     return gpg_error (GPG_ERR_INV_ARG);
1866   return 0;
1867 }
1868
1869
1870 gcry_error_t
1871 gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1872 {
1873   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1874
1875   switch (cmd)
1876     {
1877     case GCRYCTL_SET_KEY:  /* Deprecated; use gcry_cipher_setkey.  */
1878       rc = cipher_setkey( h, buffer, buflen );
1879       break;
1880
1881     case GCRYCTL_SET_IV:   /* Deprecated; use gcry_cipher_setiv.  */
1882       cipher_setiv( h, buffer, buflen );
1883       break;
1884
1885     case GCRYCTL_RESET:
1886       cipher_reset (h);
1887       break;
1888
1889     case GCRYCTL_CFB_SYNC:
1890       cipher_sync( h );
1891       break;
1892
1893     case GCRYCTL_SET_CBC_CTS:
1894       if (buflen)
1895         if (h->flags & GCRY_CIPHER_CBC_MAC)
1896           rc = GPG_ERR_INV_FLAG;
1897         else
1898           h->flags |= GCRY_CIPHER_CBC_CTS;
1899       else
1900         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1901       break;
1902
1903     case GCRYCTL_SET_CBC_MAC:
1904       if (buflen)
1905         if (h->flags & GCRY_CIPHER_CBC_CTS)
1906           rc = GPG_ERR_INV_FLAG;
1907         else
1908           h->flags |= GCRY_CIPHER_CBC_MAC;
1909       else
1910         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1911       break;
1912
1913     case GCRYCTL_DISABLE_ALGO:
1914       /* This command expects NULL for H and BUFFER to point to an
1915          integer with the algo number.  */
1916       if( h || !buffer || buflen != sizeof(int) )
1917         return gcry_error (GPG_ERR_CIPHER_ALGO);
1918       disable_cipher_algo( *(int*)buffer );
1919       break;
1920
1921     case GCRYCTL_SET_CTR: /* Deprecated; use gcry_cipher_setctr.  */
1922       if (buffer && buflen == h->cipher->blocksize)
1923         memcpy (h->ctr, buffer, h->cipher->blocksize);
1924       else if (buffer == NULL || buflen == 0)
1925         memset (h->ctr, 0, h->cipher->blocksize);
1926       else
1927         rc = GPG_ERR_INV_ARG;
1928       break;
1929
1930     case 61:  /* Disable weak key detection (private).  */
1931       if (h->extraspec->set_extra_info)
1932         rc = h->extraspec->set_extra_info 
1933           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1934       else
1935         rc = GPG_ERR_NOT_SUPPORTED;
1936       break;
1937
1938     case 62: /* Return current input vector (private).  */
1939       /* This is the input block as used in CFB and OFB mode which has
1940          initially been set as IV.  The returned format is: 
1941            1 byte  Actual length of the block in bytes.
1942            n byte  The block.
1943          If the provided buffer is too short, an error is returned. */
1944       if (buflen < (1 + h->cipher->blocksize))
1945         rc = GPG_ERR_TOO_SHORT;
1946       else
1947         {
1948           unsigned char *ivp;
1949           unsigned char *dst = buffer;
1950           int n = h->unused;
1951           
1952           if (!n)
1953             n = h->cipher->blocksize;
1954           gcry_assert (n <= h->cipher->blocksize);
1955           *dst++ = n;
1956           ivp = h->u_iv.iv + h->cipher->blocksize - n;
1957           while (n--)
1958             *dst++ = *ivp++;
1959         }
1960       break;
1961
1962     default:
1963       rc = GPG_ERR_INV_OP;
1964     }
1965
1966   return gcry_error (rc);
1967 }
1968
1969
1970 /* Return information about the cipher handle H.  CMD is the kind of
1971    information requested.  BUFFER and NBYTES are reserved for now.
1972
1973    There are no values for CMD yet defined.  
1974
1975    The function always returns GPG_ERR_INV_OP.
1976    
1977  */
1978 gcry_error_t
1979 gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1980 {
1981   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1982
1983   (void)h;
1984   (void)buffer;
1985   (void)nbytes;
1986
1987   switch (cmd)
1988     {
1989     default:
1990       err = GPG_ERR_INV_OP;
1991     }
1992
1993   return gcry_error (err);
1994 }
1995
1996 /* Return information about the given cipher algorithm ALGO.
1997
1998    WHAT select the kind of information returned:
1999
2000     GCRYCTL_GET_KEYLEN:
2001         Return the length of the key.  If the algorithm ALGO
2002         supports multiple key lengths, the maximum supported key length
2003         is returned.  The key length is returned as number of octets.
2004         BUFFER and NBYTES must be zero.
2005
2006     GCRYCTL_GET_BLKLEN:
2007         Return the blocklength of the algorithm ALGO counted in octets.
2008         BUFFER and NBYTES must be zero.
2009
2010     GCRYCTL_TEST_ALGO:
2011         Returns 0 if the specified algorithm ALGO is available for use.
2012         BUFFER and NBYTES must be zero.
2013   
2014    Note: Because this function is in most cases used to return an
2015    integer value, we can make it easier for the caller to just look at
2016    the return value.  The caller will in all cases consult the value
2017    and thereby detecting whether a error occurred or not (i.e. while
2018    checking the block size)
2019  */
2020 gcry_error_t
2021 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
2022 {
2023   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2024   unsigned int ui;
2025
2026   switch (what)
2027     {
2028     case GCRYCTL_GET_KEYLEN:
2029       if (buffer || (! nbytes))
2030         err = GPG_ERR_CIPHER_ALGO;
2031       else
2032         {
2033           ui = cipher_get_keylen (algo);
2034           if ((ui > 0) && (ui <= 512))
2035             *nbytes = (size_t) ui / 8;
2036           else
2037             /* The only reason is an invalid algo or a strange
2038                blocksize.  */
2039             err = GPG_ERR_CIPHER_ALGO;
2040         }
2041       break;
2042
2043     case GCRYCTL_GET_BLKLEN:
2044       if (buffer || (! nbytes))
2045         err = GPG_ERR_CIPHER_ALGO;
2046       else
2047         {
2048           ui = cipher_get_blocksize (algo);
2049           if ((ui > 0) && (ui < 10000))
2050             *nbytes = ui;
2051           else
2052             /* The only reason is an invalid algo or a strange
2053                blocksize.  */
2054             err = GPG_ERR_CIPHER_ALGO;
2055         }
2056       break;
2057
2058     case GCRYCTL_TEST_ALGO:
2059       if (buffer || nbytes)
2060         err = GPG_ERR_INV_ARG;
2061       else
2062         err = check_cipher_algo (algo);
2063       break;
2064
2065       default:
2066         err = GPG_ERR_INV_OP;
2067     }
2068
2069   return gcry_error (err);
2070 }
2071
2072
2073 /* This function returns length of the key for algorithm ALGO.  If the
2074    algorithm supports multiple key lengths, the maximum supported key
2075    length is returned.  On error 0 is returned.  The key length is
2076    returned as number of octets.
2077
2078    This is a convenience functions which should be preferred over
2079    gcry_cipher_algo_info because it allows for proper type
2080    checking.  */
2081 size_t
2082 gcry_cipher_get_algo_keylen (int algo) 
2083 {
2084   size_t n;
2085
2086   if (gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
2087     n = 0;
2088   return n;
2089 }
2090
2091 /* This functions returns the blocklength of the algorithm ALGO
2092    counted in octets.  On error 0 is returned.
2093
2094    This is a convenience functions which should be preferred over
2095    gcry_cipher_algo_info because it allows for proper type
2096    checking.  */
2097 size_t
2098 gcry_cipher_get_algo_blklen (int algo) 
2099 {
2100   size_t n;
2101
2102   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
2103     n = 0;
2104   return n;
2105 }
2106
2107 /* Explicitly initialize this module.  */
2108 gcry_err_code_t
2109 _gcry_cipher_init (void)
2110 {
2111   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2112
2113   REGISTER_DEFAULT_CIPHERS;
2114
2115   return err;
2116 }
2117
2118 /* Get a list consisting of the IDs of the loaded cipher modules.  If
2119    LIST is zero, write the number of loaded cipher modules to
2120    LIST_LENGTH and return.  If LIST is non-zero, the first
2121    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
2122    according size.  In case there are less cipher modules than
2123    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
2124 gcry_error_t
2125 gcry_cipher_list (int *list, int *list_length)
2126 {
2127   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2128
2129   ath_mutex_lock (&ciphers_registered_lock);
2130   err = _gcry_module_list (ciphers_registered, list, list_length);
2131   ath_mutex_unlock (&ciphers_registered_lock);
2132
2133   return err;
2134 }
2135
2136
2137 /* Run the selftests for cipher algorithm ALGO with optional reporting
2138    function REPORT.  */
2139 gpg_error_t
2140 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
2141 {
2142   gcry_module_t module = NULL;
2143   cipher_extra_spec_t *extraspec = NULL;
2144   gcry_err_code_t ec = 0;
2145
2146   REGISTER_DEFAULT_CIPHERS;
2147
2148   ath_mutex_lock (&ciphers_registered_lock);
2149   module = _gcry_module_lookup_id (ciphers_registered, algo);
2150   if (module && !(module->flags & FLAG_MODULE_DISABLED))
2151     extraspec = module->extraspec;
2152   ath_mutex_unlock (&ciphers_registered_lock);
2153   if (extraspec && extraspec->selftest)
2154     ec = extraspec->selftest (algo, extended, report);
2155   else
2156     {
2157       ec = GPG_ERR_CIPHER_ALGO;
2158       if (report)
2159         report ("cipher", algo, "module", 
2160                 module && !(module->flags & FLAG_MODULE_DISABLED)?
2161                 "no selftest available" :
2162                 module? "algorithm disabled" : "algorithm not found");
2163     }
2164
2165   if (module)
2166     {
2167       ath_mutex_lock (&ciphers_registered_lock);
2168       _gcry_module_release (module);
2169       ath_mutex_unlock (&ciphers_registered_lock);
2170     }
2171   return gpg_error (ec);
2172 }