* global.c (gcry_control): Add GCRYCTL_SET_RANDOM_SEED_FILE and
[libgcrypt.git] / cipher / cipher.c
1 /* cipher.c  -  cipher dispatcher
2  * Copyright (C) 1998,1999,2000,2001,2002,2003 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser general Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "g10lib.h"
29 #include "cipher.h"
30 #include "ath.h"
31
32 #define MAX_BLOCKSIZE 16
33 #define TABLE_SIZE 14
34 #define CTX_MAGIC_NORMAL 0x24091964
35 #define CTX_MAGIC_SECURE 0x46919042
36
37 /* This is the list of the default ciphers, which are included in
38    libgcrypt.  */
39 static struct cipher_table_entry
40 {
41   gcry_cipher_spec_t *cipher;
42   unsigned int algorithm;
43 } cipher_table[] =
44   {
45 #if USE_BLOWFISH
46     { &cipher_spec_blowfish,   GCRY_CIPHER_BLOWFISH },
47 #endif
48 #if USE_DES
49     { &cipher_spec_des,        GCRY_CIPHER_DES },
50     { &cipher_spec_tripledes,  GCRY_CIPHER_3DES },
51 #endif
52 #if USE_ARCFOUR
53     { &cipher_spec_arcfour,    GCRY_CIPHER_ARCFOUR },
54 #endif
55 #if USE_CAST5
56     { &cipher_spec_cast5,      GCRY_CIPHER_CAST5 },
57 #endif
58 #if USE_AES
59     { &cipher_spec_aes,        GCRY_CIPHER_AES },
60     { &cipher_spec_aes192,     GCRY_CIPHER_AES192 },
61     { &cipher_spec_aes256,     GCRY_CIPHER_AES256 },
62 #endif
63 #if USE_TWOFISH
64     { &cipher_spec_twofish,    GCRY_CIPHER_TWOFISH },
65     { &cipher_spec_twofish128, GCRY_CIPHER_TWOFISH128 },
66 #endif
67     { NULL                    },
68   };
69
70 /* List of registered ciphers.  */
71 static gcry_module_t ciphers_registered;
72
73 /* This is the lock protecting CIPHERS_REGISTERED.  */
74 static ath_mutex_t ciphers_registered_lock = ATH_MUTEX_INITIALIZER;
75
76 /* Flag to check wether the default ciphers have already been
77    registered.  */
78 static int default_ciphers_registered;
79
80 /* Convenient macro for registering the default ciphers.  */
81 #define REGISTER_DEFAULT_CIPHERS                   \
82   do                                               \
83     {                                              \
84       ath_mutex_lock (&ciphers_registered_lock);   \
85       if (! default_ciphers_registered)            \
86         {                                          \
87           gcry_cipher_register_default ();         \
88           default_ciphers_registered = 1;          \
89         }                                          \
90       ath_mutex_unlock (&ciphers_registered_lock); \
91     }                                              \
92   while (0)
93
94 /* The handle structure.  */
95 struct gcry_cipher_handle
96 {
97   int magic;
98   gcry_cipher_spec_t *cipher;
99   gcry_module_t module;
100   int mode;
101   unsigned int flags;
102   byte iv[MAX_BLOCKSIZE];       /* (this should be ulong aligned) */
103   byte lastiv[MAX_BLOCKSIZE];
104   int unused;  /* in IV */
105   byte ctr[MAX_BLOCKSIZE];    /* for Counter (CTR) mode */
106   PROPERLY_ALIGNED_TYPE context;
107 };
108
109 /* These dummy functions are used in case a cipher implementation
110    refuses to provide it's own functions.  */
111
112 static gcry_err_code_t
113 dummy_setkey (void *c, const unsigned char *key, unsigned keylen)
114 {
115   return GPG_ERR_NO_ERROR;
116 }
117
118 static void
119 dummy_encrypt_block (void *c,
120                      unsigned char *outbuf, const unsigned char *inbuf)
121 {
122   BUG();
123 }
124
125 static void
126 dummy_decrypt_block (void *c,
127                      unsigned char *outbuf, const unsigned char *inbuf)
128 {
129   BUG();
130 }
131
132 static void
133 dummy_encrypt_stream (void *c,
134                       unsigned char *outbuf, const unsigned char *inbuf,
135                       unsigned int n)
136 {
137   BUG();
138 }
139
140 static void
141 dummy_decrypt_stream (void *c,
142                       unsigned char *outbuf, const unsigned char *inbuf,
143                       unsigned int n)
144 {
145   BUG();
146 }
147
148 /* Internal function.  Register all the ciphers included in
149    CIPHER_TABLE.  */
150 static void
151 gcry_cipher_register_default (void)
152 {
153   gcry_err_code_t err = GPG_ERR_NO_ERROR;
154   int i;
155   
156   for (i = 0; (! err) && cipher_table[i].cipher; i++)
157     {
158       if (! cipher_table[i].cipher->setkey)
159         cipher_table[i].cipher->setkey = dummy_setkey;
160       if (! cipher_table[i].cipher->encrypt)
161         cipher_table[i].cipher->encrypt = dummy_encrypt_block;
162       if (! cipher_table[i].cipher->decrypt)
163         cipher_table[i].cipher->decrypt = dummy_decrypt_block;
164       if (! cipher_table[i].cipher->stencrypt)
165         cipher_table[i].cipher->stencrypt = dummy_encrypt_stream;
166       if (! cipher_table[i].cipher->stdecrypt)
167         cipher_table[i].cipher->stdecrypt = dummy_decrypt_stream;
168
169       err = _gcry_module_add (&ciphers_registered,
170                               cipher_table[i].algorithm,
171                               (void *) cipher_table[i].cipher,
172                               NULL);
173     }
174
175   if (err)
176     BUG ();
177 }
178
179 /* Internal callback function.  Used via _gcry_module_lookup.  */
180 static int
181 gcry_cipher_lookup_func_name (void *spec, void *data)
182 {
183   gcry_cipher_spec_t *cipher = (gcry_cipher_spec_t *) spec;
184   char *name = (char *) data;
185   const char **aliases = cipher->aliases;
186   int i, ret = ! stricmp (name, cipher->name);
187
188   if (aliases)
189     for (i = 0; aliases[i] && (! ret); i++)
190       ret = ! stricmp (name, aliases[i]);
191
192   return ret;
193 }
194
195 /* Internal callback function.  Used via _gcry_module_lookup.  */
196 static int
197 gcry_cipher_lookup_func_oid (void *spec, void *data)
198 {
199   gcry_cipher_spec_t *cipher = (gcry_cipher_spec_t *) spec;
200   char *oid = (char *) data;
201   gcry_cipher_oid_spec_t *oid_specs = cipher->oids;
202   int ret = 0, i;
203
204   if (oid_specs)
205     for (i = 0; oid_specs[i].oid && (! ret); i++)
206       if (! stricmp (oid, oid_specs[i].oid))
207         ret = 1;
208
209   return ret;
210 }
211
212 /* Internal function.  Lookup a cipher entry by it's name.  */
213 static gcry_module_t
214 gcry_cipher_lookup_name (const char *name)
215 {
216   gcry_module_t cipher;
217
218   cipher = _gcry_module_lookup (ciphers_registered, (void *) name,
219                                 gcry_cipher_lookup_func_name);
220
221   return cipher;
222 }
223
224 /* Internal function.  Lookup a cipher entry by it's oid.  */
225 static gcry_module_t
226 gcry_cipher_lookup_oid (const char *oid)
227 {
228   gcry_module_t cipher;
229
230   cipher = _gcry_module_lookup (ciphers_registered, (void *) oid,
231                                 gcry_cipher_lookup_func_oid);
232
233   return cipher;
234 }
235
236 /* Register a new cipher module whose specification can be found in
237    CIPHER.  On success, a new algorithm ID is stored in ALGORITHM_ID
238    and a pointer representhing this module is stored in MODULE.  */
239 gcry_error_t
240 gcry_cipher_register (gcry_cipher_spec_t *cipher,
241                       unsigned int *algorithm_id,
242                       gcry_module_t *module)
243 {
244   gcry_err_code_t err = 0;
245   gcry_module_t mod;
246
247   ath_mutex_lock (&ciphers_registered_lock);
248   err = _gcry_module_add (&ciphers_registered, 0,
249                           (void *) cipher, &mod);
250   ath_mutex_unlock (&ciphers_registered_lock);
251
252   if (! err)
253     {
254       *module = mod;
255       *algorithm_id = mod->mod_id;
256     }
257
258   return gcry_error (err);
259 }
260
261 /* Unregister the cipher identified by MODULE, which must have been
262    registered with gcry_cipher_register.  */
263 void
264 gcry_cipher_unregister (gcry_module_t module)
265 {
266   ath_mutex_lock (&ciphers_registered_lock);
267   _gcry_module_release (module);
268   ath_mutex_unlock (&ciphers_registered_lock);
269 }
270
271 /* locate the OID in the oid table and return the index or -1 when not
272    found */
273 static int 
274 search_oid (const char *oid, int *algorithm, gcry_cipher_oid_spec_t *oid_spec)
275 {
276   gcry_module_t module;
277   int ret = 0;
278
279   if (oid && ((! strncmp (oid, "oid.", 4))
280               || (! strncmp (oid, "OID.", 4))))
281     oid += 4;
282
283   module = gcry_cipher_lookup_oid (oid);
284   if (module)
285     {
286       gcry_cipher_spec_t *cipher = module->spec;
287       int i;
288
289       for (i = 0; cipher->oids[i].oid && (! ret); i++)
290         if (! stricmp (oid, cipher->oids[i].oid))
291           {
292             if (algorithm)
293               *algorithm = module->mod_id;
294             if (oid_spec)
295               *oid_spec = cipher->oids[i];
296             ret = 1;
297           }
298       _gcry_module_release (module);
299     }
300
301   return ret;
302 }
303
304 /****************
305  * Map a string to the cipher algo.
306  * Returns: The algo ID of the cipher for the gioven name or
307  *          0 if the name is not known.
308  */
309 int
310 gcry_cipher_map_name (const char *string)
311 {
312   gcry_module_t cipher;
313   int ret, algorithm = 0;
314
315   if (! string)
316     return 0;
317
318   REGISTER_DEFAULT_CIPHERS;
319
320   /* If the string starts with a digit (optionally prefixed with
321      either "OID." or "oid."), we first look into our table of ASN.1
322      object identifiers to figure out the algorithm */
323
324   ath_mutex_lock (&ciphers_registered_lock);
325
326   ret = search_oid (string, &algorithm, NULL);
327   if (! ret)
328     {
329       cipher = gcry_cipher_lookup_name (string);
330       if (cipher)
331         {
332           algorithm = cipher->mod_id;
333           _gcry_module_release (cipher);
334         }
335     }
336
337   ath_mutex_unlock (&ciphers_registered_lock);
338   
339   return algorithm;
340 }
341
342 int
343 gcry_cipher_mode_from_oid (const char *string)
344 {
345   gcry_cipher_oid_spec_t oid_spec;
346   int ret = 0, mode = 0;
347
348   ath_mutex_lock (&ciphers_registered_lock);
349   ret = search_oid (string, NULL, &oid_spec);
350   if (ret)
351     mode = oid_spec.mode;
352   ath_mutex_unlock (&ciphers_registered_lock);
353
354   return mode;
355 }
356
357
358 /****************
359  * Map a cipher algo to a string
360  */
361 static const char *
362 cipher_algo_to_string (int algorithm)
363 {
364   gcry_module_t cipher;
365   const char *name = NULL;
366
367   REGISTER_DEFAULT_CIPHERS;
368
369   ath_mutex_lock (&ciphers_registered_lock);
370   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
371   if (cipher)
372     {
373       name = ((gcry_cipher_spec_t *) cipher->spec)->name;
374       _gcry_module_release (cipher);
375     }
376   ath_mutex_unlock (&ciphers_registered_lock);
377
378   return name;
379 }
380
381 /****************
382  * This function simply returns the name of the algorithm or some constant
383  * string when there is no algo.  It will never return NULL.
384  */
385 const char *
386 gcry_cipher_algo_name (int algorithm)
387 {
388   const char *s = cipher_algo_to_string (algorithm);
389   return s ? s : "";
390 }
391
392
393 static void
394 disable_cipher_algo (int algorithm)
395 {
396   gcry_module_t cipher;
397
398   REGISTER_DEFAULT_CIPHERS;
399
400   ath_mutex_lock (&ciphers_registered_lock);
401   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
402   if (cipher)
403     {
404       if (! (cipher->flags & FLAG_MODULE_DISABLED))
405         cipher->flags |= FLAG_MODULE_DISABLED;
406       _gcry_module_release (cipher);
407     }
408   ath_mutex_unlock (&ciphers_registered_lock);
409 }
410
411
412 /****************
413  * Return 0 if the cipher algo is available.
414  */
415
416 static gcry_err_code_t
417 check_cipher_algo (int algorithm)
418 {
419   gcry_err_code_t err = GPG_ERR_NO_ERROR;
420   gcry_module_t cipher;
421
422   REGISTER_DEFAULT_CIPHERS;
423
424   ath_mutex_lock (&ciphers_registered_lock);
425   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
426   if (cipher)
427     {
428       if (cipher->flags & FLAG_MODULE_DISABLED)
429         err = GPG_ERR_CIPHER_ALGO;
430       _gcry_module_release (cipher);
431     }
432   else
433     err = GPG_ERR_CIPHER_ALGO;
434   ath_mutex_unlock (&ciphers_registered_lock);
435   
436   return err;
437 }
438
439 static unsigned
440 cipher_get_keylen (int algorithm)
441 {
442   gcry_module_t cipher;
443   unsigned len = 0;
444
445   REGISTER_DEFAULT_CIPHERS;
446
447   ath_mutex_lock (&ciphers_registered_lock);
448   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
449   if (cipher)
450     {
451       len = ((gcry_cipher_spec_t *) cipher->spec)->keylen;
452       if (! len)
453         log_bug ("cipher %d w/o key length\n", algorithm);
454       _gcry_module_release (cipher);
455     }
456   else
457     log_bug ("cipher %d not found\n", algorithm);
458   ath_mutex_unlock (&ciphers_registered_lock);
459
460   return len;
461 }
462
463 static unsigned
464 cipher_get_blocksize (int algorithm)
465 {
466   gcry_module_t cipher;
467   unsigned len = 0;
468
469   REGISTER_DEFAULT_CIPHERS;
470
471   ath_mutex_lock (&ciphers_registered_lock);
472   cipher = _gcry_module_lookup_id (ciphers_registered, algorithm);
473   if (cipher)
474     {
475       len = ((gcry_cipher_spec_t *) cipher->spec)->blocksize;
476       if (! len)
477           log_bug ("cipher %d w/o blocksize\n", algorithm);
478       _gcry_module_release (cipher);
479     }
480   else
481     log_bug ("cipher %d not found\n", algorithm);
482   ath_mutex_unlock (&ciphers_registered_lock);
483
484   return len;
485 }
486
487
488 /****************
489  * Open a cipher handle for use with algorithm ALGO, in mode MODE and
490  * return the handle.  Put NULL into HANDLER and return and error code
491  * if something goes wrong.  */
492
493 gcry_error_t
494 gcry_cipher_open (gcry_cipher_hd_t *handle,
495                   int algo, int mode, unsigned int flags)
496 {
497   int secure = (flags & GCRY_CIPHER_SECURE);
498   gcry_cipher_spec_t *cipher = NULL;
499   gcry_module_t module = NULL;
500   gcry_cipher_hd_t h = NULL;
501   gcry_err_code_t err = 0;
502
503   _gcry_fast_random_poll();
504   
505   REGISTER_DEFAULT_CIPHERS;
506
507   /* Fetch the according module and check wether the cipher is marked
508      available for use.  */
509   ath_mutex_lock (&ciphers_registered_lock);
510   module = _gcry_module_lookup_id (ciphers_registered, algo);
511   if (module)
512     {
513       /* Found module.  */
514
515       if (module->flags & FLAG_MODULE_DISABLED)
516         {
517           /* Not available for use.  */
518           err = GPG_ERR_CIPHER_ALGO;
519           _gcry_module_release (module);
520         }
521       else
522         cipher = (gcry_cipher_spec_t *) module->spec;
523     }
524   else
525     err = GPG_ERR_CIPHER_ALGO;
526   ath_mutex_unlock (&ciphers_registered_lock);
527
528   /* check flags */
529   if ((! err)
530       && ((flags & ~(0 
531                      | GCRY_CIPHER_SECURE
532                      | GCRY_CIPHER_ENABLE_SYNC
533                      | GCRY_CIPHER_CBC_CTS
534                      | GCRY_CIPHER_CBC_MAC))
535           || (flags & GCRY_CIPHER_CBC_CTS & GCRY_CIPHER_CBC_MAC)))
536     err = GPG_ERR_CIPHER_ALGO;
537
538   /* check that a valid mode has been requested */
539   if (! err)
540     switch (mode)
541       {
542       case GCRY_CIPHER_MODE_ECB:
543       case GCRY_CIPHER_MODE_CBC:
544       case GCRY_CIPHER_MODE_CFB:
545       case GCRY_CIPHER_MODE_CTR:
546         if ((cipher->encrypt == dummy_encrypt_block)
547             || (cipher->decrypt == dummy_decrypt_block))
548           err = GPG_ERR_INV_CIPHER_MODE;
549         break;
550
551       case GCRY_CIPHER_MODE_STREAM:
552         if ((cipher->stencrypt == dummy_encrypt_stream)
553             || (cipher->stdecrypt == dummy_decrypt_stream))
554           err = GPG_ERR_INV_CIPHER_MODE;
555         break;
556
557       case GCRY_CIPHER_MODE_NONE:
558         /* FIXME: issue a warning when this mode is used */
559         break;
560
561       default:
562         err = GPG_ERR_INV_CIPHER_MODE;
563       }
564
565   /* ? FIXME: perform selftest here and mark this with a flag in
566      cipher_table ? */
567
568   if (! err)
569     {
570       size_t size = sizeof (*h)
571         + 2 * cipher->contextsize
572         - sizeof (PROPERLY_ALIGNED_TYPE);
573
574       if (secure)
575         h = gcry_calloc_secure (1, size);
576       else
577         h = gcry_calloc (1, size);
578
579       if (! h)
580         err = gpg_err_code_from_errno (errno);
581       else
582         {
583           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
584           h->cipher = cipher;
585           h->module = module;
586           h->mode = mode;
587           h->flags = flags;
588         }
589     }
590
591   /* Done.  */
592
593   if (err)
594     {
595       if (module)
596         {
597           /* Release module.  */
598           ath_mutex_lock (&ciphers_registered_lock);
599           _gcry_module_release (module);
600           ath_mutex_unlock (&ciphers_registered_lock);
601         }
602     }
603
604   *handle = err ? NULL : h;
605
606   return gcry_error (err);
607 }
608
609
610 void
611 gcry_cipher_close (gcry_cipher_hd_t h)
612 {
613   if (! h)
614     return;
615
616   if ((h->magic != CTX_MAGIC_SECURE)
617       && (h->magic != CTX_MAGIC_NORMAL))
618     _gcry_fatal_error(GPG_ERR_INTERNAL,
619                       "gcry_cipher_close: already closed/invalid handle");
620   else
621     h->magic = 0;
622
623   /* Release module.  */
624   ath_mutex_lock (&ciphers_registered_lock);
625   _gcry_module_release (h->module);
626   ath_mutex_unlock (&ciphers_registered_lock);
627
628   gcry_free (h);
629 }
630
631
632 static gcry_error_t
633 cipher_setkey (gcry_cipher_hd_t c, byte *key, unsigned keylen)
634 {
635   gcry_err_code_t ret;
636
637   ret = (*c->cipher->setkey) (&c->context.c, key, keylen);
638   if (! ret)
639     /* Duplicate initial context.  */
640     memcpy ((void *) ((char *) &c->context.c + c->cipher->contextsize),
641             (void *) &c->context.c,
642             c->cipher->contextsize);
643
644   return gcry_error (ret);
645 }
646
647
648 static void
649 cipher_setiv( gcry_cipher_hd_t c, const byte *iv, unsigned ivlen )
650 {
651     memset( c->iv, 0, c->cipher->blocksize );
652     if( iv ) {
653         if( ivlen != c->cipher->blocksize )
654             log_info("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
655                      ivlen, (unsigned) c->cipher->blocksize );
656         if (ivlen > c->cipher->blocksize)
657           ivlen = c->cipher->blocksize;
658         memcpy( c->iv, iv, ivlen );
659     }
660     c->unused = 0;
661 }
662
663
664 static void
665 cipher_reset (gcry_cipher_hd_t c)
666 {
667   memcpy ((void *) &c->context.c,
668           (void *) ((char *) &c->context.c + c->cipher->contextsize),
669           c->cipher->contextsize);
670   memset (c->iv, 0, c->cipher->blocksize);
671   memset (c->lastiv, 0, c->cipher->blocksize);
672   memset (c->ctr, 0, c->cipher->blocksize);
673 }
674
675
676 static void
677 do_ecb_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf, unsigned nblocks )
678 {
679     unsigned n;
680
681     for(n=0; n < nblocks; n++ ) {
682         (*c->cipher->encrypt)( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
683         inbuf  += c->cipher->blocksize;
684         outbuf += c->cipher->blocksize;
685     }
686 }
687
688 static void
689 do_ecb_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf, unsigned nblocks )
690 {
691     unsigned n;
692
693     for(n=0; n < nblocks; n++ ) {
694         (*c->cipher->decrypt)( &c->context.c, outbuf, (byte*)/*arggg*/inbuf );
695         inbuf  += c->cipher->blocksize;
696         outbuf += c->cipher->blocksize;
697     }
698 }
699
700 static void
701 do_cbc_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf, unsigned nbytes )
702 {
703     unsigned int n;
704     byte *ivp;
705     int i;
706     size_t blocksize = c->cipher->blocksize;
707     unsigned nblocks = nbytes / blocksize;
708
709     if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) {
710       if ((nbytes % blocksize) == 0)
711         nblocks--;
712     }
713
714     for(n=0; n < nblocks; n++ ) {
715         /* fixme: the xor should works on words and not on
716          * bytes.  Maybe it is a good idea to enhance the cipher backend
717          * API to allow for CBC handling in the backend */
718         for(ivp=c->iv,i=0; i < blocksize; i++ )
719             outbuf[i] = inbuf[i] ^ *ivp++;
720         (*c->cipher->encrypt)( &c->context.c, outbuf, outbuf );
721         memcpy(c->iv, outbuf, blocksize );
722         inbuf  += c->cipher->blocksize;
723         if (!(c->flags & GCRY_CIPHER_CBC_MAC))
724           outbuf += c->cipher->blocksize;
725     }
726
727     if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize)
728       {
729         int restbytes;
730
731         if ((nbytes % blocksize) == 0)
732           restbytes = blocksize;
733         else
734           restbytes = nbytes % blocksize;
735
736         memcpy(outbuf, outbuf - c->cipher->blocksize, restbytes);
737         outbuf -= c->cipher->blocksize;
738
739         for(ivp=c->iv,i=0; i < restbytes; i++ )
740             outbuf[i] = inbuf[i] ^ *ivp++;
741         for(; i < blocksize; i++ )
742             outbuf[i] = 0 ^ *ivp++;
743
744         (*c->cipher->encrypt)( &c->context.c, outbuf, outbuf );
745         memcpy(c->iv, outbuf, blocksize );
746       }
747 }
748
749 static void
750 do_cbc_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf, unsigned nbytes )
751 {
752     unsigned int n;
753     byte *ivp;
754     int i;
755     size_t blocksize = c->cipher->blocksize;
756     unsigned nblocks = nbytes / blocksize;
757
758     if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) {
759       nblocks--;
760       if ((nbytes % blocksize) == 0)
761         nblocks--;
762       memcpy(c->lastiv, c->iv, blocksize );
763     }
764
765     for(n=0; n < nblocks; n++ ) {
766         /* because outbuf and inbuf might be the same, we have
767          * to save the original ciphertext block.  We use lastiv
768          * for this here because it is not used otherwise */
769         memcpy(c->lastiv, inbuf, blocksize );
770         (*c->cipher->decrypt)( &c->context.c, outbuf, (char*)/*argggg*/inbuf );
771         for(ivp=c->iv,i=0; i < blocksize; i++ )
772             outbuf[i] ^= *ivp++;
773         memcpy(c->iv, c->lastiv, blocksize );
774         inbuf  += c->cipher->blocksize;
775         outbuf += c->cipher->blocksize;
776     }
777
778     if ((c->flags & GCRY_CIPHER_CBC_CTS) && nbytes > blocksize) {
779         int restbytes;
780
781         if ((nbytes % blocksize) == 0)
782           restbytes = blocksize;
783         else
784           restbytes = nbytes % blocksize;
785
786         memcpy(c->lastiv, c->iv, blocksize ); /* save Cn-2 */
787         memcpy(c->iv, inbuf + blocksize, restbytes ); /* save Cn */
788
789         (*c->cipher->decrypt)( &c->context.c, outbuf, (char*)/*argggg*/inbuf );
790         for(ivp=c->iv,i=0; i < restbytes; i++ )
791             outbuf[i] ^= *ivp++;
792
793         memcpy(outbuf + blocksize, outbuf, restbytes);
794         for(i=restbytes; i < blocksize; i++)
795           c->iv[i] = outbuf[i];
796         (*c->cipher->decrypt)( &c->context.c, outbuf, c->iv );
797         for(ivp=c->lastiv,i=0; i < blocksize; i++ )
798             outbuf[i] ^= *ivp++;
799         /* c->lastiv is now really lastlastiv, does this matter? */
800     }
801 }
802
803
804 static void
805 do_cfb_encrypt( gcry_cipher_hd_t c,
806                 byte *outbuf, const byte *inbuf, unsigned nbytes )
807 {
808     byte *ivp;
809     size_t blocksize = c->cipher->blocksize;
810
811     if( nbytes <= c->unused ) {
812         /* short enough to be encoded by the remaining XOR mask */
813         /* XOR the input with the IV and store input into IV */
814         for(ivp=c->iv+c->cipher->blocksize - c->unused; nbytes; nbytes--, c->unused-- )
815             *outbuf++ = (*ivp++ ^= *inbuf++);
816         return;
817     }
818
819     if( c->unused ) {
820         /* XOR the input with the IV and store input into IV */
821         nbytes -= c->unused;
822         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- )
823             *outbuf++ = (*ivp++ ^= *inbuf++);
824     }
825
826     /* now we can process complete blocks */
827     while( nbytes >= blocksize ) {
828         int i;
829         /* encrypt the IV (and save the current one) */
830         memcpy( c->lastiv, c->iv, blocksize );
831         (*c->cipher->encrypt)( &c->context.c, c->iv, c->iv );
832         /* XOR the input with the IV and store input into IV */
833         for(ivp=c->iv,i=0; i < blocksize; i++ )
834             *outbuf++ = (*ivp++ ^= *inbuf++);
835         nbytes -= blocksize;
836     }
837     if( nbytes ) { /* process the remaining bytes */
838         /* encrypt the IV (and save the current one) */
839         memcpy( c->lastiv, c->iv, blocksize );
840         (*c->cipher->encrypt)( &c->context.c, c->iv, c->iv );
841         c->unused = blocksize;
842         /* and apply the xor */
843         c->unused -= nbytes;
844         for(ivp=c->iv; nbytes; nbytes-- )
845             *outbuf++ = (*ivp++ ^= *inbuf++);
846     }
847 }
848
849 static void
850 do_cfb_decrypt( gcry_cipher_hd_t c,
851                 byte *outbuf, const byte *inbuf, unsigned nbytes )
852 {
853     byte *ivp;
854     ulong temp;
855     size_t blocksize = c->cipher->blocksize;
856
857     if( nbytes <= c->unused ) {
858         /* short enough to be encoded by the remaining XOR mask */
859         /* XOR the input with the IV and store input into IV */
860         for(ivp=c->iv+blocksize - c->unused; nbytes; nbytes--,c->unused--){
861             temp = *inbuf++;
862             *outbuf++ = *ivp ^ temp;
863             *ivp++ = temp;
864         }
865         return;
866     }
867
868     if( c->unused ) {
869         /* XOR the input with the IV and store input into IV */
870         nbytes -= c->unused;
871         for(ivp=c->iv+blocksize - c->unused; c->unused; c->unused-- ) {
872             temp = *inbuf++;
873             *outbuf++ = *ivp ^ temp;
874             *ivp++ = temp;
875         }
876     }
877
878     /* now we can process complete blocks */
879     while( nbytes >= blocksize ) {
880         int i;
881         /* encrypt the IV (and save the current one) */
882         memcpy( c->lastiv, c->iv, blocksize );
883         (*c->cipher->encrypt)( &c->context.c, c->iv, c->iv );
884         /* XOR the input with the IV and store input into IV */
885         for(ivp=c->iv,i=0; i < blocksize; i++ ) {
886             temp = *inbuf++;
887             *outbuf++ = *ivp ^ temp;
888             *ivp++ = temp;
889         }
890         nbytes -= blocksize;
891     }
892     if( nbytes ) { /* process the remaining bytes */
893         /* encrypt the IV (and save the current one) */
894         memcpy( c->lastiv, c->iv, blocksize );
895         (*c->cipher->encrypt)( &c->context.c, c->iv, c->iv );
896         c->unused = blocksize;
897         /* and apply the xor */
898         c->unused -= nbytes;
899         for(ivp=c->iv; nbytes; nbytes-- ) {
900             temp = *inbuf++;
901             *outbuf++ = *ivp ^ temp;
902             *ivp++ = temp;
903         }
904     }
905 }
906
907
908 static void
909 do_ctr_encrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf, unsigned nbytes )
910 {
911   unsigned int n;
912   byte tmp[MAX_BLOCKSIZE];
913   int i;
914
915   for(n=0; n < nbytes; n++)
916     {
917       if ((n % c->cipher->blocksize) == 0)
918         {
919           (*c->cipher->encrypt) (&c->context.c, tmp, c->ctr);
920
921           for (i = c->cipher->blocksize; i > 0; i--)
922             {
923               c->ctr[i-1]++;
924               if (c->ctr[i-1] != 0)
925                 break;
926             }
927         }
928
929       /* XOR input with encrypted counter and store in output */
930       outbuf[n] = inbuf[n] ^ tmp[n % c->cipher->blocksize];
931     }
932 }
933
934 static void
935 do_ctr_decrypt( gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf, unsigned nbytes )
936 {
937   return do_ctr_encrypt (c, outbuf, inbuf, nbytes);
938 }
939
940
941 /****************
942  * Encrypt INBUF to OUTBUF with the mode selected at open.
943  * inbuf and outbuf may overlap or be the same.
944  * Depending on the mode some contraints apply to NBYTES.
945  */
946 static gcry_err_code_t
947 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf,
948                 const byte *inbuf, unsigned int nbytes)
949 {
950     gcry_err_code_t rc = GPG_ERR_NO_ERROR;
951
952     switch( c->mode ) {
953       case GCRY_CIPHER_MODE_ECB:
954         if (!(nbytes%c->cipher->blocksize))
955             do_ecb_encrypt(c, outbuf, inbuf, nbytes/c->cipher->blocksize );
956         else 
957             rc = GPG_ERR_INV_ARG;
958         break;
959       case GCRY_CIPHER_MODE_CBC:
960         if (!(nbytes%c->cipher->blocksize) || (nbytes > c->cipher->blocksize && 
961                                        (c->flags & GCRY_CIPHER_CBC_CTS)))
962             do_cbc_encrypt(c, outbuf, inbuf, nbytes );
963         else 
964             rc = GPG_ERR_INV_ARG;
965         break;
966       case GCRY_CIPHER_MODE_CFB:
967         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
968         break;
969       case GCRY_CIPHER_MODE_CTR:
970         do_ctr_encrypt(c, outbuf, inbuf, nbytes );
971         break;
972       case GCRY_CIPHER_MODE_STREAM:
973         (*c->cipher->stencrypt)( &c->context.c,
974                                  outbuf, (byte*)/*arggg*/inbuf, nbytes );
975         break;
976       case GCRY_CIPHER_MODE_NONE:
977         if( inbuf != outbuf )
978             memmove( outbuf, inbuf, nbytes );
979         break;
980       default:
981         log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
982         rc = GPG_ERR_INV_CIPHER_MODE;
983         break;
984     }
985     return rc;
986 }
987
988
989 /****************
990  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
991  * been requested,
992  */
993 gcry_error_t
994 gcry_cipher_encrypt (gcry_cipher_hd_t h, byte *out, size_t outsize,
995                      const byte  *in, size_t inlen)
996 {
997   gcry_err_code_t err;
998
999   if (!in)
1000     /* caller requested in-place encryption */
1001     /* actullay cipher_encrypt() does not need to know about it, but
1002      * we may change this to get better performace */
1003     err = cipher_encrypt (h, out, out, outsize);
1004   else if (outsize < ((h->flags & GCRY_CIPHER_CBC_MAC) ? h->cipher->blocksize : inlen))
1005     err = GPG_ERR_TOO_SHORT;
1006   else if ((h->mode == GCRY_CIPHER_MODE_ECB
1007             || (h->mode == GCRY_CIPHER_MODE_CBC
1008                 && (! ((h->flags & GCRY_CIPHER_CBC_CTS)
1009                        && (inlen > h->cipher->blocksize)))))
1010            && (inlen % h->cipher->blocksize))
1011     err = GPG_ERR_INV_ARG;
1012   else
1013     err = cipher_encrypt (h, out, in, inlen);
1014
1015   if (err && out)
1016     memset (out, 0x42, outsize); /* Failsafe: Make sure that the
1017                                     plaintext will never make it into
1018                                     OUT. */
1019
1020   return gcry_error (err);
1021 }
1022
1023
1024
1025 /****************
1026  * Decrypt INBUF to OUTBUF with the mode selected at open.
1027  * inbuf and outbuf may overlap or be the same.
1028  * Depending on the mode some some contraints apply to NBYTES.
1029  */
1030 static gcry_err_code_t
1031 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, const byte *inbuf,
1032                 unsigned nbytes)
1033 {
1034     gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1035
1036     switch( c->mode ) {
1037       case GCRY_CIPHER_MODE_ECB:
1038         if (!(nbytes%c->cipher->blocksize))
1039             do_ecb_decrypt(c, outbuf, inbuf, nbytes/c->cipher->blocksize );
1040         else 
1041             rc = GPG_ERR_INV_ARG;
1042         break;
1043       case GCRY_CIPHER_MODE_CBC:
1044         if (!(nbytes%c->cipher->blocksize) || (nbytes > c->cipher->blocksize && 
1045                                                (c->flags & GCRY_CIPHER_CBC_CTS)))
1046             do_cbc_decrypt(c, outbuf, inbuf, nbytes );
1047         else 
1048             rc = GPG_ERR_INV_ARG;
1049         break;
1050       case GCRY_CIPHER_MODE_CFB:
1051         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
1052         break;
1053       case GCRY_CIPHER_MODE_CTR:
1054         do_ctr_decrypt(c, outbuf, inbuf, nbytes );
1055         break;
1056       case GCRY_CIPHER_MODE_STREAM:
1057         (*c->cipher->stdecrypt)( &c->context.c,
1058                                  outbuf, (byte*)/*arggg*/inbuf, nbytes );
1059         break;
1060       case GCRY_CIPHER_MODE_NONE:
1061         if( inbuf != outbuf )
1062             memmove( outbuf, inbuf, nbytes );
1063         break;
1064       default:
1065         log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1066         rc = GPG_ERR_INV_CIPHER_MODE;
1067         break;
1068     }
1069     return rc;
1070 }
1071
1072
1073 gcry_error_t
1074 gcry_cipher_decrypt (gcry_cipher_hd_t h, byte *out, size_t outsize,
1075                      const byte  *in, size_t inlen)
1076 {
1077   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1078
1079   if (! in)
1080     /* caller requested in-place encryption */
1081     /* actullay cipher_encrypt() does not need to know about it, but
1082      * we may chnage this to get better performace */
1083     err = cipher_decrypt (h, out, out, outsize);
1084   else if (outsize < inlen)
1085     err = GPG_ERR_TOO_SHORT;
1086   else if (((h->mode == GCRY_CIPHER_MODE_ECB)
1087             || ((h->mode == GCRY_CIPHER_MODE_CBC)
1088                 && (! ((h->flags & GCRY_CIPHER_CBC_CTS)
1089                        && (inlen > h->cipher->blocksize)))))
1090            && (inlen % h->cipher->blocksize) != 0)
1091     err = GPG_ERR_INV_ARG;
1092   else
1093     err = cipher_decrypt (h, out, in, inlen);
1094
1095   return gcry_error (err);
1096 }
1097
1098
1099
1100 /****************
1101  * Used for PGP's somewhat strange CFB mode. Only works if
1102  * the corresponding flag is set.
1103  */
1104 static void
1105 cipher_sync( gcry_cipher_hd_t c )
1106 {
1107     if( (c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused ) {
1108         memmove(c->iv + c->unused, c->iv, c->cipher->blocksize - c->unused );
1109         memcpy(c->iv, c->lastiv + c->cipher->blocksize - c->unused, c->unused);
1110         c->unused = 0;
1111     }
1112 }
1113
1114
1115 gcry_error_t
1116 gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1117 {
1118   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1119
1120   switch (cmd)
1121     {
1122     case GCRYCTL_SET_KEY:
1123       rc = cipher_setkey( h, buffer, buflen );
1124       break;
1125     case GCRYCTL_SET_IV:
1126       cipher_setiv( h, buffer, buflen );
1127       break;
1128     case GCRYCTL_RESET:
1129       cipher_reset (h);
1130       break;
1131     case GCRYCTL_CFB_SYNC:
1132       cipher_sync( h );
1133       break;
1134     case GCRYCTL_SET_CBC_CTS:
1135       if (buflen)
1136         if (h->flags & GCRY_CIPHER_CBC_MAC)
1137           rc = GPG_ERR_INV_FLAG;
1138         else
1139           h->flags |= GCRY_CIPHER_CBC_CTS;
1140       else
1141         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1142       break;
1143     case GCRYCTL_SET_CBC_MAC:
1144       if (buflen)
1145         if (h->flags & GCRY_CIPHER_CBC_CTS)
1146           rc = GPG_ERR_INV_FLAG;
1147         else
1148           h->flags |= GCRY_CIPHER_CBC_MAC;
1149       else
1150         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1151       break;
1152     case GCRYCTL_DISABLE_ALGO:
1153       /* this one expects a NULL handle and buffer pointing to an
1154        * integer with the algo number.
1155        */
1156       if( h || !buffer || buflen != sizeof(int) )
1157         return gcry_error (GPG_ERR_CIPHER_ALGO);
1158       disable_cipher_algo( *(int*)buffer );
1159       break;
1160     case GCRYCTL_SET_CTR:
1161       if (buffer && buflen == h->cipher->blocksize)
1162         memcpy (h->ctr, buffer, h->cipher->blocksize);
1163       else if (buffer == NULL || buflen == 0)
1164         memset (h->ctr, 0, h->cipher->blocksize);
1165       else
1166         rc = GPG_ERR_INV_ARG;
1167       break;
1168
1169     default:
1170       rc = GPG_ERR_INV_OP;
1171     }
1172
1173   return gcry_error (rc);
1174 }
1175
1176
1177 /****************
1178  * Return information about the cipher handle.
1179  */
1180 gcry_error_t
1181 gcry_cipher_info( gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1182 {
1183   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1184
1185   switch (cmd)
1186     {
1187     default:
1188       err = GPG_ERR_INV_OP;
1189     }
1190
1191   return gcry_error (err);
1192 }
1193
1194 /****************
1195  * Return information about the given cipher algorithm
1196  * WHAT select the kind of information returned:
1197  *  GCRYCTL_GET_KEYLEN:
1198  *      Return the length of the key, if the algorithm
1199  *      supports multiple key length, the maximum supported value
1200  *      is returnd.  The length is return as number of octets.
1201  *      buffer and nbytes must be zero.
1202  *      The keylength is returned in _bytes_.
1203  *  GCRYCTL_GET_BLKLEN:
1204  *      Return the blocklength of the algorithm counted in octets.
1205  *      buffer and nbytes must be zero.
1206  *  GCRYCTL_TEST_ALGO:
1207  *      Returns 0 when the specified algorithm is available for use.
1208  *      buffer and nbytes must be zero.
1209  *
1210  * Note:  Because this function is in most cases used to return an
1211  * integer value, we can make it easier for the caller to just look at
1212  * the return value.  The caller will in all cases consult the value
1213  * and thereby detecting whether a error occured or not (i.e. while checking
1214  * the block size)
1215  */
1216 gcry_error_t
1217 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1218 {
1219   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1220   unsigned int ui;
1221
1222   switch (what)
1223     {
1224     case GCRYCTL_GET_KEYLEN:
1225       if (buffer || (! nbytes))
1226         err = GPG_ERR_CIPHER_ALGO;
1227       else
1228         {
1229           ui = cipher_get_keylen (algo);
1230           if ((ui > 0) && (ui <= 512))
1231             *nbytes = (size_t) ui / 8;
1232           else
1233             /* The only reason is an invalid algo or a strange
1234                blocksize.  */
1235             err = GPG_ERR_CIPHER_ALGO;
1236         }
1237       break;
1238
1239     case GCRYCTL_GET_BLKLEN:
1240       if (buffer || (! nbytes))
1241         err = GPG_ERR_CIPHER_ALGO;
1242       else
1243         {
1244           ui = cipher_get_blocksize (algo);
1245           if ((ui > 0) && (ui < 10000))
1246             *nbytes = ui;
1247           else
1248             /* The only reason is an invalid algo or a strange
1249                blocksize.  */
1250             err = GPG_ERR_CIPHER_ALGO;
1251         }
1252       break;
1253
1254     case GCRYCTL_TEST_ALGO:
1255       if (buffer || nbytes)
1256         err = GPG_ERR_INV_ARG;
1257       else
1258         err = check_cipher_algo (algo);
1259       break;
1260
1261       default:
1262         err = GPG_ERR_INV_OP;
1263     }
1264
1265   return gcry_error (err);
1266 }
1267
1268
1269 size_t
1270 gcry_cipher_get_algo_keylen (int algo) 
1271 {
1272   size_t n;
1273
1274   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1275     n = 0;
1276   return n;
1277 }
1278
1279
1280 size_t
1281 gcry_cipher_get_algo_blklen (int algo) 
1282 {
1283   size_t n;
1284
1285   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1286     n = 0;
1287   return n;
1288 }
1289
1290
1291 gcry_err_code_t
1292 _gcry_cipher_init (void)
1293 {
1294   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1295
1296   REGISTER_DEFAULT_CIPHERS;
1297
1298   return err;
1299 }
1300
1301 /* Get a list consisting of the IDs of the loaded cipher modules.  If
1302    LIST is zero, write the number of loaded cipher modules to
1303    LIST_LENGTH and return.  If LIST is non-zero, the first
1304    *LIST_LENGTH algorithm IDs are stored in LIST, which must be of
1305    according size.  In case there are less cipher modules than
1306    *LIST_LENGTH, *LIST_LENGTH is updated to the correct number.  */
1307 gcry_error_t
1308 gcry_cipher_list (int *list, int *list_length)
1309 {
1310   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1311
1312   ath_mutex_lock (&ciphers_registered_lock);
1313   err = _gcry_module_list (ciphers_registered, list, list_length);
1314   ath_mutex_unlock (&ciphers_registered_lock);
1315
1316   return err;
1317 }