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