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