Fix bug 1263
[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         }
702       else
703         {
704           cipher = (gcry_cipher_spec_t *) module->spec;
705           extraspec = module->extraspec;
706         }
707     }
708   else
709     err = GPG_ERR_CIPHER_ALGO;
710   ath_mutex_unlock (&ciphers_registered_lock);
711
712   /* check flags */
713   if ((! err)
714       && ((flags & ~(0 
715                      | GCRY_CIPHER_SECURE
716                      | GCRY_CIPHER_ENABLE_SYNC
717                      | GCRY_CIPHER_CBC_CTS
718                      | GCRY_CIPHER_CBC_MAC))
719           || (flags & GCRY_CIPHER_CBC_CTS & GCRY_CIPHER_CBC_MAC)))
720     err = GPG_ERR_CIPHER_ALGO;
721
722   /* check that a valid mode has been requested */
723   if (! err)
724     switch (mode)
725       {
726       case GCRY_CIPHER_MODE_ECB:
727       case GCRY_CIPHER_MODE_CBC:
728       case GCRY_CIPHER_MODE_CFB:
729       case GCRY_CIPHER_MODE_OFB:
730       case GCRY_CIPHER_MODE_CTR:
731       case GCRY_CIPHER_MODE_AESWRAP:
732         if ((cipher->encrypt == dummy_encrypt_block)
733             || (cipher->decrypt == dummy_decrypt_block))
734           err = GPG_ERR_INV_CIPHER_MODE;
735         break;
736
737       case GCRY_CIPHER_MODE_STREAM:
738         if ((cipher->stencrypt == dummy_encrypt_stream)
739             || (cipher->stdecrypt == dummy_decrypt_stream))
740           err = GPG_ERR_INV_CIPHER_MODE;
741         break;
742
743       case GCRY_CIPHER_MODE_NONE:
744         /* This mode may be used for debugging.  It copies the main
745            text verbatim to the ciphertext.  We do not allow this in
746            fips mode or if no debug flag has been set.  */
747         if (fips_mode () || !_gcry_get_debug_flag (0))
748           err = GPG_ERR_INV_CIPHER_MODE;
749         break;
750
751       default:
752         err = GPG_ERR_INV_CIPHER_MODE;
753       }
754
755   /* Perform selftest here and mark this with a flag in cipher_table?
756      No, we should not do this as it takes too long.  Further it does
757      not make sense to exclude algorithms with failing selftests at
758      runtime: If a selftest fails there is something seriously wrong
759      with the system and thus we better die immediately. */
760
761   if (! err)
762     {
763       size_t size = (sizeof (*h)
764                      + 2 * cipher->contextsize
765                      - sizeof (cipher_context_alignment_t)
766 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
767                      + 15  /* Space for leading alignment gap.  */
768 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
769                      );
770
771       if (secure)
772         h = gcry_calloc_secure (1, size);
773       else
774         h = gcry_calloc (1, size);
775
776       if (! h)
777         err = gpg_err_code_from_errno (errno);
778       else
779         {
780           size_t off = 0;
781
782 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
783           if ( ((unsigned long)h & 0x0f) )
784             {
785               /* The malloced block is not aligned on a 16 byte
786                  boundary.  Correct for this.  */
787               off = 16 - ((unsigned long)h & 0x0f);
788               h = (void*)((char*)h + off);
789             }
790 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
791
792           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
793           h->actual_handle_size = size - off;
794           h->handle_offset = off;
795           h->cipher = cipher;
796           h->extraspec = extraspec;
797           h->module = module;
798           h->algo = algo;
799           h->mode = mode;
800           h->flags = flags;
801
802           /* Setup bulk encryption routines.  */
803           switch (algo)
804             {
805 #ifdef USE_AES
806             case GCRY_CIPHER_AES128:
807             case GCRY_CIPHER_AES192:
808             case GCRY_CIPHER_AES256:
809               h->bulk.cfb_enc = _gcry_aes_cfb_enc;
810               h->bulk.cfb_dec = _gcry_aes_cfb_dec;
811               h->bulk.cbc_enc = _gcry_aes_cbc_enc;
812               h->bulk.cbc_dec = _gcry_aes_cbc_dec;
813               break;
814 #endif /*USE_AES*/
815               
816             default:
817               break;
818             }
819         }
820     }
821
822   /* Done.  */
823
824   if (err)
825     {
826       if (module)
827         {
828           /* Release module.  */
829           ath_mutex_lock (&ciphers_registered_lock);
830           _gcry_module_release (module);
831           ath_mutex_unlock (&ciphers_registered_lock);
832         }
833     }
834
835   *handle = err ? NULL : h;
836
837   return gcry_error (err);
838 }
839
840
841 /* Release all resources associated with the cipher handle H. H may be
842    NULL in which case this is a no-operation. */
843 void
844 gcry_cipher_close (gcry_cipher_hd_t h)
845 {
846   size_t off;
847
848   if (!h)
849     return;
850
851   if ((h->magic != CTX_MAGIC_SECURE)
852       && (h->magic != CTX_MAGIC_NORMAL))
853     _gcry_fatal_error(GPG_ERR_INTERNAL,
854                       "gcry_cipher_close: already closed/invalid handle");
855   else
856     h->magic = 0;
857
858   /* Release module.  */
859   ath_mutex_lock (&ciphers_registered_lock);
860   _gcry_module_release (h->module);
861   ath_mutex_unlock (&ciphers_registered_lock);
862
863   /* We always want to wipe out the memory even when the context has
864      been allocated in secure memory.  The user might have disabled
865      secure memory or is using his own implementation which does not
866      do the wiping.  To accomplish this we need to keep track of the
867      actual size of this structure because we have no way to known
868      how large the allocated area was when using a standard malloc. */
869   off = h->handle_offset;
870   wipememory (h, h->actual_handle_size);
871
872   gcry_free ((char*)h - off);
873 }
874
875
876 /* Set the key to be used for the encryption context C to KEY with
877    length KEYLEN.  The length should match the required length. */
878 static gcry_error_t
879 cipher_setkey (gcry_cipher_hd_t c, byte *key, unsigned int keylen)
880 {
881   gcry_err_code_t ret;
882
883   ret = (*c->cipher->setkey) (&c->context.c, key, keylen);
884   if (!ret)
885     {
886       /* Duplicate initial context.  */
887       memcpy ((void *) ((char *) &c->context.c + c->cipher->contextsize),
888               (void *) &c->context.c,
889               c->cipher->contextsize);
890       c->marks.key = 1;
891     }
892   else
893     c->marks.key = 0;
894
895   return gcry_error (ret);
896 }
897
898
899 /* Set the IV to be used for the encryption context C to IV with
900    length IVLEN.  The length should match the required length. */
901 static void
902 cipher_setiv( gcry_cipher_hd_t c, const byte *iv, unsigned ivlen )
903 {
904   memset (c->u_iv.iv, 0, c->cipher->blocksize);
905   if (iv) 
906     {
907       if (ivlen != c->cipher->blocksize)
908         {
909           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
910                     ivlen, (unsigned int)c->cipher->blocksize);
911           fips_signal_error ("IV length does not match blocklength");
912         }
913       if (ivlen > c->cipher->blocksize)
914         ivlen = c->cipher->blocksize;
915       memcpy (c->u_iv.iv, iv, ivlen);
916       c->marks.iv = 1;
917     }
918   else
919       c->marks.iv = 0;
920   c->unused = 0;
921 }
922
923
924 /* Reset the cipher context to the initial context.  This is basically
925    the same as an release followed by a new. */
926 static void
927 cipher_reset (gcry_cipher_hd_t c)
928 {
929   memcpy (&c->context.c,
930           (char *) &c->context.c + c->cipher->contextsize,
931           c->cipher->contextsize);
932   memset (&c->marks, 0, sizeof c->marks);
933   memset (c->u_iv.iv, 0, c->cipher->blocksize);
934   memset (c->lastiv, 0, c->cipher->blocksize);
935   memset (c->ctr, 0, c->cipher->blocksize);
936 }
937
938
939 \f
940 static gcry_err_code_t
941 do_ecb_encrypt (gcry_cipher_hd_t c,
942                 unsigned char *outbuf, unsigned int outbuflen,
943                 const unsigned char *inbuf, unsigned int inbuflen)
944 {
945   unsigned int blocksize = c->cipher->blocksize;
946   unsigned int n, nblocks;
947   
948   if (outbuflen < inbuflen)
949     return GPG_ERR_BUFFER_TOO_SHORT;
950   if ((inbuflen % blocksize))
951     return GPG_ERR_INV_LENGTH;
952
953   nblocks = inbuflen / c->cipher->blocksize;
954
955   for (n=0; n < nblocks; n++ )
956     {
957       c->cipher->encrypt (&c->context.c, outbuf, (byte*)/*arggg*/inbuf);
958       inbuf  += blocksize;
959       outbuf += blocksize;
960     }
961   return 0;
962 }
963
964 static gcry_err_code_t
965 do_ecb_decrypt (gcry_cipher_hd_t c,
966                 unsigned char *outbuf, unsigned int outbuflen,
967                 const unsigned char *inbuf, unsigned int inbuflen)
968 {
969   unsigned int blocksize = c->cipher->blocksize;
970   unsigned int n, nblocks;
971
972   if (outbuflen < inbuflen)
973     return GPG_ERR_BUFFER_TOO_SHORT;
974   if ((inbuflen % blocksize))
975     return GPG_ERR_INV_LENGTH;
976   nblocks = inbuflen / c->cipher->blocksize;
977
978   for (n=0; n < nblocks; n++ ) 
979     {
980       c->cipher->decrypt (&c->context.c, outbuf, (byte*)/*arggg*/inbuf );
981       inbuf  += blocksize;
982       outbuf += blocksize;
983     }
984
985   return 0;
986 }
987
988
989 static gcry_err_code_t
990 do_cbc_encrypt (gcry_cipher_hd_t c,
991                 unsigned char *outbuf, unsigned int outbuflen,
992                 const unsigned char *inbuf, unsigned int inbuflen)
993 {
994   unsigned int n;
995   unsigned char *ivp;
996   int i;
997   size_t blocksize = c->cipher->blocksize;
998   unsigned nblocks = inbuflen / blocksize;
999
1000   if (outbuflen < ((c->flags & GCRY_CIPHER_CBC_MAC)? blocksize : inbuflen))
1001     return GPG_ERR_BUFFER_TOO_SHORT;
1002
1003   if ((inbuflen % c->cipher->blocksize)
1004       && !(inbuflen > c->cipher->blocksize
1005            && (c->flags & GCRY_CIPHER_CBC_CTS)))
1006     return GPG_ERR_INV_LENGTH;
1007
1008   if ((c->flags & GCRY_CIPHER_CBC_CTS) && inbuflen > blocksize) 
1009     {
1010       if ((inbuflen % blocksize) == 0)
1011         nblocks--;
1012     }
1013
1014   if (c->bulk.cbc_enc)
1015     {
1016       c->bulk.cbc_enc (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks,
1017                        (c->flags & GCRY_CIPHER_CBC_MAC)); 
1018       inbuf  += nblocks * blocksize;
1019       if (!(c->flags & GCRY_CIPHER_CBC_MAC))
1020         outbuf += nblocks * blocksize;
1021     }
1022   else
1023     {
1024       for (n=0; n < nblocks; n++ )
1025         {
1026           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1027             outbuf[i] = inbuf[i] ^ *ivp++;
1028           c->cipher->encrypt ( &c->context.c, outbuf, outbuf );
1029           memcpy (c->u_iv.iv, outbuf, blocksize );
1030           inbuf  += blocksize;
1031           if (!(c->flags & GCRY_CIPHER_CBC_MAC))
1032             outbuf += blocksize;
1033         }
1034     }
1035
1036   if ((c->flags & GCRY_CIPHER_CBC_CTS) && inbuflen > blocksize)
1037     {
1038       /* We have to be careful here, since outbuf might be equal to
1039          inbuf.  */
1040       int restbytes;
1041       unsigned char b;
1042
1043       if ((inbuflen % blocksize) == 0)
1044         restbytes = blocksize;
1045       else
1046         restbytes = inbuflen % blocksize;
1047
1048       outbuf -= blocksize;
1049       for (ivp = c->u_iv.iv, i = 0; i < restbytes; i++)
1050         {
1051           b = inbuf[i];
1052           outbuf[blocksize + i] = outbuf[i];
1053           outbuf[i] = b ^ *ivp++;
1054         }
1055       for (; i < blocksize; i++)
1056         outbuf[i] = 0 ^ *ivp++;
1057       
1058       c->cipher->encrypt (&c->context.c, outbuf, outbuf);
1059       memcpy (c->u_iv.iv, outbuf, blocksize);
1060     }
1061
1062   return 0;
1063 }
1064
1065
1066 static gcry_err_code_t
1067 do_cbc_decrypt (gcry_cipher_hd_t c,
1068                 unsigned char *outbuf, unsigned int outbuflen,
1069                 const unsigned char *inbuf, unsigned int inbuflen)
1070 {
1071   unsigned int n;
1072   unsigned char *ivp;
1073   int i;
1074   size_t blocksize = c->cipher->blocksize;
1075   unsigned int nblocks = inbuflen / blocksize;
1076
1077   if (outbuflen < inbuflen)
1078     return GPG_ERR_BUFFER_TOO_SHORT;
1079
1080   if ((inbuflen % c->cipher->blocksize)
1081       && !(inbuflen > c->cipher->blocksize
1082            && (c->flags & GCRY_CIPHER_CBC_CTS)))
1083     return GPG_ERR_INV_LENGTH;
1084
1085   if ((c->flags & GCRY_CIPHER_CBC_CTS) && inbuflen > blocksize)
1086     {
1087       nblocks--;
1088       if ((inbuflen % blocksize) == 0)
1089         nblocks--;
1090       memcpy (c->lastiv, c->u_iv.iv, blocksize);
1091     }
1092
1093   if (c->bulk.cbc_dec)
1094     {
1095       c->bulk.cbc_dec (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1096       inbuf  += nblocks * blocksize;
1097       outbuf += nblocks * blocksize;
1098     }
1099   else
1100     {
1101       for (n=0; n < nblocks; n++ ) 
1102         {
1103           /* Because outbuf and inbuf might be the same, we have to
1104            * save the original ciphertext block.  We use LASTIV for
1105            * this here because it is not used otherwise. */
1106           memcpy (c->lastiv, inbuf, blocksize);
1107           c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
1108           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1109             outbuf[i] ^= *ivp++;
1110           memcpy(c->u_iv.iv, c->lastiv, blocksize );
1111           inbuf  += c->cipher->blocksize;
1112           outbuf += c->cipher->blocksize;
1113         }
1114     }
1115
1116   if ((c->flags & GCRY_CIPHER_CBC_CTS) && inbuflen > blocksize) 
1117     {
1118       int restbytes;
1119       
1120       if ((inbuflen % blocksize) == 0)
1121         restbytes = blocksize;
1122       else
1123         restbytes = inbuflen % blocksize;
1124       
1125       memcpy (c->lastiv, c->u_iv.iv, blocksize );         /* Save Cn-2. */
1126       memcpy (c->u_iv.iv, inbuf + blocksize, restbytes ); /* Save Cn. */
1127
1128       c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
1129       for (ivp=c->u_iv.iv,i=0; i < restbytes; i++ )
1130         outbuf[i] ^= *ivp++;
1131       
1132       memcpy(outbuf + blocksize, outbuf, restbytes);
1133       for(i=restbytes; i < blocksize; i++)
1134         c->u_iv.iv[i] = outbuf[i];
1135       c->cipher->decrypt (&c->context.c, outbuf, c->u_iv.iv);
1136       for(ivp=c->lastiv,i=0; i < blocksize; i++ )
1137         outbuf[i] ^= *ivp++;
1138       /* c->lastiv is now really lastlastiv, does this matter? */
1139     }
1140
1141   return 0;
1142 }
1143
1144
1145 static gcry_err_code_t
1146 do_cfb_encrypt (gcry_cipher_hd_t c,
1147                 unsigned char *outbuf, unsigned int outbuflen,
1148                 const unsigned char *inbuf, unsigned int inbuflen)
1149 {
1150   unsigned char *ivp;
1151   size_t blocksize = c->cipher->blocksize;
1152   size_t blocksize_x_2 = blocksize + blocksize;
1153   
1154   if (outbuflen < inbuflen)
1155     return GPG_ERR_BUFFER_TOO_SHORT;
1156
1157   if ( inbuflen <= c->unused )
1158     {
1159       /* Short enough to be encoded by the remaining XOR mask. */
1160       /* XOR the input with the IV and store input into IV. */
1161       for (ivp=c->u_iv.iv+c->cipher->blocksize - c->unused;
1162            inbuflen;
1163            inbuflen--, c->unused-- )
1164         *outbuf++ = (*ivp++ ^= *inbuf++);
1165       return 0;
1166     }
1167
1168   if ( c->unused )
1169     {
1170       /* XOR the input with the IV and store input into IV */
1171       inbuflen -= c->unused;
1172       for(ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1173         *outbuf++ = (*ivp++ ^= *inbuf++);
1174     }
1175
1176   /* Now we can process complete blocks.  We use a loop as long as we
1177      have at least 2 blocks and use conditions for the rest.  This
1178      also allows to use a bulk encryption function if available.  */
1179   if (inbuflen >= blocksize_x_2 && c->bulk.cfb_enc)
1180     {
1181       unsigned int nblocks = inbuflen / blocksize;
1182       c->bulk.cfb_enc (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1183       outbuf += nblocks * blocksize;
1184       inbuf  += nblocks * blocksize;
1185       inbuflen -= nblocks * blocksize;
1186     }
1187   else
1188     {
1189       while ( inbuflen >= blocksize_x_2 )
1190         {
1191           int i;
1192           /* Encrypt the IV. */
1193           c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1194           /* XOR the input with the IV and store input into IV.  */
1195           for(ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1196             *outbuf++ = (*ivp++ ^= *inbuf++);
1197           inbuflen -= blocksize;
1198         }
1199     }
1200
1201   if ( inbuflen >= blocksize )
1202     {
1203       int i;
1204       /* Save the current IV and then encrypt the IV. */
1205       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1206       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1207       /* XOR the input with the IV and store input into IV */
1208       for(ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1209         *outbuf++ = (*ivp++ ^= *inbuf++);
1210       inbuflen -= blocksize;
1211     }
1212   if ( inbuflen ) 
1213     {
1214       /* Save the current IV and then encrypt the IV. */
1215       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1216       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1217       c->unused = blocksize;
1218       /* Apply the XOR. */
1219       c->unused -= inbuflen;
1220       for(ivp=c->u_iv.iv; inbuflen; inbuflen-- )
1221         *outbuf++ = (*ivp++ ^= *inbuf++);
1222     }
1223   return 0;
1224 }
1225
1226
1227 static gcry_err_code_t
1228 do_cfb_decrypt (gcry_cipher_hd_t c,
1229                 unsigned char *outbuf, unsigned int outbuflen,
1230                 const unsigned char *inbuf, unsigned int inbuflen)
1231 {
1232   unsigned char *ivp;
1233   unsigned long temp;
1234   int i;
1235   size_t blocksize = c->cipher->blocksize;
1236   size_t blocksize_x_2 = blocksize + blocksize;
1237   
1238   if (outbuflen < inbuflen)
1239     return GPG_ERR_BUFFER_TOO_SHORT;
1240
1241   if (inbuflen <= c->unused)
1242     {
1243       /* Short enough to be encoded by the remaining XOR mask. */
1244       /* XOR the input with the IV and store input into IV. */
1245       for (ivp=c->u_iv.iv+blocksize - c->unused;
1246            inbuflen; 
1247            inbuflen--, c->unused--)
1248         {
1249           temp = *inbuf++;
1250           *outbuf++ = *ivp ^ temp;
1251           *ivp++ = temp;
1252         }
1253       return 0;
1254     }
1255   
1256   if (c->unused)
1257     {
1258       /* XOR the input with the IV and store input into IV. */
1259       inbuflen -= c->unused;
1260       for (ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1261         {
1262           temp = *inbuf++;
1263           *outbuf++ = *ivp ^ temp;
1264           *ivp++ = temp;
1265         }
1266     }
1267   
1268   /* Now we can process complete blocks.  We use a loop as long as we
1269      have at least 2 blocks and use conditions for the rest.  This
1270      also allows to use a bulk encryption function if available.  */
1271   if (inbuflen >= blocksize_x_2 && c->bulk.cfb_dec)
1272     {
1273       unsigned int nblocks = inbuflen / blocksize;
1274       c->bulk.cfb_dec (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1275       outbuf += nblocks * blocksize;
1276       inbuf  += nblocks * blocksize;
1277       inbuflen -= nblocks * blocksize;
1278     }
1279   else
1280     {
1281       while (inbuflen >= blocksize_x_2 )
1282         {
1283           /* Encrypt the IV. */
1284           c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1285           /* XOR the input with the IV and store input into IV. */
1286           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1287             {
1288               temp = *inbuf++;
1289               *outbuf++ = *ivp ^ temp;
1290               *ivp++ = temp;
1291             }
1292           inbuflen -= blocksize;
1293         }
1294     }
1295
1296   if (inbuflen >= blocksize )
1297     {
1298       /* Save the current IV and then encrypt the IV. */
1299       memcpy ( c->lastiv, c->u_iv.iv, blocksize);
1300       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1301       /* XOR the input with the IV and store input into IV */
1302       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1303         {
1304           temp = *inbuf++;
1305           *outbuf++ = *ivp ^ temp;
1306           *ivp++ = temp;
1307         }
1308       inbuflen -= blocksize;
1309     }
1310
1311   if (inbuflen)
1312     { 
1313       /* Save the current IV and then encrypt the IV. */
1314       memcpy ( c->lastiv, c->u_iv.iv, blocksize );
1315       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1316       c->unused = blocksize;
1317       /* Apply the XOR. */
1318       c->unused -= inbuflen;
1319       for (ivp=c->u_iv.iv; inbuflen; inbuflen-- )
1320         {
1321           temp = *inbuf++;
1322           *outbuf++ = *ivp ^ temp;
1323           *ivp++ = temp;
1324         }
1325     }
1326   return 0;
1327 }
1328
1329
1330 static gcry_err_code_t
1331 do_ofb_encrypt (gcry_cipher_hd_t c,
1332                 unsigned char *outbuf, unsigned int outbuflen,
1333                 const unsigned char *inbuf, unsigned int inbuflen)
1334 {
1335   unsigned char *ivp;
1336   size_t blocksize = c->cipher->blocksize;
1337
1338   if (outbuflen < inbuflen)
1339     return GPG_ERR_BUFFER_TOO_SHORT;
1340
1341   if ( inbuflen <= c->unused )
1342     {
1343       /* Short enough to be encoded by the remaining XOR mask. */
1344       /* XOR the input with the IV */
1345       for (ivp=c->u_iv.iv+c->cipher->blocksize - c->unused;
1346            inbuflen;
1347            inbuflen--, c->unused-- )
1348         *outbuf++ = (*ivp++ ^ *inbuf++);
1349       return 0;
1350     }
1351
1352   if( c->unused )
1353     {
1354       inbuflen -= c->unused;
1355       for(ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1356         *outbuf++ = (*ivp++ ^ *inbuf++);
1357     }
1358
1359   /* Now we can process complete blocks. */
1360   while ( inbuflen >= blocksize )
1361     {
1362       int i;
1363       /* Encrypt the IV (and save the current one). */
1364       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1365       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1366       
1367       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1368         *outbuf++ = (*ivp++ ^ *inbuf++);
1369       inbuflen -= blocksize;
1370     }
1371   if ( inbuflen )
1372     { /* process the remaining bytes */
1373       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1374       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1375       c->unused = blocksize;
1376       c->unused -= inbuflen;
1377       for(ivp=c->u_iv.iv; inbuflen; inbuflen-- )
1378         *outbuf++ = (*ivp++ ^ *inbuf++);
1379     }
1380   return 0;
1381 }
1382
1383 static gcry_err_code_t
1384 do_ofb_decrypt (gcry_cipher_hd_t c,
1385                 unsigned char *outbuf, unsigned int outbuflen,
1386                 const unsigned char *inbuf, unsigned int inbuflen)
1387 {
1388   unsigned char *ivp;
1389   size_t blocksize = c->cipher->blocksize;
1390   
1391   if (outbuflen < inbuflen)
1392     return GPG_ERR_BUFFER_TOO_SHORT;
1393
1394   if( inbuflen <= c->unused )
1395     {
1396       /* Short enough to be encoded by the remaining XOR mask. */
1397       for (ivp=c->u_iv.iv+blocksize - c->unused; inbuflen; inbuflen--,c->unused--)
1398         *outbuf++ = *ivp++ ^ *inbuf++;
1399       return 0;
1400     }
1401
1402   if ( c->unused )
1403     {
1404       inbuflen -= c->unused;
1405       for (ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1406         *outbuf++ = *ivp++ ^ *inbuf++;
1407     }
1408
1409   /* Now we can process complete blocks. */
1410   while ( inbuflen >= blocksize )
1411     {
1412       int i;
1413       /* Encrypt the IV (and save the current one). */
1414       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1415       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1416       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1417         *outbuf++ = *ivp++ ^ *inbuf++;
1418       inbuflen -= blocksize;
1419     }
1420   if ( inbuflen ) 
1421     { /* Process the remaining bytes. */
1422       /* Encrypt the IV (and save the current one). */
1423       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1424       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1425       c->unused = blocksize;
1426       c->unused -= inbuflen;
1427       for (ivp=c->u_iv.iv; inbuflen; inbuflen-- )
1428         *outbuf++ = *ivp++ ^ *inbuf++;
1429     }
1430   return 0;
1431 }
1432
1433
1434 static gcry_err_code_t
1435 do_ctr_encrypt (gcry_cipher_hd_t c,
1436                 unsigned char *outbuf, unsigned int outbuflen,
1437                 const unsigned char *inbuf, unsigned int inbuflen)
1438 {
1439   unsigned int n;
1440   unsigned char tmp[MAX_BLOCKSIZE];
1441   int i;
1442   unsigned int blocksize = c->cipher->blocksize;
1443
1444   if (outbuflen < inbuflen)
1445     return GPG_ERR_BUFFER_TOO_SHORT;
1446
1447   if ((inbuflen % blocksize))
1448     return GPG_ERR_INV_LENGTH;
1449
1450   for (n=0; n < inbuflen; n++)
1451     {
1452       if ((n % blocksize) == 0)
1453         {
1454           c->cipher->encrypt (&c->context.c, tmp, c->ctr);
1455
1456           for (i = blocksize; i > 0; i--)
1457             {
1458               c->ctr[i-1]++;
1459               if (c->ctr[i-1] != 0)
1460                 break;
1461             }
1462         }
1463
1464       /* XOR input with encrypted counter and store in output.  */
1465       outbuf[n] = inbuf[n] ^ tmp[n % blocksize];
1466     }
1467
1468   wipememory (tmp, sizeof tmp);
1469   return 0;
1470 }
1471
1472 static gcry_err_code_t
1473 do_ctr_decrypt (gcry_cipher_hd_t c,
1474                 unsigned char *outbuf, unsigned int outbuflen,
1475                 const unsigned char *inbuf, unsigned int inbuflen)
1476 {
1477   return do_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1478 }
1479
1480
1481 /* Perform the AES-Wrap algorithm as specified by RFC3394.  We
1482    implement this as a mode usable with any cipher algorithm of
1483    blocksize 128.  */
1484 static gcry_err_code_t
1485 do_aeswrap_encrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
1486                     const byte *inbuf, unsigned int inbuflen )
1487 {
1488   int j, x;
1489   unsigned int n, i;
1490   unsigned char *r, *a, *b;
1491   unsigned char t[8];
1492
1493 #if MAX_BLOCKSIZE < 8
1494 #error Invalid block size
1495 #endif
1496   /* We require a cipher with a 128 bit block length.  */
1497   if (c->cipher->blocksize != 16)
1498     return GPG_ERR_INV_LENGTH;  
1499   
1500   /* The output buffer must be able to hold the input data plus one
1501      additional block.  */
1502   if (outbuflen < inbuflen + 8)
1503     return GPG_ERR_BUFFER_TOO_SHORT;
1504   /* Input data must be multiple of 64 bits.  */
1505   if (inbuflen % 8)
1506     return GPG_ERR_INV_ARG;   
1507
1508   n = inbuflen / 8;
1509
1510   /* We need at least two 64 bit blocks.  */
1511   if (n < 2)
1512     return GPG_ERR_INV_ARG;
1513
1514   r = outbuf; 
1515   a = outbuf;  /* We store A directly in OUTBUF.  */
1516   b = c->ctr;  /* B is also used to concatenate stuff.  */
1517
1518   /* If an IV has been set we use that IV as the Alternative Initial
1519      Value; if it has not been set we use the standard value.  */
1520   if (c->marks.iv)
1521     memcpy (a, c->u_iv.iv, 8);
1522   else
1523     memset (a, 0xa6, 8);
1524
1525   /* Copy the inbuf to the outbuf. */
1526   memmove (r+8, inbuf, inbuflen);
1527
1528   memset (t, 0, sizeof t); /* t := 0.  */
1529
1530   for (j = 0; j <= 5; j++)
1531     {
1532       for (i = 1; i <= n; i++)
1533         {
1534           /* B := AES_k( A | R[i] ) */
1535           memcpy (b, a, 8);
1536           memcpy (b+8, r+i*8, 8);
1537           c->cipher->encrypt (&c->context.c, b, b);
1538           /* t := t + 1  */
1539           for (x = 7; x >= 0; x--)
1540             {
1541               t[x]++;
1542               if (t[x])
1543                 break;
1544             }
1545           /* A := MSB_64(B) ^ t */
1546           for (x=0; x < 8; x++)
1547             a[x] = b[x] ^ t[x];
1548           /* R[i] := LSB_64(B) */
1549           memcpy (r+i*8, b+8, 8);
1550         }
1551    }
1552   
1553   return 0;
1554 }
1555
1556 /* Perform the AES-Unwrap algorithm as specified by RFC3394.  We
1557    implement this as a mode usable with any cipher algorithm of
1558    blocksize 128.  */
1559 static gcry_err_code_t
1560 do_aeswrap_decrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
1561                     const byte *inbuf, unsigned int inbuflen)
1562 {
1563   int j, x;
1564   unsigned int n, i;
1565   unsigned char *r, *a, *b;
1566   unsigned char t[8];
1567
1568 #if MAX_BLOCKSIZE < 8
1569 #error Invalid block size
1570 #endif
1571   /* We require a cipher with a 128 bit block length.  */
1572   if (c->cipher->blocksize != 16)
1573     return GPG_ERR_INV_LENGTH;  
1574   
1575   /* The output buffer must be able to hold the input data minus one
1576      additional block.  Fixme: The caller has more restrictive checks
1577      - we may want to fix them for this mode.  */
1578   if (outbuflen + 8  < inbuflen)
1579     return GPG_ERR_BUFFER_TOO_SHORT;
1580   /* Input data must be multiple of 64 bits.  */
1581   if (inbuflen % 8)
1582     return GPG_ERR_INV_ARG;   
1583
1584   n = inbuflen / 8;
1585
1586   /* We need at least three 64 bit blocks.  */
1587   if (n < 3)
1588     return GPG_ERR_INV_ARG;
1589
1590   r = outbuf; 
1591   a = c->lastiv;  /* We use c->LASTIV as buffer for A.  */
1592   b = c->ctr;     /* B is also used to concatenate stuff.  */
1593
1594   /* Copy the inbuf to the outbuf and save A. */
1595   memcpy (a, inbuf, 8);
1596   memmove (r, inbuf+8, inbuflen-8);
1597   n--; /* Reduce to actual number of data blocks.  */
1598
1599   /* t := 6 * n  */
1600   i = n * 6;  /* The range is valid because: n = inbuflen / 8 - 1.  */
1601   for (x=0; x < 8 && x < sizeof (i); x++)
1602     t[7-x] = i >> (8*x);
1603   for (; x < 8; x++)
1604     t[7-x] = 0;
1605
1606   for (j = 5; j >= 0; j--)
1607     {
1608       for (i = n; i >= 1; i--)
1609         {
1610           /* B := AES_k^1( (A ^ t)| R[i] ) */
1611           for (x = 0; x < 8; x++)
1612             b[x] = a[x] ^ t[x];
1613           memcpy (b+8, r+(i-1)*8, 8);
1614           c->cipher->decrypt (&c->context.c, b, b);
1615           /* t := t - 1  */
1616           for (x = 7; x >= 0; x--)
1617             {
1618               t[x]--;
1619               if (t[x] != 0xff)
1620                 break;
1621             }
1622           /* A := MSB_64(B) */
1623           memcpy (a, b, 8);
1624           /* R[i] := LSB_64(B) */
1625           memcpy (r+(i-1)*8, b+8, 8);
1626         }
1627    }
1628
1629   /* If an IV has been set we compare against this Alternative Initial
1630      Value; if it has not been set we compare against the standard IV.  */
1631   if (c->marks.iv)
1632     j = memcmp (a, c->u_iv.iv, 8);
1633   else
1634     {
1635       for (j=0, x=0; x < 8; x++)
1636         if (a[x] != 0xa6)
1637           {
1638             j=1;
1639             break;
1640           }
1641     }
1642   return j? GPG_ERR_CHECKSUM : 0;
1643 }
1644
1645
1646 /****************
1647  * Encrypt INBUF to OUTBUF with the mode selected at open.
1648  * inbuf and outbuf may overlap or be the same.
1649  * Depending on the mode some constraints apply to INBUFLEN.
1650  */
1651 static gcry_err_code_t
1652 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
1653                 const byte *inbuf, unsigned int inbuflen)
1654 {
1655   gcry_err_code_t rc;
1656
1657   switch (c->mode)
1658     {
1659     case GCRY_CIPHER_MODE_ECB:
1660       rc = do_ecb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1661       break;
1662
1663     case GCRY_CIPHER_MODE_CBC:
1664       rc = do_cbc_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1665       break;
1666       
1667     case GCRY_CIPHER_MODE_CFB:
1668       rc = do_cfb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1669       break;
1670
1671     case GCRY_CIPHER_MODE_OFB:
1672       rc = do_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1673       break;
1674
1675     case GCRY_CIPHER_MODE_CTR:
1676       rc = do_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1677       break;
1678
1679     case GCRY_CIPHER_MODE_AESWRAP:
1680       rc = do_aeswrap_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1681       break;
1682
1683     case GCRY_CIPHER_MODE_STREAM:
1684       c->cipher->stencrypt (&c->context.c,
1685                             outbuf, (byte*)/*arggg*/inbuf, inbuflen);
1686       rc = 0;
1687       break;
1688
1689     case GCRY_CIPHER_MODE_NONE:
1690       if (fips_mode () || !_gcry_get_debug_flag (0))
1691         {
1692           fips_signal_error ("cipher mode NONE used");
1693           rc = GPG_ERR_INV_CIPHER_MODE;
1694         }
1695       else
1696         {
1697           if (inbuf != outbuf)
1698             memmove (outbuf, inbuf, inbuflen);
1699           rc = 0;
1700         }
1701       break;
1702       
1703     default:
1704       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
1705       rc = GPG_ERR_INV_CIPHER_MODE;
1706       break;
1707     }
1708
1709   return rc;
1710 }
1711
1712
1713 /****************
1714  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
1715  * been requested.
1716  */
1717 gcry_error_t
1718 gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1719                      const void *in, size_t inlen)
1720 {
1721   gcry_err_code_t err;
1722
1723   if (!in)  /* Caller requested in-place encryption.  */
1724     err = cipher_encrypt (h, out, outsize, out, outsize);
1725   else
1726     err = cipher_encrypt (h, out, outsize, in, inlen);
1727
1728   /* Failsafe: Make sure that the plaintext will never make it into
1729      OUT if the encryption returned an error.  */
1730   if (err && out)
1731     memset (out, 0x42, outsize); 
1732
1733   return gcry_error (err);
1734 }
1735
1736
1737
1738 /****************
1739  * Decrypt INBUF to OUTBUF with the mode selected at open.
1740  * inbuf and outbuf may overlap or be the same.
1741  * Depending on the mode some some contraints apply to INBUFLEN.
1742  */
1743 static gcry_err_code_t
1744 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, unsigned int outbuflen,
1745                 const byte *inbuf, unsigned int inbuflen)
1746 {
1747   gcry_err_code_t rc;
1748
1749   switch (c->mode)
1750     {
1751     case GCRY_CIPHER_MODE_ECB:
1752       rc = do_ecb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1753       break;
1754
1755     case GCRY_CIPHER_MODE_CBC:
1756       rc = do_cbc_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1757       break;
1758
1759     case GCRY_CIPHER_MODE_CFB:
1760       rc = do_cfb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1761       break;
1762
1763     case GCRY_CIPHER_MODE_OFB:
1764       rc = do_ofb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1765       break;
1766
1767     case GCRY_CIPHER_MODE_CTR:
1768       rc = do_ctr_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1769       break;
1770
1771     case GCRY_CIPHER_MODE_AESWRAP:
1772       rc = do_aeswrap_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1773       break;
1774
1775     case GCRY_CIPHER_MODE_STREAM:
1776       c->cipher->stdecrypt (&c->context.c,
1777                             outbuf, (byte*)/*arggg*/inbuf, inbuflen);
1778       rc = 0;
1779       break;
1780
1781     case GCRY_CIPHER_MODE_NONE:
1782       if (fips_mode () || !_gcry_get_debug_flag (0))
1783         {
1784           fips_signal_error ("cipher mode NONE used");
1785           rc = GPG_ERR_INV_CIPHER_MODE;
1786         }
1787       else
1788         {
1789           if (inbuf != outbuf)
1790             memmove (outbuf, inbuf, inbuflen);
1791           rc = 0;
1792         }
1793       break;
1794       
1795     default:
1796       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1797       rc = GPG_ERR_INV_CIPHER_MODE;
1798       break;
1799     }
1800
1801   return rc;
1802 }
1803
1804
1805 gcry_error_t
1806 gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1807                      const void *in, size_t inlen)
1808 {
1809   gcry_err_code_t err;
1810
1811   if (!in) /* Caller requested in-place encryption. */
1812     err = cipher_decrypt (h, out, outsize, out, outsize);
1813   else
1814     err = cipher_decrypt (h, out, outsize, in, inlen);
1815
1816   return gcry_error (err);
1817 }
1818
1819
1820
1821 /****************
1822  * Used for PGP's somewhat strange CFB mode. Only works if
1823  * the corresponding flag is set.
1824  */
1825 static void
1826 cipher_sync (gcry_cipher_hd_t c)
1827 {
1828   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1829     {
1830       memmove (c->u_iv.iv + c->unused,
1831                c->u_iv.iv, c->cipher->blocksize - c->unused);
1832       memcpy (c->u_iv.iv,
1833               c->lastiv + c->cipher->blocksize - c->unused, c->unused);
1834       c->unused = 0;
1835     }
1836 }
1837
1838
1839 gcry_error_t
1840 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
1841 {
1842   return cipher_setkey (hd, (void*)key, keylen);
1843 }
1844
1845
1846 gcry_error_t
1847 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
1848 {
1849   cipher_setiv (hd, iv, ivlen);
1850   return 0;
1851 }
1852
1853 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1854    block size length, or (NULL,0) to set the CTR to the all-zero
1855    block. */
1856 gpg_error_t
1857 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1858 {
1859   if (ctr && ctrlen == hd->cipher->blocksize)
1860     memcpy (hd->ctr, ctr, hd->cipher->blocksize);
1861   else if (!ctr || !ctrlen)
1862     memset (hd->ctr, 0, hd->cipher->blocksize);
1863   else
1864     return gpg_error (GPG_ERR_INV_ARG);
1865   return 0;
1866 }
1867
1868
1869 gcry_error_t
1870 gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1871 {
1872   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1873
1874   switch (cmd)
1875     {
1876     case GCRYCTL_SET_KEY:  /* Deprecated; use gcry_cipher_setkey.  */
1877       rc = cipher_setkey( h, buffer, buflen );
1878       break;
1879
1880     case GCRYCTL_SET_IV:   /* Deprecated; use gcry_cipher_setiv.  */
1881       cipher_setiv( h, buffer, buflen );
1882       break;
1883
1884     case GCRYCTL_RESET:
1885       cipher_reset (h);
1886       break;
1887
1888     case GCRYCTL_CFB_SYNC:
1889       cipher_sync( h );
1890       break;
1891
1892     case GCRYCTL_SET_CBC_CTS:
1893       if (buflen)
1894         if (h->flags & GCRY_CIPHER_CBC_MAC)
1895           rc = GPG_ERR_INV_FLAG;
1896         else
1897           h->flags |= GCRY_CIPHER_CBC_CTS;
1898       else
1899         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1900       break;
1901
1902     case GCRYCTL_SET_CBC_MAC:
1903       if (buflen)
1904         if (h->flags & GCRY_CIPHER_CBC_CTS)
1905           rc = GPG_ERR_INV_FLAG;
1906         else
1907           h->flags |= GCRY_CIPHER_CBC_MAC;
1908       else
1909         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1910       break;
1911
1912     case GCRYCTL_DISABLE_ALGO:
1913       /* This command expects NULL for H and BUFFER to point to an
1914          integer with the algo number.  */
1915       if( h || !buffer || buflen != sizeof(int) )
1916         return gcry_error (GPG_ERR_CIPHER_ALGO);
1917       disable_cipher_algo( *(int*)buffer );
1918       break;
1919
1920     case GCRYCTL_SET_CTR: /* Deprecated; use gcry_cipher_setctr.  */
1921       if (buffer && buflen == h->cipher->blocksize)
1922         memcpy (h->ctr, buffer, h->cipher->blocksize);
1923       else if (buffer == NULL || buflen == 0)
1924         memset (h->ctr, 0, h->cipher->blocksize);
1925       else
1926         rc = GPG_ERR_INV_ARG;
1927       break;
1928
1929     case 61:  /* Disable weak key detection (private).  */
1930       if (h->extraspec->set_extra_info)
1931         rc = h->extraspec->set_extra_info 
1932           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1933       else
1934         rc = GPG_ERR_NOT_SUPPORTED;
1935       break;
1936
1937     case 62: /* Return current input vector (private).  */
1938       /* This is the input block as used in CFB and OFB mode which has
1939          initially been set as IV.  The returned format is: 
1940            1 byte  Actual length of the block in bytes.
1941            n byte  The block.
1942          If the provided buffer is too short, an error is returned. */
1943       if (buflen < (1 + h->cipher->blocksize))
1944         rc = GPG_ERR_TOO_SHORT;
1945       else
1946         {
1947           unsigned char *ivp;
1948           unsigned char *dst = buffer;
1949           int n = h->unused;
1950           
1951           if (!n)
1952             n = h->cipher->blocksize;
1953           gcry_assert (n <= h->cipher->blocksize);
1954           *dst++ = n;
1955           ivp = h->u_iv.iv + h->cipher->blocksize - n;
1956           while (n--)
1957             *dst++ = *ivp++;
1958         }
1959       break;
1960
1961     default:
1962       rc = GPG_ERR_INV_OP;
1963     }
1964
1965   return gcry_error (rc);
1966 }
1967
1968
1969 /* Return information about the cipher handle H.  CMD is the kind of
1970    information requested.  BUFFER and NBYTES are reserved for now.
1971
1972    There are no values for CMD yet defined.  
1973
1974    The function always returns GPG_ERR_INV_OP.
1975    
1976  */
1977 gcry_error_t
1978 gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1979 {
1980   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1981
1982   (void)h;
1983   (void)buffer;
1984   (void)nbytes;
1985
1986   switch (cmd)
1987     {
1988     default:
1989       err = GPG_ERR_INV_OP;
1990     }
1991
1992   return gcry_error (err);
1993 }
1994
1995 /* Return information about the given cipher algorithm ALGO.
1996
1997    WHAT select the kind of information returned:
1998
1999     GCRYCTL_GET_KEYLEN:
2000         Return the length of the key.  If the algorithm ALGO
2001         supports multiple key lengths, the maximum supported key length
2002         is returned.  The key length is returned as number of octets.
2003         BUFFER and NBYTES must be zero.
2004
2005     GCRYCTL_GET_BLKLEN:
2006         Return the blocklength of the algorithm ALGO counted in octets.
2007         BUFFER and NBYTES must be zero.
2008
2009     GCRYCTL_TEST_ALGO:
2010         Returns 0 if the specified algorithm ALGO is available for use.
2011         BUFFER and NBYTES must be zero.
2012   
2013    Note: Because this function is in most cases used to return an
2014    integer value, we can make it easier for the caller to just look at
2015    the return value.  The caller will in all cases consult the value
2016    and thereby detecting whether a error occurred or not (i.e. while
2017    checking the block size)
2018  */
2019 gcry_error_t
2020 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
2021 {
2022   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2023   unsigned int ui;
2024
2025   switch (what)
2026     {
2027     case GCRYCTL_GET_KEYLEN:
2028       if (buffer || (! nbytes))
2029         err = GPG_ERR_CIPHER_ALGO;
2030       else
2031         {
2032           ui = cipher_get_keylen (algo);
2033           if ((ui > 0) && (ui <= 512))
2034             *nbytes = (size_t) ui / 8;
2035           else
2036             /* The only reason is an invalid algo or a strange
2037                blocksize.  */
2038             err = GPG_ERR_CIPHER_ALGO;
2039         }
2040       break;
2041
2042     case GCRYCTL_GET_BLKLEN:
2043       if (buffer || (! nbytes))
2044         err = GPG_ERR_CIPHER_ALGO;
2045       else
2046         {
2047           ui = cipher_get_blocksize (algo);
2048           if ((ui > 0) && (ui < 10000))
2049             *nbytes = ui;
2050           else
2051             /* The only reason is an invalid algo or a strange
2052                blocksize.  */
2053             err = GPG_ERR_CIPHER_ALGO;
2054         }
2055       break;
2056
2057     case GCRYCTL_TEST_ALGO:
2058       if (buffer || nbytes)
2059         err = GPG_ERR_INV_ARG;
2060       else
2061         err = check_cipher_algo (algo);
2062       break;
2063
2064       default:
2065         err = GPG_ERR_INV_OP;
2066     }
2067
2068   return gcry_error (err);
2069 }
2070
2071
2072 /* This function returns length of the key for algorithm ALGO.  If the
2073    algorithm supports multiple key lengths, the maximum supported key
2074    length is returned.  On error 0 is returned.  The key length is
2075    returned as number of octets.
2076
2077    This is a convenience functions which should be preferred over
2078    gcry_cipher_algo_info because it allows for proper type
2079    checking.  */
2080 size_t
2081 gcry_cipher_get_algo_keylen (int algo) 
2082 {
2083   size_t n;
2084
2085   if (gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
2086     n = 0;
2087   return n;
2088 }
2089
2090 /* This functions returns the blocklength of the algorithm ALGO
2091    counted in octets.  On error 0 is returned.
2092
2093    This is a convenience functions which should be preferred over
2094    gcry_cipher_algo_info because it allows for proper type
2095    checking.  */
2096 size_t
2097 gcry_cipher_get_algo_blklen (int algo) 
2098 {
2099   size_t n;
2100
2101   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
2102     n = 0;
2103   return n;
2104 }
2105
2106 /* Explicitly initialize this module.  */
2107 gcry_err_code_t
2108 _gcry_cipher_init (void)
2109 {
2110   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2111
2112   REGISTER_DEFAULT_CIPHERS;
2113
2114   return err;
2115 }
2116
2117 /* Get a list consisting of the IDs of the loaded cipher modules.  If
2118    LIST is zero, write the number of loaded cipher modules to
2119    LIST_LENGTH and return.  If LIST is non-zero, the first
2120    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
2121    according size.  In case there are less cipher modules than
2122    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
2123 gcry_error_t
2124 gcry_cipher_list (int *list, int *list_length)
2125 {
2126   gcry_err_code_t err = GPG_ERR_NO_ERROR;
2127
2128   ath_mutex_lock (&ciphers_registered_lock);
2129   err = _gcry_module_list (ciphers_registered, list, list_length);
2130   ath_mutex_unlock (&ciphers_registered_lock);
2131
2132   return err;
2133 }
2134
2135
2136 /* Run the selftests for cipher algorithm ALGO with optional reporting
2137    function REPORT.  */
2138 gpg_error_t
2139 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
2140 {
2141   gcry_module_t module = NULL;
2142   cipher_extra_spec_t *extraspec = NULL;
2143   gcry_err_code_t ec = 0;
2144
2145   REGISTER_DEFAULT_CIPHERS;
2146
2147   ath_mutex_lock (&ciphers_registered_lock);
2148   module = _gcry_module_lookup_id (ciphers_registered, algo);
2149   if (module && !(module->flags & FLAG_MODULE_DISABLED))
2150     extraspec = module->extraspec;
2151   ath_mutex_unlock (&ciphers_registered_lock);
2152   if (extraspec && extraspec->selftest)
2153     ec = extraspec->selftest (algo, extended, report);
2154   else
2155     {
2156       ec = GPG_ERR_CIPHER_ALGO;
2157       if (report)
2158         report ("cipher", algo, "module", 
2159                 module && !(module->flags & FLAG_MODULE_DISABLED)?
2160                 "no selftest available" :
2161                 module? "algorithm disabled" : "algorithm not found");
2162     }
2163
2164   if (module)
2165     {
2166       ath_mutex_lock (&ciphers_registered_lock);
2167       _gcry_module_release (module);
2168       ath_mutex_unlock (&ciphers_registered_lock);
2169     }
2170   return gpg_error (ec);
2171 }