Better AES performance.
[libgcrypt.git] / cipher / cipher.c
1 /* cipher.c  -  cipher dispatcher
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *               2005, 2007 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 /* This is the list of the default ciphers, which are included in
42    libgcrypt.  */
43 static struct cipher_table_entry
44 {
45   gcry_cipher_spec_t *cipher;
46   unsigned int algorithm;
47 } cipher_table[] =
48   {
49 #if USE_BLOWFISH
50     { &_gcry_cipher_spec_blowfish,   GCRY_CIPHER_BLOWFISH },
51 #endif
52 #if USE_DES
53     { &_gcry_cipher_spec_des,        GCRY_CIPHER_DES },
54     { &_gcry_cipher_spec_tripledes,  GCRY_CIPHER_3DES },
55 #endif
56 #if USE_ARCFOUR
57     { &_gcry_cipher_spec_arcfour,    GCRY_CIPHER_ARCFOUR },
58 #endif
59 #if USE_CAST5
60     { &_gcry_cipher_spec_cast5,      GCRY_CIPHER_CAST5 },
61 #endif
62 #if USE_AES
63     { &_gcry_cipher_spec_aes,        GCRY_CIPHER_AES},
64     { &_gcry_cipher_spec_aes192,     GCRY_CIPHER_AES192},
65     { &_gcry_cipher_spec_aes256,     GCRY_CIPHER_AES256},
66 #endif
67 #if USE_TWOFISH
68     { &_gcry_cipher_spec_twofish,    GCRY_CIPHER_TWOFISH },
69     { &_gcry_cipher_spec_twofish128, GCRY_CIPHER_TWOFISH128 },
70 #endif
71 #if USE_SERPENT
72     { &_gcry_cipher_spec_serpent128, GCRY_CIPHER_SERPENT128 },
73     { &_gcry_cipher_spec_serpent192, GCRY_CIPHER_SERPENT192 },
74     { &_gcry_cipher_spec_serpent256, GCRY_CIPHER_SERPENT256 },
75 #endif
76 #if USE_RFC2268
77     { &_gcry_cipher_spec_rfc2268_40, GCRY_CIPHER_RFC2268_40 },
78 #endif
79 #if USE_SEED
80     { &_gcry_cipher_spec_seed,       GCRY_CIPHER_SEED },
81 #endif
82 #if USE_CAMELLIA
83     { &_gcry_cipher_spec_camellia128, GCRY_CIPHER_CAMELLIA128 },
84     { &_gcry_cipher_spec_camellia192, GCRY_CIPHER_CAMELLIA192 },
85     { &_gcry_cipher_spec_camellia256, GCRY_CIPHER_CAMELLIA256 },
86 #endif
87     { NULL                    }
88   };
89
90 /* List of registered ciphers.  */
91 static gcry_module_t ciphers_registered;
92
93 /* This is the lock protecting CIPHERS_REGISTERED.  */
94 static ath_mutex_t ciphers_registered_lock = ATH_MUTEX_INITIALIZER;
95
96 /* Flag to check wether the default ciphers have already been
97    registered.  */
98 static int default_ciphers_registered;
99
100 /* Convenient macro for registering the default ciphers.  */
101 #define REGISTER_DEFAULT_CIPHERS                   \
102   do                                               \
103     {                                              \
104       ath_mutex_lock (&ciphers_registered_lock);   \
105       if (! default_ciphers_registered)            \
106         {                                          \
107           gcry_cipher_register_default ();         \
108           default_ciphers_registered = 1;          \
109         }                                          \
110       ath_mutex_unlock (&ciphers_registered_lock); \
111     }                                              \
112   while (0)
113
114
115 /* A VIA processor with the Padlock engine requires an alignment of
116    most data on a 16 byte boundary.  Because we trick out the compiler
117    while allocating the context, the align attribute as used in
118    rijndael.c does not work on its own.  Thus we need to make sure
119    that the entire context structure is a aligned on that boundary.
120    We achieve this by defining a new type and use that instead of our
121    usual alignment type.  */
122 typedef union 
123 {
124   PROPERLY_ALIGNED_TYPE foo;
125 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
126   char bar[16] __attribute__ ((aligned (16)));
127 #endif  
128   char c[1];
129 } cipher_context_alignment_t;
130
131
132 /* The handle structure.  */
133 struct gcry_cipher_handle
134 {
135   int magic;
136   size_t actual_handle_size;     /* Allocated size of this handle. */
137   size_t handle_offset;          /* Offset to the malloced block.  */
138   gcry_cipher_spec_t *cipher;
139   gcry_module_t module;
140
141   /* The algorithm id.  This is a hack required because the module
142      interface does not easily allow to retrieve this value. */
143   int algo;  
144
145   /* A structure with function pointers for bulk operations.  Due to
146      limitations of the module system (we don't want to change the
147      API) we need to keep these function pointers here.  The cipher
148      open function intializes them and the actual encryption routines
149      use them if they are not NULL.  */
150   struct {
151     void (*cfb_enc)(void *context, unsigned char *iv, 
152                     void *outbuf_arg, const void *inbuf_arg,
153                     unsigned int nblocks);
154     void (*cfb_dec)(void *context, unsigned char *iv, 
155                     void *outbuf_arg, const void *inbuf_arg,
156                     unsigned int nblocks);
157     void (*cbc_enc)(void *context, unsigned char *iv, 
158                     void *outbuf_arg, const void *inbuf_arg,
159                     unsigned int nblocks, int cbc_mac);
160     void (*cbc_dec)(void *context, unsigned char *iv, 
161                     void *outbuf_arg, const void *inbuf_arg,
162                     unsigned int nblocks);
163   } bulk;
164
165
166   int mode;
167   unsigned int flags;
168
169   /* The initialization vector.  To help code optimization we make
170      sure that it is aligned on an unsigned long and u32 boundary.  */
171   union {
172     unsigned long dummy_iv;         
173     u32 dummy_u32_iv;
174     unsigned char iv[MAX_BLOCKSIZE];    
175   } u_iv;
176
177   unsigned char lastiv[MAX_BLOCKSIZE];
178   int unused;  /* Number of unused bytes in the IV. */
179
180   unsigned char ctr[MAX_BLOCKSIZE];     /* For Counter (CTR) mode. */
181
182
183   /* What follows are two contexts of the cipher in use.  The first
184      one needs to be aligned well enough for the cipher operation
185      whereas the second one is a copy created by cipher_setkey and
186      used by cipher_reset.  That second copy has no need for proper
187      aligment because it is only accessed by memcpy.  */
188   cipher_context_alignment_t context;
189 };
190
191
192 \f
193 /* These dummy functions are used in case a cipher implementation
194    refuses to provide it's own functions.  */
195
196 static gcry_err_code_t
197 dummy_setkey (void *c, const unsigned char *key, unsigned int keylen)
198 {
199   (void)c; 
200   (void)key;
201   (void)keylen;
202   return GPG_ERR_NO_ERROR;
203 }
204
205 static void
206 dummy_encrypt_block (void *c,
207                      unsigned char *outbuf, const unsigned char *inbuf)
208 {
209   (void)c;
210   (void)outbuf;
211   (void)inbuf;
212   BUG();
213 }
214
215 static void
216 dummy_decrypt_block (void *c,
217                      unsigned char *outbuf, const unsigned char *inbuf)
218 {
219   (void)c;
220   (void)outbuf;
221   (void)inbuf;
222   BUG();
223 }
224
225 static void
226 dummy_encrypt_stream (void *c,
227                       unsigned char *outbuf, const unsigned char *inbuf,
228                       unsigned int n)
229 {
230   (void)c;
231   (void)outbuf;
232   (void)inbuf;
233   (void)n;
234   BUG();
235 }
236
237 static void
238 dummy_decrypt_stream (void *c,
239                       unsigned char *outbuf, const unsigned char *inbuf,
240                       unsigned int n)
241 {
242   (void)c;
243   (void)outbuf;
244   (void)inbuf;
245   (void)n;
246   BUG();
247 }
248
249 \f
250 /* Internal function.  Register all the ciphers included in
251    CIPHER_TABLE.  Note, that this function gets only used by the macro
252    REGISTER_DEFAULT_CIPHERS which protects it using a mutex. */
253 static void
254 gcry_cipher_register_default (void)
255 {
256   gcry_err_code_t err = GPG_ERR_NO_ERROR;
257   int i;
258   
259   for (i = 0; !err && cipher_table[i].cipher; i++)
260     {
261       if (! cipher_table[i].cipher->setkey)
262         cipher_table[i].cipher->setkey = dummy_setkey;
263       if (! cipher_table[i].cipher->encrypt)
264         cipher_table[i].cipher->encrypt = dummy_encrypt_block;
265       if (! cipher_table[i].cipher->decrypt)
266         cipher_table[i].cipher->decrypt = dummy_decrypt_block;
267       if (! cipher_table[i].cipher->stencrypt)
268         cipher_table[i].cipher->stencrypt = dummy_encrypt_stream;
269       if (! cipher_table[i].cipher->stdecrypt)
270         cipher_table[i].cipher->stdecrypt = dummy_decrypt_stream;
271
272       err = _gcry_module_add (&ciphers_registered,
273                               cipher_table[i].algorithm,
274                               (void *) cipher_table[i].cipher,
275                               NULL);
276     }
277
278   if (err)
279     BUG ();
280 }
281
282 /* Internal callback function.  Used via _gcry_module_lookup.  */
283 static int
284 gcry_cipher_lookup_func_name (void *spec, void *data)
285 {
286   gcry_cipher_spec_t *cipher = (gcry_cipher_spec_t *) spec;
287   char *name = (char *) data;
288   const char **aliases = cipher->aliases;
289   int i, ret = ! stricmp (name, cipher->name);
290
291   if (aliases)
292     for (i = 0; aliases[i] && (! ret); i++)
293       ret = ! stricmp (name, aliases[i]);
294
295   return ret;
296 }
297
298 /* Internal callback function.  Used via _gcry_module_lookup.  */
299 static int
300 gcry_cipher_lookup_func_oid (void *spec, void *data)
301 {
302   gcry_cipher_spec_t *cipher = (gcry_cipher_spec_t *) spec;
303   char *oid = (char *) data;
304   gcry_cipher_oid_spec_t *oid_specs = cipher->oids;
305   int ret = 0, i;
306
307   if (oid_specs)
308     for (i = 0; oid_specs[i].oid && (! ret); i++)
309       if (! stricmp (oid, oid_specs[i].oid))
310         ret = 1;
311
312   return ret;
313 }
314
315 /* Internal function.  Lookup a cipher entry by it's name.  */
316 static gcry_module_t
317 gcry_cipher_lookup_name (const char *name)
318 {
319   gcry_module_t cipher;
320
321   cipher = _gcry_module_lookup (ciphers_registered, (void *) name,
322                                 gcry_cipher_lookup_func_name);
323
324   return cipher;
325 }
326
327 /* Internal function.  Lookup a cipher entry by it's oid.  */
328 static gcry_module_t
329 gcry_cipher_lookup_oid (const char *oid)
330 {
331   gcry_module_t cipher;
332
333   cipher = _gcry_module_lookup (ciphers_registered, (void *) oid,
334                                 gcry_cipher_lookup_func_oid);
335
336   return cipher;
337 }
338
339 /* Register a new cipher module whose specification can be found in
340    CIPHER.  On success, a new algorithm ID is stored in ALGORITHM_ID
341    and a pointer representhing this module is stored in MODULE.  */
342 gcry_error_t
343 gcry_cipher_register (gcry_cipher_spec_t *cipher,
344                       int *algorithm_id,
345                       gcry_module_t *module)
346 {
347   gcry_err_code_t err = 0;
348   gcry_module_t mod;
349
350   ath_mutex_lock (&ciphers_registered_lock);
351   err = _gcry_module_add (&ciphers_registered, 0,
352                           (void *) cipher, &mod);
353   ath_mutex_unlock (&ciphers_registered_lock);
354
355   if (! err)
356     {
357       *module = mod;
358       *algorithm_id = mod->mod_id;
359     }
360
361   return gcry_error (err);
362 }
363
364 /* Unregister the cipher identified by MODULE, which must have been
365    registered with gcry_cipher_register.  */
366 void
367 gcry_cipher_unregister (gcry_module_t module)
368 {
369   ath_mutex_lock (&ciphers_registered_lock);
370   _gcry_module_release (module);
371   ath_mutex_unlock (&ciphers_registered_lock);
372 }
373
374 /* Locate the OID in the oid table and return the index or -1 when not
375    found.  An opitonal "oid." or "OID." prefix in OID is ignored, the
376    OID is expected to be in standard IETF dotted notation.  The
377    internal algorithm number is returned in ALGORITHM unless it
378    ispassed as NULL.  A pointer to the specification of the module
379    implementing this algorithm is return in OID_SPEC unless passed as
380    NULL.*/
381 static int 
382 search_oid (const char *oid, int *algorithm, gcry_cipher_oid_spec_t *oid_spec)
383 {
384   gcry_module_t module;
385   int ret = 0;
386
387   if (oid && ((! strncmp (oid, "oid.", 4))
388               || (! strncmp (oid, "OID.", 4))))
389     oid += 4;
390
391   module = gcry_cipher_lookup_oid (oid);
392   if (module)
393     {
394       gcry_cipher_spec_t *cipher = module->spec;
395       int i;
396
397       for (i = 0; cipher->oids[i].oid && !ret; i++)
398         if (! stricmp (oid, cipher->oids[i].oid))
399           {
400             if (algorithm)
401               *algorithm = module->mod_id;
402             if (oid_spec)
403               *oid_spec = cipher->oids[i];
404             ret = 1;
405           }
406       _gcry_module_release (module);
407     }
408
409   return ret;
410 }
411
412 /* Map STRING to the cipher algorithm identifier.  Returns the
413    algorithm ID of the cipher for the given name or 0 if the name is
414    not known.  It is valid to pass NULL for STRING which results in a
415    return value of 0. */
416 int
417 gcry_cipher_map_name (const char *string)
418 {
419   gcry_module_t cipher;
420   int ret, algorithm = 0;
421
422   if (! string)
423     return 0;
424
425   REGISTER_DEFAULT_CIPHERS;
426
427   /* If the string starts with a digit (optionally prefixed with
428      either "OID." or "oid."), we first look into our table of ASN.1
429      object identifiers to figure out the algorithm */
430
431   ath_mutex_lock (&ciphers_registered_lock);
432
433   ret = search_oid (string, &algorithm, NULL);
434   if (! ret)
435     {
436       cipher = gcry_cipher_lookup_name (string);
437       if (cipher)
438         {
439           algorithm = cipher->mod_id;
440           _gcry_module_release (cipher);
441         }
442     }
443
444   ath_mutex_unlock (&ciphers_registered_lock);
445   
446   return algorithm;
447 }
448
449
450 /* Given a STRING with an OID in dotted decimal notation, this
451    function returns the cipher mode (GCRY_CIPHER_MODE_*) associated
452    with that OID or 0 if no mode is known.  Passing NULL for string
453    yields a return value of 0. */
454 int
455 gcry_cipher_mode_from_oid (const char *string)
456 {
457   gcry_cipher_oid_spec_t oid_spec;
458   int ret = 0, mode = 0;
459
460   if (!string)
461     return 0;
462
463   ath_mutex_lock (&ciphers_registered_lock);
464   ret = search_oid (string, NULL, &oid_spec);
465   if (ret)
466     mode = oid_spec.mode;
467   ath_mutex_unlock (&ciphers_registered_lock);
468
469   return mode;
470 }
471
472
473 /* Map the cipher algorithm whose ID is contained in ALGORITHM to a
474    string representation of the algorithm name.  For unknown algorithm
475    IDs this function returns "?".  */
476 static const char *
477 cipher_algo_to_string (int algorithm)
478 {
479   gcry_module_t cipher;
480   const char *name;
481
482   REGISTER_DEFAULT_CIPHERS;
483
484   ath_mutex_lock (&ciphers_registered_lock);
485   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
486   if (cipher)
487     {
488       name = ((gcry_cipher_spec_t *) cipher->spec)->name;
489       _gcry_module_release (cipher);
490     }
491   else
492     name = "?";
493   ath_mutex_unlock (&ciphers_registered_lock);
494
495   return name;
496 }
497
498 /* Map the cipher algorithm identifier ALGORITHM to a string
499    representing this algorithm.  This string is the default name as
500    used by Libgcrypt.  An pointer to an empty string is returned for
501    an unknown algorithm.  NULL is never returned. */
502 const char *
503 gcry_cipher_algo_name (int algorithm)
504 {
505   return cipher_algo_to_string (algorithm);
506 }
507
508
509 /* Flag the cipher algorithm with the identifier ALGORITHM as
510    disabled.  There is no error return, the function does nothing for
511    unknown algorithms.  Disabled algorithms are vitually not available
512    in Libgcrypt. */
513 static void
514 disable_cipher_algo (int algorithm)
515 {
516   gcry_module_t cipher;
517
518   REGISTER_DEFAULT_CIPHERS;
519
520   ath_mutex_lock (&ciphers_registered_lock);
521   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
522   if (cipher)
523     {
524       if (! (cipher->flags & FLAG_MODULE_DISABLED))
525         cipher->flags |= FLAG_MODULE_DISABLED;
526       _gcry_module_release (cipher);
527     }
528   ath_mutex_unlock (&ciphers_registered_lock);
529 }
530
531
532 /* Return 0 if the cipher algorithm with indentifier ALGORITHM is
533    available. Returns a basic error code value if it is not available.  */
534 static gcry_err_code_t
535 check_cipher_algo (int algorithm)
536 {
537   gcry_err_code_t err = GPG_ERR_NO_ERROR;
538   gcry_module_t cipher;
539
540   REGISTER_DEFAULT_CIPHERS;
541
542   ath_mutex_lock (&ciphers_registered_lock);
543   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
544   if (cipher)
545     {
546       if (cipher->flags & FLAG_MODULE_DISABLED)
547         err = GPG_ERR_CIPHER_ALGO;
548       _gcry_module_release (cipher);
549     }
550   else
551     err = GPG_ERR_CIPHER_ALGO;
552   ath_mutex_unlock (&ciphers_registered_lock);
553   
554   return err;
555 }
556
557
558 /* Return the standard length of the key for the cipher algorithm with
559    the identifier ALGORITHM.  This function expects a valid algorithm
560    and will abort if the algorithm is not available or the length of
561    the key is not known. */
562 static unsigned int
563 cipher_get_keylen (int algorithm)
564 {
565   gcry_module_t cipher;
566   unsigned len = 0;
567
568   REGISTER_DEFAULT_CIPHERS;
569
570   ath_mutex_lock (&ciphers_registered_lock);
571   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
572   if (cipher)
573     {
574       len = ((gcry_cipher_spec_t *) cipher->spec)->keylen;
575       if (! len)
576         log_bug ("cipher %d w/o key length\n", algorithm);
577       _gcry_module_release (cipher);
578     }
579   else
580     log_bug ("cipher %d not found\n", algorithm);
581   ath_mutex_unlock (&ciphers_registered_lock);
582
583   return len;
584 }
585
586 /* Return the block length of the cipher algorithm with the identifier
587    ALGORITHM.  This function expects a valid algorithm and will abort
588    if the algorithm is not available or the length of the key is not
589    known. */
590 static unsigned int
591 cipher_get_blocksize (int algorithm)
592 {
593   gcry_module_t cipher;
594   unsigned len = 0;
595
596   REGISTER_DEFAULT_CIPHERS;
597
598   ath_mutex_lock (&ciphers_registered_lock);
599   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
600   if (cipher)
601     {
602       len = ((gcry_cipher_spec_t *) cipher->spec)->blocksize;
603       if (! len)
604           log_bug ("cipher %d w/o blocksize\n", algorithm);
605       _gcry_module_release (cipher);
606     }
607   else
608     log_bug ("cipher %d not found\n", algorithm);
609   ath_mutex_unlock (&ciphers_registered_lock);
610
611   return len;
612 }
613
614
615 /*
616    Open a cipher handle for use with cipher algorithm ALGORITHM, using
617    the cipher mode MODE (one of the GCRY_CIPHER_MODE_*) and return a
618    handle in HANDLE.  Put NULL into HANDLE and return an error code if
619    something goes wrong.  FLAGS may be used to modify the
620    operation.  The defined flags are:
621
622    GCRY_CIPHER_SECURE:  allocate all internal buffers in secure memory.
623    GCRY_CIPHER_ENABLE_SYNC:  Enable the sync operation as used in OpenPGP.
624    GCRY_CIPHER_CBC_CTS:  Enable CTS mode.
625    GCRY_CIPHER_CBC_MAC:  Enable MAC mode.
626
627    Values for these flags may be combined using OR.
628  */
629 gcry_error_t
630 gcry_cipher_open (gcry_cipher_hd_t *handle,
631                   int algo, int mode, unsigned int flags)
632 {
633   int secure = (flags & GCRY_CIPHER_SECURE);
634   gcry_cipher_spec_t *cipher = NULL;
635   gcry_module_t module = NULL;
636   gcry_cipher_hd_t h = NULL;
637   gcry_err_code_t err = 0;
638
639   /* If the application missed to call the random poll function, we do
640      it here to ensure that it is used once in a while. */
641   _gcry_fast_random_poll ();
642   
643   REGISTER_DEFAULT_CIPHERS;
644
645   /* Fetch the according module and check wether the cipher is marked
646      available for use.  */
647   ath_mutex_lock (&ciphers_registered_lock);
648   module = _gcry_module_lookup_id (ciphers_registered, algo);
649   if (module)
650     {
651       /* Found module.  */
652
653       if (module->flags & FLAG_MODULE_DISABLED)
654         {
655           /* Not available for use.  */
656           err = GPG_ERR_CIPHER_ALGO;
657           _gcry_module_release (module);
658         }
659       else
660         cipher = (gcry_cipher_spec_t *) module->spec;
661     }
662   else
663     err = GPG_ERR_CIPHER_ALGO;
664   ath_mutex_unlock (&ciphers_registered_lock);
665
666   /* check flags */
667   if ((! err)
668       && ((flags & ~(0 
669                      | GCRY_CIPHER_SECURE
670                      | GCRY_CIPHER_ENABLE_SYNC
671                      | GCRY_CIPHER_CBC_CTS
672                      | GCRY_CIPHER_CBC_MAC))
673           || (flags & GCRY_CIPHER_CBC_CTS & GCRY_CIPHER_CBC_MAC)))
674     err = GPG_ERR_CIPHER_ALGO;
675
676   /* check that a valid mode has been requested */
677   if (! err)
678     switch (mode)
679       {
680       case GCRY_CIPHER_MODE_ECB:
681       case GCRY_CIPHER_MODE_CBC:
682       case GCRY_CIPHER_MODE_CFB:
683       case GCRY_CIPHER_MODE_OFB:
684       case GCRY_CIPHER_MODE_CTR:
685         if ((cipher->encrypt == dummy_encrypt_block)
686             || (cipher->decrypt == dummy_decrypt_block))
687           err = GPG_ERR_INV_CIPHER_MODE;
688         break;
689
690       case GCRY_CIPHER_MODE_STREAM:
691         if ((cipher->stencrypt == dummy_encrypt_stream)
692             || (cipher->stdecrypt == dummy_decrypt_stream))
693           err = GPG_ERR_INV_CIPHER_MODE;
694         break;
695
696       case GCRY_CIPHER_MODE_NONE:
697         /* FIXME: issue a warning when this mode is used */
698         break;
699
700       default:
701         err = GPG_ERR_INV_CIPHER_MODE;
702       }
703
704   /* Perform selftest here and mark this with a flag in cipher_table?
705      No, we should not do this as it takes too long.  Further it does
706      not make sense to exclude algorithms with failing selftests at
707      runtime: If a selftest fails there is something seriously wrong
708      with the system and thus we better die immediately. */
709
710   if (! err)
711     {
712       size_t size = (sizeof (*h)
713                      + 2 * cipher->contextsize
714                      - sizeof (cipher_context_alignment_t)
715 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
716                      + 15  /* Space for leading alignment gap.  */
717 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
718                      );
719
720       if (secure)
721         h = gcry_calloc_secure (1, size);
722       else
723         h = gcry_calloc (1, size);
724
725       if (! h)
726         err = gpg_err_code_from_errno (errno);
727       else
728         {
729           size_t off = 0;
730
731 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
732           if ( ((unsigned long)h & 0x0f) )
733             {
734               /* The malloced block is not aligned on a 16 byte
735                  boundary.  Correct for this.  */
736               off = 16 - ((unsigned long)h & 0x0f);
737               h = (void*)((char*)h + off);
738             }
739 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
740
741           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
742           h->actual_handle_size = size - off;
743           h->handle_offset = off;
744           h->cipher = cipher;
745           h->module = module;
746           h->algo = algo;
747           h->mode = mode;
748           h->flags = flags;
749
750           /* Setup bulk encryption routines.  */
751           switch (algo)
752             {
753             case GCRY_CIPHER_AES128:
754             case GCRY_CIPHER_AES192:
755             case GCRY_CIPHER_AES256:
756               h->bulk.cfb_enc = _gcry_aes_cfb_enc;
757               h->bulk.cfb_dec = _gcry_aes_cfb_dec;
758               h->bulk.cbc_enc = _gcry_aes_cbc_enc;
759               h->bulk.cbc_dec = _gcry_aes_cbc_dec;
760               break;
761               
762             default:
763               break;
764             }
765         }
766     }
767
768   /* Done.  */
769
770   if (err)
771     {
772       if (module)
773         {
774           /* Release module.  */
775           ath_mutex_lock (&ciphers_registered_lock);
776           _gcry_module_release (module);
777           ath_mutex_unlock (&ciphers_registered_lock);
778         }
779     }
780
781   *handle = err ? NULL : h;
782
783   return gcry_error (err);
784 }
785
786
787 /* Release all resources associated with the cipher handle H. H may be
788    NULL in which case this is a no-operation. */
789 void
790 gcry_cipher_close (gcry_cipher_hd_t h)
791 {
792   size_t off;
793
794   if (! h)
795     return;
796
797   if ((h->magic != CTX_MAGIC_SECURE)
798       && (h->magic != CTX_MAGIC_NORMAL))
799     _gcry_fatal_error(GPG_ERR_INTERNAL,
800                       "gcry_cipher_close: already closed/invalid handle");
801   else
802     h->magic = 0;
803
804   /* Release module.  */
805   ath_mutex_lock (&ciphers_registered_lock);
806   _gcry_module_release (h->module);
807   ath_mutex_unlock (&ciphers_registered_lock);
808
809   /* We always want to wipe out the memory even when the context has
810      been allocated in secure memory.  The user might have disabled
811      secure memory or is using his own implementation which does not
812      do the wiping.  To accomplish this we need to keep track of the
813      actual size of this structure because we have no way to known
814      how large the allocated area was when using a standard malloc. */
815   off = h->handle_offset;
816   wipememory (h, h->actual_handle_size);
817
818   gcry_free ((char*)h - off);
819 }
820
821
822 /* Set the key to be used for the encryption context C to KEY with
823    length KEYLEN.  The length should match the required length. */
824 static gcry_error_t
825 cipher_setkey (gcry_cipher_hd_t c, byte *key, unsigned keylen)
826 {
827   gcry_err_code_t ret;
828
829   ret = (*c->cipher->setkey) (&c->context.c, key, keylen);
830   if (! ret)
831     /* Duplicate initial context.  */
832     memcpy ((void *) ((char *) &c->context.c + c->cipher->contextsize),
833             (void *) &c->context.c,
834             c->cipher->contextsize);
835
836   return gcry_error (ret);
837 }
838
839
840 /* Set the IV to be used for the encryption context C to IV with
841    length IVLEN.  The length should match the required length. */
842 static void
843 cipher_setiv( gcry_cipher_hd_t c, const byte *iv, unsigned ivlen )
844 {
845   memset (c->u_iv.iv, 0, c->cipher->blocksize);
846   if (iv) 
847     {
848       if (ivlen != c->cipher->blocksize)
849         log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
850                   ivlen, (unsigned int)c->cipher->blocksize);
851       if (ivlen > c->cipher->blocksize)
852         ivlen = c->cipher->blocksize;
853       memcpy (c->u_iv.iv, iv, ivlen);
854     }
855   c->unused = 0;
856 }
857
858
859 /* Reset the cipher context to the initial context.  This is basically
860    the same as an release followed by a new. */
861 static void
862 cipher_reset (gcry_cipher_hd_t c)
863 {
864   memcpy (&c->context.c,
865           (char *) &c->context.c + c->cipher->contextsize,
866           c->cipher->contextsize);
867   memset (c->u_iv.iv, 0, c->cipher->blocksize);
868   memset (c->lastiv, 0, c->cipher->blocksize);
869   memset (c->ctr, 0, c->cipher->blocksize);
870 }
871
872
873 static void
874 do_ecb_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
875                 unsigned int nblocks )
876 {
877     unsigned int n;
878
879     for(n=0; n < nblocks; n++ ) {
880         c->cipher->encrypt ( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
881         inbuf  += c->cipher->blocksize;
882         outbuf += c->cipher->blocksize;
883     }
884 }
885
886 static void
887 do_ecb_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
888                 unsigned int nblocks )
889 {
890     unsigned n;
891
892     for(n=0; n < nblocks; n++ ) {
893         c->cipher->decrypt ( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
894         inbuf  += c->cipher->blocksize;
895         outbuf += c->cipher->blocksize;
896     }
897 }
898
899
900 static void
901 do_cbc_encrypt (gcry_cipher_hd_t c, unsigned char *outbuf, 
902                 const unsigned char *inbuf, unsigned int nbytes )
903 {
904   unsigned int n;
905   unsigned char *ivp;
906   int i;
907   size_t blocksize = c->cipher->blocksize;
908   unsigned nblocks = nbytes / blocksize;
909
910   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) 
911     {
912       if ((nbytes % blocksize) == 0)
913         nblocks--;
914     }
915
916   if (c->bulk.cbc_enc)
917     {
918       c->bulk.cbc_enc (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks,
919                        (c->flags & GCRY_CIPHER_CBC_MAC)); 
920       inbuf  += nblocks * blocksize;
921       if (!(c->flags & GCRY_CIPHER_CBC_MAC))
922         outbuf += nblocks * blocksize;
923     }
924   else
925     {
926       for (n=0; n < nblocks; n++ )
927         {
928           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
929             outbuf[i] = inbuf[i] ^ *ivp++;
930           c->cipher->encrypt ( &c->context.c, outbuf, outbuf );
931           memcpy (c->u_iv.iv, outbuf, blocksize );
932           inbuf  += blocksize;
933           if (!(c->flags & GCRY_CIPHER_CBC_MAC))
934             outbuf += blocksize;
935         }
936     }
937
938   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize)
939     {
940       /* We have to be careful here, since outbuf might be equal to
941          inbuf.  */
942       int restbytes;
943       unsigned char b;
944
945       if ((nbytes % blocksize) == 0)
946         restbytes = blocksize;
947       else
948         restbytes = nbytes % blocksize;
949
950       outbuf -= blocksize;
951       for (ivp = c->u_iv.iv, i = 0; i < restbytes; i++)
952         {
953           b = inbuf[i];
954           outbuf[blocksize + i] = outbuf[i];
955           outbuf[i] = b ^ *ivp++;
956         }
957       for (; i < blocksize; i++)
958         outbuf[i] = 0 ^ *ivp++;
959       
960       c->cipher->encrypt (&c->context.c, outbuf, outbuf);
961       memcpy (c->u_iv.iv, outbuf, blocksize);
962     }
963 }
964
965
966 static void
967 do_cbc_decrypt (gcry_cipher_hd_t c, unsigned char *outbuf, 
968                 const unsigned char *inbuf, unsigned int nbytes)
969 {
970   unsigned int n;
971   unsigned char *ivp;
972   int i;
973   size_t blocksize = c->cipher->blocksize;
974   unsigned int nblocks = nbytes / blocksize;
975
976   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize)
977     {
978       nblocks--;
979       if ((nbytes % blocksize) == 0)
980         nblocks--;
981       memcpy (c->lastiv, c->u_iv.iv, blocksize);
982     }
983
984   if (c->bulk.cbc_dec)
985     {
986       c->bulk.cbc_dec (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
987       inbuf  += nblocks * blocksize;
988       outbuf += nblocks * blocksize;
989     }
990   else
991     {
992       for (n=0; n < nblocks; n++ ) 
993         {
994           /* Because outbuf and inbuf might be the same, we have to
995            * save the original ciphertext block.  We use lastiv for
996            * this here because it is not used otherwise. */
997           memcpy (c->lastiv, inbuf, blocksize);
998           c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
999           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1000             outbuf[i] ^= *ivp++;
1001           memcpy(c->u_iv.iv, c->lastiv, blocksize );
1002           inbuf  += c->cipher->blocksize;
1003           outbuf += c->cipher->blocksize;
1004         }
1005     }
1006
1007   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) 
1008     {
1009       int restbytes;
1010       
1011       if ((nbytes % blocksize) == 0)
1012         restbytes = blocksize;
1013       else
1014         restbytes = nbytes % blocksize;
1015       
1016       memcpy (c->lastiv, c->u_iv.iv, blocksize );         /* Save Cn-2. */
1017       memcpy (c->u_iv.iv, inbuf + blocksize, restbytes ); /* Save Cn. */
1018
1019       c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
1020       for (ivp=c->u_iv.iv,i=0; i < restbytes; i++ )
1021         outbuf[i] ^= *ivp++;
1022       
1023       memcpy(outbuf + blocksize, outbuf, restbytes);
1024       for(i=restbytes; i < blocksize; i++)
1025         c->u_iv.iv[i] = outbuf[i];
1026       c->cipher->decrypt (&c->context.c, outbuf, c->u_iv.iv);
1027       for(ivp=c->lastiv,i=0; i < blocksize; i++ )
1028         outbuf[i] ^= *ivp++;
1029       /* c->lastiv is now really lastlastiv, does this matter? */
1030     }
1031 }
1032
1033
1034 static void
1035 do_cfb_encrypt( gcry_cipher_hd_t c, unsigned char *outbuf, 
1036                 const unsigned char *inbuf, unsigned int nbytes )
1037 {
1038   unsigned char *ivp;
1039   size_t blocksize = c->cipher->blocksize;
1040   size_t blocksize_x_2 = blocksize + blocksize;
1041   
1042   if ( nbytes <= c->unused )
1043     {
1044       /* Short enough to be encoded by the remaining XOR mask. */
1045       /* XOR the input with the IV and store input into IV. */
1046       for (ivp=c->u_iv.iv+c->cipher->blocksize - c->unused;
1047            nbytes;
1048            nbytes--, c->unused-- )
1049         *outbuf++ = (*ivp++ ^= *inbuf++);
1050       return;
1051     }
1052
1053   if ( c->unused )
1054     {
1055       /* XOR the input with the IV and store input into IV */
1056       nbytes -= c->unused;
1057       for(ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1058         *outbuf++ = (*ivp++ ^= *inbuf++);
1059     }
1060
1061   /* Now we can process complete blocks.  We use a loop as long as we
1062      have at least 2 blocks and use conditions for the rest.  This
1063      also allows to use a bulk encryption function if available.  */
1064   if (nbytes >= blocksize_x_2 && c->bulk.cfb_enc)
1065     {
1066       unsigned int nblocks = nbytes / blocksize;
1067       c->bulk.cfb_enc (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1068       outbuf += nblocks * blocksize;
1069       inbuf  += nblocks * blocksize;
1070       nbytes -= nblocks * blocksize;
1071     }
1072   else
1073     {
1074       while ( nbytes >= blocksize_x_2 )
1075         {
1076           int i;
1077           /* Encrypt the IV. */
1078           c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1079           /* XOR the input with the IV and store input into IV.  */
1080           for(ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1081             *outbuf++ = (*ivp++ ^= *inbuf++);
1082           nbytes -= blocksize;
1083         }
1084     }
1085
1086   if ( nbytes >= blocksize )
1087     {
1088       int i;
1089       /* Save the current IV and then encrypt the IV. */
1090       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1091       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1092       /* XOR the input with the IV and store input into IV */
1093       for(ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1094         *outbuf++ = (*ivp++ ^= *inbuf++);
1095       nbytes -= blocksize;
1096     }
1097   if ( nbytes ) 
1098     {
1099       /* Save the current IV and then encrypt the IV. */
1100       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1101       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1102       c->unused = blocksize;
1103       /* Apply the XOR. */
1104       c->unused -= nbytes;
1105       for(ivp=c->u_iv.iv; nbytes; nbytes-- )
1106         *outbuf++ = (*ivp++ ^= *inbuf++);
1107     }
1108 }
1109
1110
1111 static void
1112 do_cfb_decrypt( gcry_cipher_hd_t c, unsigned char *outbuf, 
1113                 const unsigned char *inbuf, unsigned int nbytes )
1114 {
1115   unsigned char *ivp;
1116   unsigned long temp;
1117   int i;
1118   size_t blocksize = c->cipher->blocksize;
1119   size_t blocksize_x_2 = blocksize + blocksize;
1120   
1121   if (nbytes <= c->unused)
1122     {
1123       /* Short enough to be encoded by the remaining XOR mask. */
1124       /* XOR the input with the IV and store input into IV. */
1125       for (ivp=c->u_iv.iv+blocksize - c->unused;
1126            nbytes; 
1127            nbytes--, c->unused--)
1128         {
1129           temp = *inbuf++;
1130           *outbuf++ = *ivp ^ temp;
1131           *ivp++ = temp;
1132         }
1133       return;
1134     }
1135   
1136   if (c->unused)
1137     {
1138       /* XOR the input with the IV and store input into IV. */
1139       nbytes -= c->unused;
1140       for (ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1141         {
1142           temp = *inbuf++;
1143           *outbuf++ = *ivp ^ temp;
1144           *ivp++ = temp;
1145         }
1146     }
1147   
1148   /* Now we can process complete blocks.  We use a loop as long as we
1149      have at least 2 blocks and use conditions for the rest.  This
1150      also allows to use a bulk encryption function if available.  */
1151   if (nbytes >= blocksize_x_2 && c->bulk.cfb_dec)
1152     {
1153       unsigned int nblocks = nbytes / blocksize;
1154       c->bulk.cfb_dec (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1155       outbuf += nblocks * blocksize;
1156       inbuf  += nblocks * blocksize;
1157       nbytes -= nblocks * blocksize;
1158     }
1159   else
1160     {
1161       while (nbytes >= blocksize_x_2 )
1162         {
1163           /* Encrypt the IV. */
1164           c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1165           /* XOR the input with the IV and store input into IV. */
1166           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1167             {
1168               temp = *inbuf++;
1169               *outbuf++ = *ivp ^ temp;
1170               *ivp++ = temp;
1171             }
1172           nbytes -= blocksize;
1173         }
1174     }
1175
1176   if (nbytes >= blocksize )
1177     {
1178       /* Save the current IV and then encrypt the IV. */
1179       memcpy ( c->lastiv, c->u_iv.iv, blocksize);
1180       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1181       /* XOR the input with the IV and store input into IV */
1182       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1183         {
1184           temp = *inbuf++;
1185           *outbuf++ = *ivp ^ temp;
1186           *ivp++ = temp;
1187         }
1188       nbytes -= blocksize;
1189     }
1190
1191   if (nbytes)
1192     { 
1193       /* Save the current IV and then encrypt the IV. */
1194       memcpy ( c->lastiv, c->u_iv.iv, blocksize );
1195       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1196       c->unused = blocksize;
1197       /* Apply the XOR. */
1198       c->unused -= nbytes;
1199       for (ivp=c->u_iv.iv; nbytes; nbytes-- )
1200         {
1201           temp = *inbuf++;
1202           *outbuf++ = *ivp ^ temp;
1203           *ivp++ = temp;
1204         }
1205     }
1206 }
1207
1208
1209 static void
1210 do_ofb_encrypt( gcry_cipher_hd_t c,
1211                 byte *outbuf, const byte *inbuf, unsigned nbytes )
1212 {
1213   byte *ivp;
1214   size_t blocksize = c->cipher->blocksize;
1215
1216   if ( nbytes <= c->unused )
1217     {
1218       /* Short enough to be encoded by the remaining XOR mask. */
1219       /* XOR the input with the IV */
1220       for (ivp=c->u_iv.iv+c->cipher->blocksize - c->unused;
1221            nbytes;
1222            nbytes--, c->unused-- )
1223         *outbuf++ = (*ivp++ ^ *inbuf++);
1224       return;
1225     }
1226
1227   if( c->unused )
1228     {
1229       nbytes -= c->unused;
1230       for(ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1231         *outbuf++ = (*ivp++ ^ *inbuf++);
1232     }
1233
1234   /* Now we can process complete blocks. */
1235   while ( nbytes >= blocksize )
1236     {
1237       int i;
1238       /* Encrypt the IV (and save the current one). */
1239       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1240       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1241       
1242       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1243         *outbuf++ = (*ivp++ ^ *inbuf++);
1244       nbytes -= blocksize;
1245     }
1246   if ( nbytes )
1247     { /* process the remaining bytes */
1248       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1249       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1250       c->unused = blocksize;
1251       c->unused -= nbytes;
1252       for(ivp=c->u_iv.iv; nbytes; nbytes-- )
1253         *outbuf++ = (*ivp++ ^ *inbuf++);
1254     }
1255 }
1256
1257 static void
1258 do_ofb_decrypt( gcry_cipher_hd_t c,
1259                 byte *outbuf, const byte *inbuf, unsigned int nbytes )
1260 {
1261   byte *ivp;
1262   size_t blocksize = c->cipher->blocksize;
1263   
1264   if( nbytes <= c->unused )
1265     {
1266       /* Short enough to be encoded by the remaining XOR mask. */
1267       for (ivp=c->u_iv.iv+blocksize - c->unused; nbytes; nbytes--,c->unused--)
1268         *outbuf++ = *ivp++ ^ *inbuf++;
1269       return;
1270     }
1271
1272   if ( c->unused )
1273     {
1274       nbytes -= c->unused;
1275       for (ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1276         *outbuf++ = *ivp++ ^ *inbuf++;
1277     }
1278
1279   /* Now we can process complete blocks. */
1280   while ( nbytes >= blocksize )
1281     {
1282       int i;
1283       /* Encrypt the IV (and save the current one). */
1284       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1285       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1286       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1287         *outbuf++ = *ivp++ ^ *inbuf++;
1288       nbytes -= blocksize;
1289     }
1290   if ( nbytes ) 
1291     { /* Process the remaining bytes. */
1292       /* Encrypt the IV (and save the current one). */
1293       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1294       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1295       c->unused = blocksize;
1296       c->unused -= nbytes;
1297       for (ivp=c->u_iv.iv; nbytes; nbytes-- )
1298         *outbuf++ = *ivp++ ^ *inbuf++;
1299     }
1300 }
1301
1302
1303 static void
1304 do_ctr_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1305                 unsigned int nbytes )
1306 {
1307   unsigned int n;
1308   byte tmp[MAX_BLOCKSIZE];
1309   int i;
1310
1311   for(n=0; n < nbytes; n++)
1312     {
1313       if ((n % c->cipher->blocksize) == 0)
1314         {
1315           c->cipher->encrypt (&c->context.c, tmp, c->ctr);
1316
1317           for (i = c->cipher->blocksize; i > 0; i--)
1318             {
1319               c->ctr[i-1]++;
1320               if (c->ctr[i-1] != 0)
1321                 break;
1322             }
1323         }
1324
1325       /* XOR input with encrypted counter and store in output. */
1326       outbuf[n] = inbuf[n] ^ tmp[n % c->cipher->blocksize];
1327     }
1328 }
1329
1330 static void
1331 do_ctr_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1332                 unsigned int nbytes )
1333 {
1334   do_ctr_encrypt (c, outbuf, inbuf, nbytes);
1335 }
1336
1337
1338 /****************
1339  * Encrypt INBUF to OUTBUF with the mode selected at open.
1340  * inbuf and outbuf may overlap or be the same.
1341  * Depending on the mode some contraints apply to NBYTES.
1342  */
1343 static gcry_err_code_t
1344 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf,
1345                 const byte *inbuf, unsigned int nbytes)
1346 {
1347     gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1348
1349     switch( c->mode ) {
1350       case GCRY_CIPHER_MODE_ECB:
1351         if (!(nbytes%c->cipher->blocksize))
1352             do_ecb_encrypt(c, outbuf, inbuf, nbytes/c->cipher->blocksize );
1353         else 
1354             rc = GPG_ERR_INV_ARG;
1355         break;
1356       case GCRY_CIPHER_MODE_CBC:
1357         if (!(nbytes%c->cipher->blocksize)
1358             || (nbytes > c->cipher->blocksize
1359                 && (c->flags & GCRY_CIPHER_CBC_CTS)))
1360             do_cbc_encrypt(c, outbuf, inbuf, nbytes );
1361         else 
1362             rc = GPG_ERR_INV_ARG;
1363         break;
1364       case GCRY_CIPHER_MODE_CFB:
1365         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
1366         break;
1367       case GCRY_CIPHER_MODE_OFB:
1368         do_ofb_encrypt(c, outbuf, inbuf, nbytes );
1369         break;
1370       case GCRY_CIPHER_MODE_CTR:
1371         do_ctr_encrypt(c, outbuf, inbuf, nbytes );
1372         break;
1373       case GCRY_CIPHER_MODE_STREAM:
1374         c->cipher->stencrypt ( &c->context.c,
1375                                outbuf, (byte*)/*arggg*/inbuf, nbytes );
1376         break;
1377       case GCRY_CIPHER_MODE_NONE:
1378         if( inbuf != outbuf )
1379             memmove( outbuf, inbuf, nbytes );
1380         break;
1381       default:
1382         log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
1383         rc = GPG_ERR_INV_CIPHER_MODE;
1384         break;
1385     }
1386     return rc;
1387 }
1388
1389
1390 /****************
1391  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
1392  * been requested.
1393  */
1394 gcry_error_t
1395 gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1396                      const void *in, size_t inlen)
1397 {
1398   gcry_err_code_t err;
1399
1400   if (!in)
1401     /* Caller requested in-place encryption. */
1402     /* Actually cipher_encrypt() does not need to know about it, but
1403      * we may change it in the future to get better performance.  */
1404     err = cipher_encrypt (h, out, out, outsize);
1405   else if (outsize < ((h->flags & GCRY_CIPHER_CBC_MAC) ?
1406                       h->cipher->blocksize : inlen))
1407     err = GPG_ERR_TOO_SHORT;
1408   else if ((h->mode == GCRY_CIPHER_MODE_ECB
1409             || (h->mode == GCRY_CIPHER_MODE_CBC
1410                 && (! ((h->flags & GCRY_CIPHER_CBC_CTS)
1411                        && (inlen > h->cipher->blocksize)))))
1412            && (inlen % h->cipher->blocksize))
1413     err = GPG_ERR_INV_ARG;
1414   else
1415     err = cipher_encrypt (h, out, in, inlen);
1416
1417   if (err && out)
1418     memset (out, 0x42, outsize); /* Failsafe: Make sure that the
1419                                     plaintext will never make it into
1420                                     OUT. */
1421
1422   return gcry_error (err);
1423 }
1424
1425
1426
1427 /****************
1428  * Decrypt INBUF to OUTBUF with the mode selected at open.
1429  * inbuf and outbuf may overlap or be the same.
1430  * Depending on the mode some some contraints apply to NBYTES.
1431  */
1432 static gcry_err_code_t
1433 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1434                 unsigned int nbytes)
1435 {
1436     gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1437
1438     switch( c->mode ) {
1439       case GCRY_CIPHER_MODE_ECB:
1440         if (!(nbytes%c->cipher->blocksize))
1441             do_ecb_decrypt(c, outbuf, inbuf, nbytes/c->cipher->blocksize );
1442         else 
1443             rc = GPG_ERR_INV_ARG;
1444         break;
1445       case GCRY_CIPHER_MODE_CBC:
1446         if (!(nbytes%c->cipher->blocksize)
1447             || (nbytes > c->cipher->blocksize
1448                 && (c->flags & GCRY_CIPHER_CBC_CTS)))
1449             do_cbc_decrypt(c, outbuf, inbuf, nbytes );
1450         else 
1451             rc = GPG_ERR_INV_ARG;
1452         break;
1453       case GCRY_CIPHER_MODE_CFB:
1454         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
1455         break;
1456       case GCRY_CIPHER_MODE_OFB:
1457         do_ofb_decrypt(c, outbuf, inbuf, nbytes );
1458         break;
1459       case GCRY_CIPHER_MODE_CTR:
1460         do_ctr_decrypt(c, outbuf, inbuf, nbytes );
1461         break;
1462       case GCRY_CIPHER_MODE_STREAM:
1463         c->cipher->stdecrypt ( &c->context.c,
1464                                outbuf, (byte*)/*arggg*/inbuf, nbytes );
1465         break;
1466       case GCRY_CIPHER_MODE_NONE:
1467         if( inbuf != outbuf )
1468             memmove( outbuf, inbuf, nbytes );
1469         break;
1470       default:
1471         log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1472         rc = GPG_ERR_INV_CIPHER_MODE;
1473         break;
1474     }
1475     return rc;
1476 }
1477
1478
1479 gcry_error_t
1480 gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1481                      const void *in, size_t inlen)
1482 {
1483   gcry_err_code_t err = 0;
1484
1485   if (!in)
1486     /* Caller requested in-place encryption. */
1487     /* Actually cipher_encrypt() does not need to know about it, but
1488      * we may change it in the future to get better performance.  */
1489     err = cipher_decrypt (h, out, out, outsize);
1490   else if (outsize < inlen)
1491     err = GPG_ERR_TOO_SHORT;
1492   else if (((h->mode == GCRY_CIPHER_MODE_ECB)
1493             || ((h->mode == GCRY_CIPHER_MODE_CBC)
1494                 && (! ((h->flags & GCRY_CIPHER_CBC_CTS)
1495                        && (inlen > h->cipher->blocksize)))))
1496            && (inlen % h->cipher->blocksize) != 0)
1497     err = GPG_ERR_INV_ARG;
1498   else
1499     err = cipher_decrypt (h, out, in, inlen);
1500
1501   return gcry_error (err);
1502 }
1503
1504
1505
1506 /****************
1507  * Used for PGP's somewhat strange CFB mode. Only works if
1508  * the corresponding flag is set.
1509  */
1510 static void
1511 cipher_sync( gcry_cipher_hd_t c )
1512 {
1513   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1514     {
1515       memmove (c->u_iv.iv + c->unused,
1516                c->u_iv.iv, c->cipher->blocksize - c->unused);
1517       memcpy (c->u_iv.iv,
1518               c->lastiv + c->cipher->blocksize - c->unused, c->unused);
1519       c->unused = 0;
1520     }
1521 }
1522
1523
1524 gcry_error_t
1525 gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1526 {
1527   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1528
1529   switch (cmd)
1530     {
1531     case GCRYCTL_SET_KEY:
1532       rc = cipher_setkey( h, buffer, buflen );
1533       break;
1534     case GCRYCTL_SET_IV:
1535       cipher_setiv( h, buffer, buflen );
1536       break;
1537     case GCRYCTL_RESET:
1538       cipher_reset (h);
1539       break;
1540     case GCRYCTL_CFB_SYNC:
1541       cipher_sync( h );
1542       break;
1543     case GCRYCTL_SET_CBC_CTS:
1544       if (buflen)
1545         if (h->flags & GCRY_CIPHER_CBC_MAC)
1546           rc = GPG_ERR_INV_FLAG;
1547         else
1548           h->flags |= GCRY_CIPHER_CBC_CTS;
1549       else
1550         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1551       break;
1552     case GCRYCTL_SET_CBC_MAC:
1553       if (buflen)
1554         if (h->flags & GCRY_CIPHER_CBC_CTS)
1555           rc = GPG_ERR_INV_FLAG;
1556         else
1557           h->flags |= GCRY_CIPHER_CBC_MAC;
1558       else
1559         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1560       break;
1561     case GCRYCTL_DISABLE_ALGO:
1562       /* this one expects a NULL handle and buffer pointing to an
1563        * integer with the algo number.
1564        */
1565       if( h || !buffer || buflen != sizeof(int) )
1566         return gcry_error (GPG_ERR_CIPHER_ALGO);
1567       disable_cipher_algo( *(int*)buffer );
1568       break;
1569     case GCRYCTL_SET_CTR:
1570       if (buffer && buflen == h->cipher->blocksize)
1571         memcpy (h->ctr, buffer, h->cipher->blocksize);
1572       else if (buffer == NULL || buflen == 0)
1573         memset (h->ctr, 0, h->cipher->blocksize);
1574       else
1575         rc = GPG_ERR_INV_ARG;
1576       break;
1577
1578     default:
1579       rc = GPG_ERR_INV_OP;
1580     }
1581
1582   return gcry_error (rc);
1583 }
1584
1585
1586 /****************
1587  * Return information about the cipher handle.
1588  */
1589 gcry_error_t
1590 gcry_cipher_info( gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1591 {
1592   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1593
1594   (void)h;
1595   (void)buffer;
1596   (void)nbytes;
1597
1598   switch (cmd)
1599     {
1600     default:
1601       err = GPG_ERR_INV_OP;
1602     }
1603
1604   return gcry_error (err);
1605 }
1606
1607 /****************
1608  * Return information about the given cipher algorithm
1609  * WHAT select the kind of information returned:
1610  *  GCRYCTL_GET_KEYLEN:
1611  *      Return the length of the key, if the algorithm
1612  *      supports multiple key length, the maximum supported value
1613  *      is returnd.  The length is return as number of octets.
1614  *      buffer and nbytes must be zero.
1615  *      The keylength is returned in _bytes_.
1616  *  GCRYCTL_GET_BLKLEN:
1617  *      Return the blocklength of the algorithm counted in octets.
1618  *      buffer and nbytes must be zero.
1619  *  GCRYCTL_TEST_ALGO:
1620  *      Returns 0 when the specified algorithm is available for use.
1621  *      buffer and nbytes must be zero.
1622  *
1623  * Note:  Because this function is in most cases used to return an
1624  * integer value, we can make it easier for the caller to just look at
1625  * the return value.  The caller will in all cases consult the value
1626  * and thereby detecting whether a error occured or not (i.e. while checking
1627  * the block size)
1628  */
1629 gcry_error_t
1630 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1631 {
1632   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1633   unsigned int ui;
1634
1635   switch (what)
1636     {
1637     case GCRYCTL_GET_KEYLEN:
1638       if (buffer || (! nbytes))
1639         err = GPG_ERR_CIPHER_ALGO;
1640       else
1641         {
1642           ui = cipher_get_keylen (algo);
1643           if ((ui > 0) && (ui <= 512))
1644             *nbytes = (size_t) ui / 8;
1645           else
1646             /* The only reason is an invalid algo or a strange
1647                blocksize.  */
1648             err = GPG_ERR_CIPHER_ALGO;
1649         }
1650       break;
1651
1652     case GCRYCTL_GET_BLKLEN:
1653       if (buffer || (! nbytes))
1654         err = GPG_ERR_CIPHER_ALGO;
1655       else
1656         {
1657           ui = cipher_get_blocksize (algo);
1658           if ((ui > 0) && (ui < 10000))
1659             *nbytes = ui;
1660           else
1661             /* The only reason is an invalid algo or a strange
1662                blocksize.  */
1663             err = GPG_ERR_CIPHER_ALGO;
1664         }
1665       break;
1666
1667     case GCRYCTL_TEST_ALGO:
1668       if (buffer || nbytes)
1669         err = GPG_ERR_INV_ARG;
1670       else
1671         err = check_cipher_algo (algo);
1672       break;
1673
1674       default:
1675         err = GPG_ERR_INV_OP;
1676     }
1677
1678   return gcry_error (err);
1679 }
1680
1681
1682 size_t
1683 gcry_cipher_get_algo_keylen (int algo) 
1684 {
1685   size_t n;
1686
1687   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1688     n = 0;
1689   return n;
1690 }
1691
1692
1693 size_t
1694 gcry_cipher_get_algo_blklen (int algo) 
1695 {
1696   size_t n;
1697
1698   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1699     n = 0;
1700   return n;
1701 }
1702
1703
1704 gcry_err_code_t
1705 _gcry_cipher_init (void)
1706 {
1707   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1708
1709   REGISTER_DEFAULT_CIPHERS;
1710
1711   return err;
1712 }
1713
1714 /* Get a list consisting of the IDs of the loaded cipher modules.  If
1715    LIST is zero, write the number of loaded cipher modules to
1716    LIST_LENGTH and return.  If LIST is non-zero, the first
1717    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
1718    according size.  In case there are less cipher modules than
1719    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
1720 gcry_error_t
1721 gcry_cipher_list (int *list, int *list_length)
1722 {
1723   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1724
1725   ath_mutex_lock (&ciphers_registered_lock);
1726   err = _gcry_module_list (ciphers_registered, list, list_length);
1727   ath_mutex_unlock (&ciphers_registered_lock);
1728
1729   return err;
1730 }