A whole bunch of changes to eventually support
[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         /* FIXME: issue a warning when this mode is used */
735         break;
736
737       default:
738         err = GPG_ERR_INV_CIPHER_MODE;
739       }
740
741   /* Perform selftest here and mark this with a flag in cipher_table?
742      No, we should not do this as it takes too long.  Further it does
743      not make sense to exclude algorithms with failing selftests at
744      runtime: If a selftest fails there is something seriously wrong
745      with the system and thus we better die immediately. */
746
747   if (! err)
748     {
749       size_t size = (sizeof (*h)
750                      + 2 * cipher->contextsize
751                      - sizeof (cipher_context_alignment_t)
752 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
753                      + 15  /* Space for leading alignment gap.  */
754 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
755                      );
756
757       if (secure)
758         h = gcry_calloc_secure (1, size);
759       else
760         h = gcry_calloc (1, size);
761
762       if (! h)
763         err = gpg_err_code_from_errno (errno);
764       else
765         {
766           size_t off = 0;
767
768 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
769           if ( ((unsigned long)h & 0x0f) )
770             {
771               /* The malloced block is not aligned on a 16 byte
772                  boundary.  Correct for this.  */
773               off = 16 - ((unsigned long)h & 0x0f);
774               h = (void*)((char*)h + off);
775             }
776 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
777
778           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
779           h->actual_handle_size = size - off;
780           h->handle_offset = off;
781           h->cipher = cipher;
782           h->module = module;
783           h->algo = algo;
784           h->mode = mode;
785           h->flags = flags;
786
787           /* Setup bulk encryption routines.  */
788           switch (algo)
789             {
790 #ifdef USE_AES
791             case GCRY_CIPHER_AES128:
792             case GCRY_CIPHER_AES192:
793             case GCRY_CIPHER_AES256:
794               h->bulk.cfb_enc = _gcry_aes_cfb_enc;
795               h->bulk.cfb_dec = _gcry_aes_cfb_dec;
796               h->bulk.cbc_enc = _gcry_aes_cbc_enc;
797               h->bulk.cbc_dec = _gcry_aes_cbc_dec;
798               break;
799 #endif /*USE_AES*/
800               
801             default:
802               break;
803             }
804         }
805     }
806
807   /* Done.  */
808
809   if (err)
810     {
811       if (module)
812         {
813           /* Release module.  */
814           ath_mutex_lock (&ciphers_registered_lock);
815           _gcry_module_release (module);
816           ath_mutex_unlock (&ciphers_registered_lock);
817         }
818     }
819
820   *handle = err ? NULL : h;
821
822   return gcry_error (err);
823 }
824
825
826 /* Release all resources associated with the cipher handle H. H may be
827    NULL in which case this is a no-operation. */
828 void
829 gcry_cipher_close (gcry_cipher_hd_t h)
830 {
831   size_t off;
832
833   if (!h)
834     return;
835
836   if ((h->magic != CTX_MAGIC_SECURE)
837       && (h->magic != CTX_MAGIC_NORMAL))
838     _gcry_fatal_error(GPG_ERR_INTERNAL,
839                       "gcry_cipher_close: already closed/invalid handle");
840   else
841     h->magic = 0;
842
843   /* Release module.  */
844   ath_mutex_lock (&ciphers_registered_lock);
845   _gcry_module_release (h->module);
846   ath_mutex_unlock (&ciphers_registered_lock);
847
848   /* We always want to wipe out the memory even when the context has
849      been allocated in secure memory.  The user might have disabled
850      secure memory or is using his own implementation which does not
851      do the wiping.  To accomplish this we need to keep track of the
852      actual size of this structure because we have no way to known
853      how large the allocated area was when using a standard malloc. */
854   off = h->handle_offset;
855   wipememory (h, h->actual_handle_size);
856
857   gcry_free ((char*)h - off);
858 }
859
860
861 /* Set the key to be used for the encryption context C to KEY with
862    length KEYLEN.  The length should match the required length. */
863 static gcry_error_t
864 cipher_setkey (gcry_cipher_hd_t c, byte *key, unsigned int keylen)
865 {
866   gcry_err_code_t ret;
867
868   ret = (*c->cipher->setkey) (&c->context.c, key, keylen);
869   if (!ret)
870     {
871       /* Duplicate initial context.  */
872       memcpy ((void *) ((char *) &c->context.c + c->cipher->contextsize),
873               (void *) &c->context.c,
874               c->cipher->contextsize);
875     }
876
877   return gcry_error (ret);
878 }
879
880
881 /* Set the IV to be used for the encryption context C to IV with
882    length IVLEN.  The length should match the required length. */
883 static void
884 cipher_setiv( gcry_cipher_hd_t c, const byte *iv, unsigned ivlen )
885 {
886   memset (c->u_iv.iv, 0, c->cipher->blocksize);
887   if (iv) 
888     {
889       if (ivlen != c->cipher->blocksize)
890         {
891           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
892                     ivlen, (unsigned int)c->cipher->blocksize);
893           fips_signal_error ("IV length does not match blocklength");
894         }
895       if (ivlen > c->cipher->blocksize)
896         ivlen = c->cipher->blocksize;
897       memcpy (c->u_iv.iv, iv, ivlen);
898     }
899   c->unused = 0;
900 }
901
902
903 /* Reset the cipher context to the initial context.  This is basically
904    the same as an release followed by a new. */
905 static void
906 cipher_reset (gcry_cipher_hd_t c)
907 {
908   memcpy (&c->context.c,
909           (char *) &c->context.c + c->cipher->contextsize,
910           c->cipher->contextsize);
911   memset (c->u_iv.iv, 0, c->cipher->blocksize);
912   memset (c->lastiv, 0, c->cipher->blocksize);
913   memset (c->ctr, 0, c->cipher->blocksize);
914 }
915
916
917 static void
918 do_ecb_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
919                 unsigned int nblocks )
920 {
921   unsigned int n;
922   
923   for (n=0; n < nblocks; n++ )
924     {
925       c->cipher->encrypt ( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
926       inbuf  += c->cipher->blocksize;
927       outbuf += c->cipher->blocksize;
928     }
929 }
930
931 static void
932 do_ecb_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
933                 unsigned int nblocks )
934 {
935   unsigned int n;
936
937   for (n=0; n < nblocks; n++ ) 
938     {
939       c->cipher->decrypt ( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
940       inbuf  += c->cipher->blocksize;
941       outbuf += c->cipher->blocksize;
942     }
943 }
944
945
946 static void
947 do_cbc_encrypt (gcry_cipher_hd_t c, unsigned char *outbuf, 
948                 const unsigned char *inbuf, unsigned int nbytes )
949 {
950   unsigned int n;
951   unsigned char *ivp;
952   int i;
953   size_t blocksize = c->cipher->blocksize;
954   unsigned nblocks = nbytes / blocksize;
955
956   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) 
957     {
958       if ((nbytes % blocksize) == 0)
959         nblocks--;
960     }
961
962   if (c->bulk.cbc_enc)
963     {
964       c->bulk.cbc_enc (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks,
965                        (c->flags & GCRY_CIPHER_CBC_MAC)); 
966       inbuf  += nblocks * blocksize;
967       if (!(c->flags & GCRY_CIPHER_CBC_MAC))
968         outbuf += nblocks * blocksize;
969     }
970   else
971     {
972       for (n=0; n < nblocks; n++ )
973         {
974           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
975             outbuf[i] = inbuf[i] ^ *ivp++;
976           c->cipher->encrypt ( &c->context.c, outbuf, outbuf );
977           memcpy (c->u_iv.iv, outbuf, blocksize );
978           inbuf  += blocksize;
979           if (!(c->flags & GCRY_CIPHER_CBC_MAC))
980             outbuf += blocksize;
981         }
982     }
983
984   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize)
985     {
986       /* We have to be careful here, since outbuf might be equal to
987          inbuf.  */
988       int restbytes;
989       unsigned char b;
990
991       if ((nbytes % blocksize) == 0)
992         restbytes = blocksize;
993       else
994         restbytes = nbytes % blocksize;
995
996       outbuf -= blocksize;
997       for (ivp = c->u_iv.iv, i = 0; i < restbytes; i++)
998         {
999           b = inbuf[i];
1000           outbuf[blocksize + i] = outbuf[i];
1001           outbuf[i] = b ^ *ivp++;
1002         }
1003       for (; i < blocksize; i++)
1004         outbuf[i] = 0 ^ *ivp++;
1005       
1006       c->cipher->encrypt (&c->context.c, outbuf, outbuf);
1007       memcpy (c->u_iv.iv, outbuf, blocksize);
1008     }
1009 }
1010
1011
1012 static void
1013 do_cbc_decrypt (gcry_cipher_hd_t c, unsigned char *outbuf, 
1014                 const unsigned char *inbuf, unsigned int nbytes)
1015 {
1016   unsigned int n;
1017   unsigned char *ivp;
1018   int i;
1019   size_t blocksize = c->cipher->blocksize;
1020   unsigned int nblocks = nbytes / blocksize;
1021
1022   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize)
1023     {
1024       nblocks--;
1025       if ((nbytes % blocksize) == 0)
1026         nblocks--;
1027       memcpy (c->lastiv, c->u_iv.iv, blocksize);
1028     }
1029
1030   if (c->bulk.cbc_dec)
1031     {
1032       c->bulk.cbc_dec (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1033       inbuf  += nblocks * blocksize;
1034       outbuf += nblocks * blocksize;
1035     }
1036   else
1037     {
1038       for (n=0; n < nblocks; n++ ) 
1039         {
1040           /* Because outbuf and inbuf might be the same, we have to
1041            * save the original ciphertext block.  We use LASTIV for
1042            * this here because it is not used otherwise. */
1043           memcpy (c->lastiv, inbuf, blocksize);
1044           c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
1045           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1046             outbuf[i] ^= *ivp++;
1047           memcpy(c->u_iv.iv, c->lastiv, blocksize );
1048           inbuf  += c->cipher->blocksize;
1049           outbuf += c->cipher->blocksize;
1050         }
1051     }
1052
1053   if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) 
1054     {
1055       int restbytes;
1056       
1057       if ((nbytes % blocksize) == 0)
1058         restbytes = blocksize;
1059       else
1060         restbytes = nbytes % blocksize;
1061       
1062       memcpy (c->lastiv, c->u_iv.iv, blocksize );         /* Save Cn-2. */
1063       memcpy (c->u_iv.iv, inbuf + blocksize, restbytes ); /* Save Cn. */
1064
1065       c->cipher->decrypt ( &c->context.c, outbuf, inbuf );
1066       for (ivp=c->u_iv.iv,i=0; i < restbytes; i++ )
1067         outbuf[i] ^= *ivp++;
1068       
1069       memcpy(outbuf + blocksize, outbuf, restbytes);
1070       for(i=restbytes; i < blocksize; i++)
1071         c->u_iv.iv[i] = outbuf[i];
1072       c->cipher->decrypt (&c->context.c, outbuf, c->u_iv.iv);
1073       for(ivp=c->lastiv,i=0; i < blocksize; i++ )
1074         outbuf[i] ^= *ivp++;
1075       /* c->lastiv is now really lastlastiv, does this matter? */
1076     }
1077 }
1078
1079
1080 static void
1081 do_cfb_encrypt( gcry_cipher_hd_t c, unsigned char *outbuf, 
1082                 const unsigned char *inbuf, unsigned int nbytes )
1083 {
1084   unsigned char *ivp;
1085   size_t blocksize = c->cipher->blocksize;
1086   size_t blocksize_x_2 = blocksize + blocksize;
1087   
1088   if ( nbytes <= c->unused )
1089     {
1090       /* Short enough to be encoded by the remaining XOR mask. */
1091       /* XOR the input with the IV and store input into IV. */
1092       for (ivp=c->u_iv.iv+c->cipher->blocksize - c->unused;
1093            nbytes;
1094            nbytes--, c->unused-- )
1095         *outbuf++ = (*ivp++ ^= *inbuf++);
1096       return;
1097     }
1098
1099   if ( c->unused )
1100     {
1101       /* XOR the input with the IV and store input into IV */
1102       nbytes -= c->unused;
1103       for(ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1104         *outbuf++ = (*ivp++ ^= *inbuf++);
1105     }
1106
1107   /* Now we can process complete blocks.  We use a loop as long as we
1108      have at least 2 blocks and use conditions for the rest.  This
1109      also allows to use a bulk encryption function if available.  */
1110   if (nbytes >= blocksize_x_2 && c->bulk.cfb_enc)
1111     {
1112       unsigned int nblocks = nbytes / blocksize;
1113       c->bulk.cfb_enc (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1114       outbuf += nblocks * blocksize;
1115       inbuf  += nblocks * blocksize;
1116       nbytes -= nblocks * blocksize;
1117     }
1118   else
1119     {
1120       while ( nbytes >= blocksize_x_2 )
1121         {
1122           int i;
1123           /* Encrypt the IV. */
1124           c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1125           /* XOR the input with the IV and store input into IV.  */
1126           for(ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1127             *outbuf++ = (*ivp++ ^= *inbuf++);
1128           nbytes -= blocksize;
1129         }
1130     }
1131
1132   if ( nbytes >= blocksize )
1133     {
1134       int i;
1135       /* Save the current IV and then encrypt the IV. */
1136       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1137       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1138       /* XOR the input with the IV and store input into IV */
1139       for(ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1140         *outbuf++ = (*ivp++ ^= *inbuf++);
1141       nbytes -= blocksize;
1142     }
1143   if ( nbytes ) 
1144     {
1145       /* Save the current IV and then encrypt the IV. */
1146       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1147       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1148       c->unused = blocksize;
1149       /* Apply the XOR. */
1150       c->unused -= nbytes;
1151       for(ivp=c->u_iv.iv; nbytes; nbytes-- )
1152         *outbuf++ = (*ivp++ ^= *inbuf++);
1153     }
1154 }
1155
1156
1157 static void
1158 do_cfb_decrypt( gcry_cipher_hd_t c, unsigned char *outbuf, 
1159                 const unsigned char *inbuf, unsigned int nbytes )
1160 {
1161   unsigned char *ivp;
1162   unsigned long temp;
1163   int i;
1164   size_t blocksize = c->cipher->blocksize;
1165   size_t blocksize_x_2 = blocksize + blocksize;
1166   
1167   if (nbytes <= c->unused)
1168     {
1169       /* Short enough to be encoded by the remaining XOR mask. */
1170       /* XOR the input with the IV and store input into IV. */
1171       for (ivp=c->u_iv.iv+blocksize - c->unused;
1172            nbytes; 
1173            nbytes--, c->unused--)
1174         {
1175           temp = *inbuf++;
1176           *outbuf++ = *ivp ^ temp;
1177           *ivp++ = temp;
1178         }
1179       return;
1180     }
1181   
1182   if (c->unused)
1183     {
1184       /* XOR the input with the IV and store input into IV. */
1185       nbytes -= c->unused;
1186       for (ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1187         {
1188           temp = *inbuf++;
1189           *outbuf++ = *ivp ^ temp;
1190           *ivp++ = temp;
1191         }
1192     }
1193   
1194   /* Now we can process complete blocks.  We use a loop as long as we
1195      have at least 2 blocks and use conditions for the rest.  This
1196      also allows to use a bulk encryption function if available.  */
1197   if (nbytes >= blocksize_x_2 && c->bulk.cfb_dec)
1198     {
1199       unsigned int nblocks = nbytes / blocksize;
1200       c->bulk.cfb_dec (&c->context.c, c->u_iv.iv, outbuf, inbuf, nblocks); 
1201       outbuf += nblocks * blocksize;
1202       inbuf  += nblocks * blocksize;
1203       nbytes -= nblocks * blocksize;
1204     }
1205   else
1206     {
1207       while (nbytes >= blocksize_x_2 )
1208         {
1209           /* Encrypt the IV. */
1210           c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1211           /* XOR the input with the IV and store input into IV. */
1212           for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1213             {
1214               temp = *inbuf++;
1215               *outbuf++ = *ivp ^ temp;
1216               *ivp++ = temp;
1217             }
1218           nbytes -= blocksize;
1219         }
1220     }
1221
1222   if (nbytes >= blocksize )
1223     {
1224       /* Save the current IV and then encrypt the IV. */
1225       memcpy ( c->lastiv, c->u_iv.iv, blocksize);
1226       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1227       /* XOR the input with the IV and store input into IV */
1228       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1229         {
1230           temp = *inbuf++;
1231           *outbuf++ = *ivp ^ temp;
1232           *ivp++ = temp;
1233         }
1234       nbytes -= blocksize;
1235     }
1236
1237   if (nbytes)
1238     { 
1239       /* Save the current IV and then encrypt the IV. */
1240       memcpy ( c->lastiv, c->u_iv.iv, blocksize );
1241       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1242       c->unused = blocksize;
1243       /* Apply the XOR. */
1244       c->unused -= nbytes;
1245       for (ivp=c->u_iv.iv; nbytes; nbytes-- )
1246         {
1247           temp = *inbuf++;
1248           *outbuf++ = *ivp ^ temp;
1249           *ivp++ = temp;
1250         }
1251     }
1252 }
1253
1254
1255 static void
1256 do_ofb_encrypt( gcry_cipher_hd_t c,
1257                 byte *outbuf, const byte *inbuf, unsigned nbytes )
1258 {
1259   byte *ivp;
1260   size_t blocksize = c->cipher->blocksize;
1261
1262   if ( nbytes <= c->unused )
1263     {
1264       /* Short enough to be encoded by the remaining XOR mask. */
1265       /* XOR the input with the IV */
1266       for (ivp=c->u_iv.iv+c->cipher->blocksize - c->unused;
1267            nbytes;
1268            nbytes--, c->unused-- )
1269         *outbuf++ = (*ivp++ ^ *inbuf++);
1270       return;
1271     }
1272
1273   if( c->unused )
1274     {
1275       nbytes -= c->unused;
1276       for(ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1277         *outbuf++ = (*ivp++ ^ *inbuf++);
1278     }
1279
1280   /* Now we can process complete blocks. */
1281   while ( nbytes >= blocksize )
1282     {
1283       int i;
1284       /* Encrypt the IV (and save the current one). */
1285       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1286       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1287       
1288       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1289         *outbuf++ = (*ivp++ ^ *inbuf++);
1290       nbytes -= blocksize;
1291     }
1292   if ( nbytes )
1293     { /* process the remaining bytes */
1294       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1295       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1296       c->unused = blocksize;
1297       c->unused -= nbytes;
1298       for(ivp=c->u_iv.iv; nbytes; nbytes-- )
1299         *outbuf++ = (*ivp++ ^ *inbuf++);
1300     }
1301 }
1302
1303 static void
1304 do_ofb_decrypt( gcry_cipher_hd_t c,
1305                 byte *outbuf, const byte *inbuf, unsigned int nbytes )
1306 {
1307   byte *ivp;
1308   size_t blocksize = c->cipher->blocksize;
1309   
1310   if( nbytes <= c->unused )
1311     {
1312       /* Short enough to be encoded by the remaining XOR mask. */
1313       for (ivp=c->u_iv.iv+blocksize - c->unused; nbytes; nbytes--,c->unused--)
1314         *outbuf++ = *ivp++ ^ *inbuf++;
1315       return;
1316     }
1317
1318   if ( c->unused )
1319     {
1320       nbytes -= c->unused;
1321       for (ivp=c->u_iv.iv+blocksize - c->unused; c->unused; c->unused-- )
1322         *outbuf++ = *ivp++ ^ *inbuf++;
1323     }
1324
1325   /* Now we can process complete blocks. */
1326   while ( nbytes >= blocksize )
1327     {
1328       int i;
1329       /* Encrypt the IV (and save the current one). */
1330       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1331       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1332       for (ivp=c->u_iv.iv,i=0; i < blocksize; i++ )
1333         *outbuf++ = *ivp++ ^ *inbuf++;
1334       nbytes -= blocksize;
1335     }
1336   if ( nbytes ) 
1337     { /* Process the remaining bytes. */
1338       /* Encrypt the IV (and save the current one). */
1339       memcpy( c->lastiv, c->u_iv.iv, blocksize );
1340       c->cipher->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
1341       c->unused = blocksize;
1342       c->unused -= nbytes;
1343       for (ivp=c->u_iv.iv; nbytes; nbytes-- )
1344         *outbuf++ = *ivp++ ^ *inbuf++;
1345     }
1346 }
1347
1348
1349 static void
1350 do_ctr_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1351                 unsigned int nbytes )
1352 {
1353   unsigned int n;
1354   byte tmp[MAX_BLOCKSIZE];
1355   int i;
1356
1357   for(n=0; n < nbytes; n++)
1358     {
1359       if ((n % c->cipher->blocksize) == 0)
1360         {
1361           c->cipher->encrypt (&c->context.c, tmp, c->ctr);
1362
1363           for (i = c->cipher->blocksize; i > 0; i--)
1364             {
1365               c->ctr[i-1]++;
1366               if (c->ctr[i-1] != 0)
1367                 break;
1368             }
1369         }
1370
1371       /* XOR input with encrypted counter and store in output. */
1372       outbuf[n] = inbuf[n] ^ tmp[n % c->cipher->blocksize];
1373     }
1374 }
1375
1376 static void
1377 do_ctr_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1378                 unsigned int nbytes )
1379 {
1380   do_ctr_encrypt (c, outbuf, inbuf, nbytes);
1381 }
1382
1383
1384 /****************
1385  * Encrypt INBUF to OUTBUF with the mode selected at open.
1386  * inbuf and outbuf may overlap or be the same.
1387  * Depending on the mode some contraints apply to NBYTES.
1388  */
1389 static gcry_err_code_t
1390 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf,
1391                 const byte *inbuf, unsigned int nbytes)
1392 {
1393     gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1394
1395     switch( c->mode ) {
1396       case GCRY_CIPHER_MODE_ECB:
1397         if (!(nbytes%c->cipher->blocksize))
1398             do_ecb_encrypt(c, outbuf, inbuf, nbytes/c->cipher->blocksize );
1399         else 
1400             rc = GPG_ERR_INV_ARG;
1401         break;
1402       case GCRY_CIPHER_MODE_CBC:
1403         if (!(nbytes%c->cipher->blocksize)
1404             || (nbytes > c->cipher->blocksize
1405                 && (c->flags & GCRY_CIPHER_CBC_CTS)))
1406             do_cbc_encrypt(c, outbuf, inbuf, nbytes );
1407         else 
1408             rc = GPG_ERR_INV_ARG;
1409         break;
1410       case GCRY_CIPHER_MODE_CFB:
1411         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
1412         break;
1413       case GCRY_CIPHER_MODE_OFB:
1414         do_ofb_encrypt(c, outbuf, inbuf, nbytes );
1415         break;
1416       case GCRY_CIPHER_MODE_CTR:
1417         do_ctr_encrypt(c, outbuf, inbuf, nbytes );
1418         break;
1419       case GCRY_CIPHER_MODE_STREAM:
1420         c->cipher->stencrypt ( &c->context.c,
1421                                outbuf, (byte*)/*arggg*/inbuf, nbytes );
1422         break;
1423       case GCRY_CIPHER_MODE_NONE:
1424         if( inbuf != outbuf )
1425             memmove( outbuf, inbuf, nbytes );
1426         break;
1427       default:
1428         log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
1429         rc = GPG_ERR_INV_CIPHER_MODE;
1430         break;
1431     }
1432     return rc;
1433 }
1434
1435
1436 /****************
1437  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
1438  * been requested.
1439  */
1440 gcry_error_t
1441 gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1442                      const void *in, size_t inlen)
1443 {
1444   gcry_err_code_t err;
1445
1446   if (!in)
1447     {
1448       /* Caller requested in-place encryption. */
1449       /* Actually cipher_encrypt() does not need to know about it, but
1450        * we may change it in the future to get better performance.  */
1451       err = cipher_encrypt (h, out, out, outsize);
1452     }
1453   else if (outsize < ((h->flags & GCRY_CIPHER_CBC_MAC) ?
1454                       h->cipher->blocksize : inlen))
1455     err = GPG_ERR_TOO_SHORT;
1456   else if ((h->mode == GCRY_CIPHER_MODE_ECB
1457             || (h->mode == GCRY_CIPHER_MODE_CBC
1458                 && (! ((h->flags & GCRY_CIPHER_CBC_CTS)
1459                        && (inlen > h->cipher->blocksize)))))
1460            && (inlen % h->cipher->blocksize))
1461     err = GPG_ERR_INV_ARG;
1462   else
1463     err = cipher_encrypt (h, out, in, inlen);
1464
1465   if (err && out)
1466     memset (out, 0x42, outsize); /* Failsafe: Make sure that the
1467                                     plaintext will never make it into
1468                                     OUT. */
1469
1470   return gcry_error (err);
1471 }
1472
1473
1474
1475 /****************
1476  * Decrypt INBUF to OUTBUF with the mode selected at open.
1477  * inbuf and outbuf may overlap or be the same.
1478  * Depending on the mode some some contraints apply to NBYTES.
1479  */
1480 static gcry_err_code_t
1481 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1482                 unsigned int nbytes)
1483 {
1484     gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1485
1486     switch( c->mode ) {
1487       case GCRY_CIPHER_MODE_ECB:
1488         if (!(nbytes%c->cipher->blocksize))
1489             do_ecb_decrypt(c, outbuf, inbuf, nbytes/c->cipher->blocksize );
1490         else 
1491             rc = GPG_ERR_INV_ARG;
1492         break;
1493       case GCRY_CIPHER_MODE_CBC:
1494         if (!(nbytes%c->cipher->blocksize)
1495             || (nbytes > c->cipher->blocksize
1496                 && (c->flags & GCRY_CIPHER_CBC_CTS)))
1497             do_cbc_decrypt(c, outbuf, inbuf, nbytes );
1498         else 
1499             rc = GPG_ERR_INV_ARG;
1500         break;
1501       case GCRY_CIPHER_MODE_CFB:
1502         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
1503         break;
1504       case GCRY_CIPHER_MODE_OFB:
1505         do_ofb_decrypt(c, outbuf, inbuf, nbytes );
1506         break;
1507       case GCRY_CIPHER_MODE_CTR:
1508         do_ctr_decrypt(c, outbuf, inbuf, nbytes );
1509         break;
1510       case GCRY_CIPHER_MODE_STREAM:
1511         c->cipher->stdecrypt ( &c->context.c,
1512                                outbuf, (byte*)/*arggg*/inbuf, nbytes );
1513         break;
1514       case GCRY_CIPHER_MODE_NONE:
1515         if( inbuf != outbuf )
1516             memmove( outbuf, inbuf, nbytes );
1517         break;
1518       default:
1519         log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1520         rc = GPG_ERR_INV_CIPHER_MODE;
1521         break;
1522     }
1523     return rc;
1524 }
1525
1526
1527 gcry_error_t
1528 gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1529                      const void *in, size_t inlen)
1530 {
1531   gcry_err_code_t err = 0;
1532
1533   if (!in)
1534     {
1535       /* Caller requested in-place encryption. */
1536       /* Actually cipher_encrypt() does not need to know about it, but
1537        * we may change it in the future to get better performance.  */
1538       err = cipher_decrypt (h, out, out, outsize);
1539     }
1540   else if (outsize < inlen)
1541     err = GPG_ERR_TOO_SHORT;
1542   else if (((h->mode == GCRY_CIPHER_MODE_ECB)
1543             || ((h->mode == GCRY_CIPHER_MODE_CBC)
1544                 && (! ((h->flags & GCRY_CIPHER_CBC_CTS)
1545                        && (inlen > h->cipher->blocksize)))))
1546            && (inlen % h->cipher->blocksize) != 0)
1547     err = GPG_ERR_INV_ARG;
1548   else
1549     err = cipher_decrypt (h, out, in, inlen);
1550
1551   return gcry_error (err);
1552 }
1553
1554
1555
1556 /****************
1557  * Used for PGP's somewhat strange CFB mode. Only works if
1558  * the corresponding flag is set.
1559  */
1560 static void
1561 cipher_sync (gcry_cipher_hd_t c)
1562 {
1563   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1564     {
1565       memmove (c->u_iv.iv + c->unused,
1566                c->u_iv.iv, c->cipher->blocksize - c->unused);
1567       memcpy (c->u_iv.iv,
1568               c->lastiv + c->cipher->blocksize - c->unused, c->unused);
1569       c->unused = 0;
1570     }
1571 }
1572
1573
1574 gcry_error_t
1575 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
1576 {
1577   return cipher_setkey (hd, (void*)key, keylen);
1578 }
1579
1580
1581 gcry_error_t
1582 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
1583 {
1584   cipher_setiv (hd, iv, ivlen);
1585   return 0;
1586 }
1587
1588 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1589    block size length, or (NULL,0) to set the CTR to the all-zero
1590    block. */
1591 gpg_error_t
1592 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1593 {
1594   if (ctr && ctrlen == hd->cipher->blocksize)
1595     memcpy (hd->ctr, ctr, hd->cipher->blocksize);
1596   else if (!ctr || !ctrlen)
1597     memset (hd->ctr, 0, hd->cipher->blocksize);
1598   else
1599     return gpg_error (GPG_ERR_INV_ARG);
1600   return 0;
1601 }
1602
1603
1604 gcry_error_t
1605 gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1606 {
1607   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1608
1609   switch (cmd)
1610     {
1611     case GCRYCTL_SET_KEY:  /* Deprecated; use gcry_cipher_setkey.  */
1612       rc = cipher_setkey( h, buffer, buflen );
1613       break;
1614
1615     case GCRYCTL_SET_IV:   /* Deprecated; use gcry_cipher_setiv.  */
1616       cipher_setiv( h, buffer, buflen );
1617       break;
1618
1619     case GCRYCTL_RESET:
1620       cipher_reset (h);
1621       break;
1622
1623     case GCRYCTL_CFB_SYNC:
1624       cipher_sync( h );
1625       break;
1626
1627     case GCRYCTL_SET_CBC_CTS:
1628       if (buflen)
1629         if (h->flags & GCRY_CIPHER_CBC_MAC)
1630           rc = GPG_ERR_INV_FLAG;
1631         else
1632           h->flags |= GCRY_CIPHER_CBC_CTS;
1633       else
1634         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1635       break;
1636
1637     case GCRYCTL_SET_CBC_MAC:
1638       if (buflen)
1639         if (h->flags & GCRY_CIPHER_CBC_CTS)
1640           rc = GPG_ERR_INV_FLAG;
1641         else
1642           h->flags |= GCRY_CIPHER_CBC_MAC;
1643       else
1644         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1645       break;
1646
1647     case GCRYCTL_DISABLE_ALGO:
1648       /* This command expects NULL for H and BUFFER to point to an
1649          integer with the algo number.  */
1650       if( h || !buffer || buflen != sizeof(int) )
1651         return gcry_error (GPG_ERR_CIPHER_ALGO);
1652       disable_cipher_algo( *(int*)buffer );
1653       break;
1654
1655     case GCRYCTL_SET_CTR: /* Deprecated; use gcry_cipher_setctr.  */
1656       if (buffer && buflen == h->cipher->blocksize)
1657         memcpy (h->ctr, buffer, h->cipher->blocksize);
1658       else if (buffer == NULL || buflen == 0)
1659         memset (h->ctr, 0, h->cipher->blocksize);
1660       else
1661         rc = GPG_ERR_INV_ARG;
1662       break;
1663
1664     default:
1665       rc = GPG_ERR_INV_OP;
1666     }
1667
1668   return gcry_error (rc);
1669 }
1670
1671
1672 /* Return information about the cipher handle H.  CMD is the kind of
1673    information requested.  BUFFER and NBYTES are reserved for now.
1674
1675    There are no values for CMD yet defined.  
1676
1677    The fucntion always returns GPG_ERR_INV_OP.
1678    
1679  */
1680 gcry_error_t
1681 gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1682 {
1683   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1684
1685   (void)h;
1686   (void)buffer;
1687   (void)nbytes;
1688
1689   switch (cmd)
1690     {
1691     default:
1692       err = GPG_ERR_INV_OP;
1693     }
1694
1695   return gcry_error (err);
1696 }
1697
1698 /* Return information about the given cipher algorithm ALGO.
1699
1700    WHAT select the kind of information returned:
1701
1702     GCRYCTL_GET_KEYLEN:
1703         Return the length of the key.  If the algorithm ALGO
1704         supports multiple key lengths, the maximum supported key length
1705         is returned.  The key length is returned as number of octets.
1706         BUFFER and NBYTES must be zero.
1707
1708     GCRYCTL_GET_BLKLEN:
1709         Return the blocklength of the algorithm ALGO counted in octets.
1710         BUFFER and NBYTES must be zero.
1711
1712     GCRYCTL_TEST_ALGO:
1713         Returns 0 if the specified algorithm ALGO is available for use.
1714         BUFFER and NBYTES must be zero.
1715   
1716    Note: Because this function is in most cases used to return an
1717    integer value, we can make it easier for the caller to just look at
1718    the return value.  The caller will in all cases consult the value
1719    and thereby detecting whether a error occured or not (i.e. while
1720    checking the block size)
1721  */
1722 gcry_error_t
1723 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1724 {
1725   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1726   unsigned int ui;
1727
1728   switch (what)
1729     {
1730     case GCRYCTL_GET_KEYLEN:
1731       if (buffer || (! nbytes))
1732         err = GPG_ERR_CIPHER_ALGO;
1733       else
1734         {
1735           ui = cipher_get_keylen (algo);
1736           if ((ui > 0) && (ui <= 512))
1737             *nbytes = (size_t) ui / 8;
1738           else
1739             /* The only reason is an invalid algo or a strange
1740                blocksize.  */
1741             err = GPG_ERR_CIPHER_ALGO;
1742         }
1743       break;
1744
1745     case GCRYCTL_GET_BLKLEN:
1746       if (buffer || (! nbytes))
1747         err = GPG_ERR_CIPHER_ALGO;
1748       else
1749         {
1750           ui = cipher_get_blocksize (algo);
1751           if ((ui > 0) && (ui < 10000))
1752             *nbytes = ui;
1753           else
1754             /* The only reason is an invalid algo or a strange
1755                blocksize.  */
1756             err = GPG_ERR_CIPHER_ALGO;
1757         }
1758       break;
1759
1760     case GCRYCTL_TEST_ALGO:
1761       if (buffer || nbytes)
1762         err = GPG_ERR_INV_ARG;
1763       else
1764         err = check_cipher_algo (algo);
1765       break;
1766
1767       default:
1768         err = GPG_ERR_INV_OP;
1769     }
1770
1771   return gcry_error (err);
1772 }
1773
1774
1775 /* This function returns length of the key for algorithm ALGO.  If the
1776    algorithm supports multiple key lengths, the maximum supported key
1777    length is returned.  On error 0 is returned.  The key length is
1778    returned as number of octets.
1779
1780    This is a convenience functions which should be preferred over
1781    gcry_cipher_algo_info because it allows for proper type
1782    checking.  */
1783 size_t
1784 gcry_cipher_get_algo_keylen (int algo) 
1785 {
1786   size_t n;
1787
1788   if (gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1789     n = 0;
1790   return n;
1791 }
1792
1793 /* This functions returns the blocklength of the algorithm ALGO
1794    counted in octets.  On error 0 is returned.
1795
1796    This is a convenience functions which should be preferred over
1797    gcry_cipher_algo_info because it allows for proper type
1798    checking.  */
1799 size_t
1800 gcry_cipher_get_algo_blklen (int algo) 
1801 {
1802   size_t n;
1803
1804   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1805     n = 0;
1806   return n;
1807 }
1808
1809 /* Explicitly initialize this module.  */
1810 gcry_err_code_t
1811 _gcry_cipher_init (void)
1812 {
1813   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1814
1815   REGISTER_DEFAULT_CIPHERS;
1816
1817   return err;
1818 }
1819
1820 /* Get a list consisting of the IDs of the loaded cipher modules.  If
1821    LIST is zero, write the number of loaded cipher modules to
1822    LIST_LENGTH and return.  If LIST is non-zero, the first
1823    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
1824    according size.  In case there are less cipher modules than
1825    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
1826 gcry_error_t
1827 gcry_cipher_list (int *list, int *list_length)
1828 {
1829   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1830
1831   ath_mutex_lock (&ciphers_registered_lock);
1832   err = _gcry_module_list (ciphers_registered, list, list_length);
1833   ath_mutex_unlock (&ciphers_registered_lock);
1834
1835   return err;
1836 }
1837
1838
1839 /* Run the selftests for cipher algorithm ALGO with optional reporting
1840    function REPORT.  */
1841 gpg_error_t
1842 _gcry_cipher_selftest (int algo, selftest_report_func_t report)
1843 {
1844   gcry_module_t module = NULL;
1845   cipher_extra_spec_t *extraspec = NULL;
1846   gcry_err_code_t ec = 0;
1847
1848   REGISTER_DEFAULT_CIPHERS;
1849
1850   ath_mutex_lock (&ciphers_registered_lock);
1851   module = _gcry_module_lookup_id (ciphers_registered, algo);
1852   if (module && !(module->flags & FLAG_MODULE_DISABLED))
1853     extraspec = module->extraspec;
1854   ath_mutex_unlock (&ciphers_registered_lock);
1855   if (extraspec && extraspec->selftest)
1856     ec = extraspec->selftest (algo, report);
1857   else
1858     {
1859       ec = GPG_ERR_CIPHER_ALGO;
1860       if (report)
1861         report ("cipher", algo, "module", 
1862                 module && !(module->flags & FLAG_MODULE_DISABLED)?
1863                 "no selftest available" :
1864                 module? "algorithm disabled" : "algorithm not found");
1865     }
1866
1867   if (module)
1868     {
1869       ath_mutex_lock (&ciphers_registered_lock);
1870       _gcry_module_release (module);
1871       ath_mutex_unlock (&ciphers_registered_lock);
1872     }
1873   return gpg_error (ec);
1874 }