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