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