Add new private header gcrypt-testapi.h.
[libgcrypt.git] / cipher / cipher.c
1 /* cipher.c  -  cipher dispatcher
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *               2005, 2007, 2008, 2009, 2011 Free Software Foundation, Inc.
4  * Copyright (C) 2013 g10 Code GmbH
5  *
6  * This file is part of Libgcrypt.
7  *
8  * Libgcrypt is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU Lesser general Public License as
10  * published by the Free Software Foundation; either version 2.1 of
11  * the License, or (at your option) any later version.
12  *
13  * Libgcrypt is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27
28 #include "g10lib.h"
29 #include "../src/gcrypt-testapi.h"
30 #include "cipher.h"
31 #include "./cipher-internal.h"
32
33
34 /* This is the list of the default ciphers, which are included in
35    libgcrypt.  */
36 static gcry_cipher_spec_t *cipher_list[] =
37   {
38 #if USE_BLOWFISH
39      &_gcry_cipher_spec_blowfish,
40 #endif
41 #if USE_DES
42      &_gcry_cipher_spec_des,
43      &_gcry_cipher_spec_tripledes,
44 #endif
45 #if USE_ARCFOUR
46      &_gcry_cipher_spec_arcfour,
47 #endif
48 #if USE_CAST5
49      &_gcry_cipher_spec_cast5,
50 #endif
51 #if USE_AES
52      &_gcry_cipher_spec_aes,
53      &_gcry_cipher_spec_aes192,
54      &_gcry_cipher_spec_aes256,
55 #endif
56 #if USE_TWOFISH
57      &_gcry_cipher_spec_twofish,
58      &_gcry_cipher_spec_twofish128,
59 #endif
60 #if USE_SERPENT
61      &_gcry_cipher_spec_serpent128,
62      &_gcry_cipher_spec_serpent192,
63      &_gcry_cipher_spec_serpent256,
64 #endif
65 #if USE_RFC2268
66      &_gcry_cipher_spec_rfc2268_40,
67      &_gcry_cipher_spec_rfc2268_128,
68 #endif
69 #if USE_SEED
70      &_gcry_cipher_spec_seed,
71 #endif
72 #if USE_CAMELLIA
73      &_gcry_cipher_spec_camellia128,
74      &_gcry_cipher_spec_camellia192,
75      &_gcry_cipher_spec_camellia256,
76 #endif
77 #ifdef USE_IDEA
78      &_gcry_cipher_spec_idea,
79 #endif
80 #if USE_SALSA20
81      &_gcry_cipher_spec_salsa20,
82      &_gcry_cipher_spec_salsa20r12,
83 #endif
84 #if USE_GOST28147
85      &_gcry_cipher_spec_gost28147,
86 #endif
87 #if USE_CHACHA20
88      &_gcry_cipher_spec_chacha20,
89 #endif
90     NULL
91   };
92
93
94
95 \f
96 static int
97 map_algo (int algo)
98 {
99   return algo;
100 }
101
102
103 /* Return the spec structure for the cipher algorithm ALGO.  For
104    an unknown algorithm NULL is returned.  */
105 static gcry_cipher_spec_t *
106 spec_from_algo (int algo)
107 {
108   int idx;
109   gcry_cipher_spec_t *spec;
110
111   algo = map_algo (algo);
112
113   for (idx = 0; (spec = cipher_list[idx]); idx++)
114     if (algo == spec->algo)
115       return spec;
116   return NULL;
117 }
118
119
120 /* Lookup a cipher's spec by its name.  */
121 static gcry_cipher_spec_t *
122 spec_from_name (const char *name)
123 {
124   gcry_cipher_spec_t *spec;
125   int idx;
126   const char **aliases;
127
128   for (idx=0; (spec = cipher_list[idx]); idx++)
129     {
130       if (!stricmp (name, spec->name))
131         return spec;
132       if (spec->aliases)
133         {
134           for (aliases = spec->aliases; *aliases; aliases++)
135             if (!stricmp (name, *aliases))
136               return spec;
137         }
138     }
139
140   return NULL;
141 }
142
143
144 /* Lookup a cipher's spec by its OID.  */
145 static gcry_cipher_spec_t *
146 spec_from_oid (const char *oid)
147 {
148   gcry_cipher_spec_t *spec;
149   gcry_cipher_oid_spec_t *oid_specs;
150   int idx, j;
151
152   for (idx=0; (spec = cipher_list[idx]); idx++)
153     {
154       oid_specs = spec->oids;
155       if (oid_specs)
156         {
157           for (j = 0; oid_specs[j].oid; j++)
158             if (!stricmp (oid, oid_specs[j].oid))
159               return spec;
160         }
161     }
162
163   return NULL;
164 }
165
166
167 /* Locate the OID in the oid table and return the spec or NULL if not
168    found.  An optional "oid." or "OID." prefix in OID is ignored, the
169    OID is expected to be in standard IETF dotted notation.  A pointer
170    to the OID specification of the module implementing this algorithm
171    is return in OID_SPEC unless passed as NULL.*/
172 static gcry_cipher_spec_t *
173 search_oid (const char *oid, gcry_cipher_oid_spec_t *oid_spec)
174 {
175   gcry_cipher_spec_t *spec;
176   int i;
177
178   if (oid && ((! strncmp (oid, "oid.", 4))
179               || (! strncmp (oid, "OID.", 4))))
180     oid += 4;
181
182   spec = spec_from_oid (oid);
183   if (spec && spec->oids)
184     {
185       for (i = 0; spec->oids[i].oid; i++)
186         if (!stricmp (oid, spec->oids[i].oid))
187           {
188             if (oid_spec)
189               *oid_spec = spec->oids[i];
190             return spec;
191           }
192     }
193
194   return NULL;
195 }
196
197
198 /* Map STRING to the cipher algorithm identifier.  Returns the
199    algorithm ID of the cipher for the given name or 0 if the name is
200    not known.  It is valid to pass NULL for STRING which results in a
201    return value of 0. */
202 int
203 _gcry_cipher_map_name (const char *string)
204 {
205   gcry_cipher_spec_t *spec;
206
207   if (!string)
208     return 0;
209
210   /* If the string starts with a digit (optionally prefixed with
211      either "OID." or "oid."), we first look into our table of ASN.1
212      object identifiers to figure out the algorithm */
213
214   spec = search_oid (string, NULL);
215   if (spec)
216     return spec->algo;
217
218   spec = spec_from_name (string);
219   if (spec)
220     return spec->algo;
221
222   return 0;
223 }
224
225
226 /* Given a STRING with an OID in dotted decimal notation, this
227    function returns the cipher mode (GCRY_CIPHER_MODE_*) associated
228    with that OID or 0 if no mode is known.  Passing NULL for string
229    yields a return value of 0. */
230 int
231 _gcry_cipher_mode_from_oid (const char *string)
232 {
233   gcry_cipher_spec_t *spec;
234   gcry_cipher_oid_spec_t oid_spec;
235
236   if (!string)
237     return 0;
238
239   spec = search_oid (string, &oid_spec);
240   if (spec)
241     return oid_spec.mode;
242
243   return 0;
244 }
245
246
247 /* Map the cipher algorithm identifier ALGORITHM to a string
248    representing this algorithm.  This string is the default name as
249    used by Libgcrypt.  A "?" is returned for an unknown algorithm.
250    NULL is never returned. */
251 const char *
252 _gcry_cipher_algo_name (int algorithm)
253 {
254   gcry_cipher_spec_t *spec;
255
256   spec = spec_from_algo (algorithm);
257   return spec? spec->name : "?";
258 }
259
260
261 /* Flag the cipher algorithm with the identifier ALGORITHM as
262    disabled.  There is no error return, the function does nothing for
263    unknown algorithms.  Disabled algorithms are virtually not
264    available in Libgcrypt.  This is not thread safe and should thus be
265    called early. */
266 static void
267 disable_cipher_algo (int algo)
268 {
269   gcry_cipher_spec_t *spec = spec_from_algo (algo);
270
271   if (spec)
272     spec->flags.disabled = 1;
273 }
274
275
276 /* Return 0 if the cipher algorithm with identifier ALGORITHM is
277    available. Returns a basic error code value if it is not
278    available.  */
279 static gcry_err_code_t
280 check_cipher_algo (int algorithm)
281 {
282   gcry_cipher_spec_t *spec;
283
284   spec = spec_from_algo (algorithm);
285   if (spec && !spec->flags.disabled)
286     return 0;
287
288   return GPG_ERR_CIPHER_ALGO;
289 }
290
291
292 /* Return the standard length in bits of the key for the cipher
293    algorithm with the identifier ALGORITHM.  */
294 static unsigned int
295 cipher_get_keylen (int algorithm)
296 {
297   gcry_cipher_spec_t *spec;
298   unsigned len = 0;
299
300   spec = spec_from_algo (algorithm);
301   if (spec)
302     {
303       len = spec->keylen;
304       if (!len)
305         log_bug ("cipher %d w/o key length\n", algorithm);
306     }
307
308   return len;
309 }
310
311
312 /* Return the block length of the cipher algorithm with the identifier
313    ALGORITHM.  This function return 0 for an invalid algorithm.  */
314 static unsigned int
315 cipher_get_blocksize (int algorithm)
316 {
317   gcry_cipher_spec_t *spec;
318   unsigned len = 0;
319
320   spec = spec_from_algo (algorithm);
321   if (spec)
322     {
323       len = spec->blocksize;
324       if (!len)
325         log_bug ("cipher %d w/o blocksize\n", algorithm);
326     }
327
328   return len;
329 }
330
331
332 /*
333    Open a cipher handle for use with cipher algorithm ALGORITHM, using
334    the cipher mode MODE (one of the GCRY_CIPHER_MODE_*) and return a
335    handle in HANDLE.  Put NULL into HANDLE and return an error code if
336    something goes wrong.  FLAGS may be used to modify the
337    operation.  The defined flags are:
338
339    GCRY_CIPHER_SECURE:  allocate all internal buffers in secure memory.
340    GCRY_CIPHER_ENABLE_SYNC:  Enable the sync operation as used in OpenPGP.
341    GCRY_CIPHER_CBC_CTS:  Enable CTS mode.
342    GCRY_CIPHER_CBC_MAC:  Enable MAC mode.
343
344    Values for these flags may be combined using OR.
345  */
346 gcry_err_code_t
347 _gcry_cipher_open (gcry_cipher_hd_t *handle,
348                    int algo, int mode, unsigned int flags)
349 {
350   gcry_err_code_t rc;
351   gcry_cipher_hd_t h = NULL;
352
353   if (mode >= GCRY_CIPHER_MODE_INTERNAL)
354     rc = GPG_ERR_INV_CIPHER_MODE;
355   else
356     rc = _gcry_cipher_open_internal (&h, algo, mode, flags);
357
358   *handle = rc ? NULL : h;
359
360   return rc;
361 }
362
363
364 gcry_err_code_t
365 _gcry_cipher_open_internal (gcry_cipher_hd_t *handle,
366                             int algo, int mode, unsigned int flags)
367 {
368   int secure = (flags & GCRY_CIPHER_SECURE);
369   gcry_cipher_spec_t *spec;
370   gcry_cipher_hd_t h = NULL;
371   gcry_err_code_t err;
372
373   /* If the application missed to call the random poll function, we do
374      it here to ensure that it is used once in a while. */
375   _gcry_fast_random_poll ();
376
377   spec = spec_from_algo (algo);
378   if (!spec)
379     err = GPG_ERR_CIPHER_ALGO;
380   else if (spec->flags.disabled)
381     err = GPG_ERR_CIPHER_ALGO;
382   else
383     err = 0;
384
385   /* check flags */
386   if ((! err)
387       && ((flags & ~(0
388                      | GCRY_CIPHER_SECURE
389                      | GCRY_CIPHER_ENABLE_SYNC
390                      | GCRY_CIPHER_CBC_CTS
391                      | GCRY_CIPHER_CBC_MAC))
392           || (flags & GCRY_CIPHER_CBC_CTS & GCRY_CIPHER_CBC_MAC)))
393     err = GPG_ERR_CIPHER_ALGO;
394
395   /* check that a valid mode has been requested */
396   if (! err)
397     switch (mode)
398       {
399       case GCRY_CIPHER_MODE_CCM:
400 #ifdef HAVE_U64_TYPEDEF
401         if (spec->blocksize != GCRY_CCM_BLOCK_LEN)
402           err = GPG_ERR_INV_CIPHER_MODE;
403         if (!spec->encrypt || !spec->decrypt)
404           err = GPG_ERR_INV_CIPHER_MODE;
405         break;
406 #else
407         err = GPG_ERR_NOT_SUPPORTED;
408 #endif
409
410       case GCRY_CIPHER_MODE_ECB:
411       case GCRY_CIPHER_MODE_CBC:
412       case GCRY_CIPHER_MODE_CFB:
413       case GCRY_CIPHER_MODE_OFB:
414       case GCRY_CIPHER_MODE_CTR:
415       case GCRY_CIPHER_MODE_AESWRAP:
416       case GCRY_CIPHER_MODE_CMAC:
417       case GCRY_CIPHER_MODE_GCM:
418         if (!spec->encrypt || !spec->decrypt)
419           err = GPG_ERR_INV_CIPHER_MODE;
420         break;
421
422       case GCRY_CIPHER_MODE_POLY1305:
423         if (!spec->stencrypt || !spec->stdecrypt || !spec->setiv)
424           err = GPG_ERR_INV_CIPHER_MODE;
425         else if (spec->algo != GCRY_CIPHER_CHACHA20)
426           err = GPG_ERR_INV_CIPHER_MODE;
427         break;
428
429       case GCRY_CIPHER_MODE_OCB:
430         /* Note that our implementation allows only for 128 bit block
431            length algorithms.  Lower block lengths would be possible
432            but we do not implement them because they limit the
433            security too much.  */
434         if (!spec->encrypt || !spec->decrypt)
435           err = GPG_ERR_INV_CIPHER_MODE;
436         else if (spec->blocksize != (128/8))
437           err = GPG_ERR_INV_CIPHER_MODE;
438         break;
439
440       case GCRY_CIPHER_MODE_STREAM:
441         if (!spec->stencrypt || !spec->stdecrypt)
442           err = GPG_ERR_INV_CIPHER_MODE;
443         break;
444
445       case GCRY_CIPHER_MODE_NONE:
446         /* This mode may be used for debugging.  It copies the main
447            text verbatim to the ciphertext.  We do not allow this in
448            fips mode or if no debug flag has been set.  */
449         if (fips_mode () || !_gcry_get_debug_flag (0))
450           err = GPG_ERR_INV_CIPHER_MODE;
451         break;
452
453       default:
454         err = GPG_ERR_INV_CIPHER_MODE;
455       }
456
457   /* Perform selftest here and mark this with a flag in cipher_table?
458      No, we should not do this as it takes too long.  Further it does
459      not make sense to exclude algorithms with failing selftests at
460      runtime: If a selftest fails there is something seriously wrong
461      with the system and thus we better die immediately. */
462
463   if (! err)
464     {
465       size_t size = (sizeof (*h)
466                      + 2 * spec->contextsize
467                      - sizeof (cipher_context_alignment_t)
468 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
469                      + 15  /* Space for leading alignment gap.  */
470 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
471                      );
472
473       if (secure)
474         h = xtrycalloc_secure (1, size);
475       else
476         h = xtrycalloc (1, size);
477
478       if (! h)
479         err = gpg_err_code_from_syserror ();
480       else
481         {
482           size_t off = 0;
483
484 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
485           if ( ((uintptr_t)h & 0x0f) )
486             {
487               /* The malloced block is not aligned on a 16 byte
488                  boundary.  Correct for this.  */
489               off = 16 - ((uintptr_t)h & 0x0f);
490               h = (void*)((char*)h + off);
491             }
492 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
493
494           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
495           h->actual_handle_size = size - off;
496           h->handle_offset = off;
497           h->spec = spec;
498           h->algo = algo;
499           h->mode = mode;
500           h->flags = flags;
501
502           /* Setup bulk encryption routines.  */
503           switch (algo)
504             {
505 #ifdef USE_AES
506             case GCRY_CIPHER_AES128:
507             case GCRY_CIPHER_AES192:
508             case GCRY_CIPHER_AES256:
509               h->bulk.cfb_enc = _gcry_aes_cfb_enc;
510               h->bulk.cfb_dec = _gcry_aes_cfb_dec;
511               h->bulk.cbc_enc = _gcry_aes_cbc_enc;
512               h->bulk.cbc_dec = _gcry_aes_cbc_dec;
513               h->bulk.ctr_enc = _gcry_aes_ctr_enc;
514               h->bulk.ocb_crypt = _gcry_aes_ocb_crypt;
515               h->bulk.ocb_auth  = _gcry_aes_ocb_auth;
516               break;
517 #endif /*USE_AES*/
518 #ifdef USE_BLOWFISH
519             case GCRY_CIPHER_BLOWFISH:
520               h->bulk.cfb_dec = _gcry_blowfish_cfb_dec;
521               h->bulk.cbc_dec = _gcry_blowfish_cbc_dec;
522               h->bulk.ctr_enc = _gcry_blowfish_ctr_enc;
523               break;
524 #endif /*USE_BLOWFISH*/
525 #ifdef USE_CAST5
526             case GCRY_CIPHER_CAST5:
527               h->bulk.cfb_dec = _gcry_cast5_cfb_dec;
528               h->bulk.cbc_dec = _gcry_cast5_cbc_dec;
529               h->bulk.ctr_enc = _gcry_cast5_ctr_enc;
530               break;
531 #endif /*USE_CAMELLIA*/
532 #ifdef USE_CAMELLIA
533             case GCRY_CIPHER_CAMELLIA128:
534             case GCRY_CIPHER_CAMELLIA192:
535             case GCRY_CIPHER_CAMELLIA256:
536               h->bulk.cbc_dec = _gcry_camellia_cbc_dec;
537               h->bulk.cfb_dec = _gcry_camellia_cfb_dec;
538               h->bulk.ctr_enc = _gcry_camellia_ctr_enc;
539               h->bulk.ocb_crypt = _gcry_camellia_ocb_crypt;
540               h->bulk.ocb_auth  = _gcry_camellia_ocb_auth;
541               break;
542 #endif /*USE_CAMELLIA*/
543 #ifdef USE_DES
544             case GCRY_CIPHER_3DES:
545               h->bulk.cbc_dec =  _gcry_3des_cbc_dec;
546               h->bulk.cfb_dec =  _gcry_3des_cfb_dec;
547               h->bulk.ctr_enc =  _gcry_3des_ctr_enc;
548               break;
549 #endif /*USE_DES*/
550 #ifdef USE_SERPENT
551             case GCRY_CIPHER_SERPENT128:
552             case GCRY_CIPHER_SERPENT192:
553             case GCRY_CIPHER_SERPENT256:
554               h->bulk.cbc_dec = _gcry_serpent_cbc_dec;
555               h->bulk.cfb_dec = _gcry_serpent_cfb_dec;
556               h->bulk.ctr_enc = _gcry_serpent_ctr_enc;
557               h->bulk.ocb_crypt = _gcry_serpent_ocb_crypt;
558               h->bulk.ocb_auth  = _gcry_serpent_ocb_auth;
559               break;
560 #endif /*USE_SERPENT*/
561 #ifdef USE_TWOFISH
562             case GCRY_CIPHER_TWOFISH:
563             case GCRY_CIPHER_TWOFISH128:
564               h->bulk.cbc_dec = _gcry_twofish_cbc_dec;
565               h->bulk.cfb_dec = _gcry_twofish_cfb_dec;
566               h->bulk.ctr_enc = _gcry_twofish_ctr_enc;
567               h->bulk.ocb_crypt = _gcry_twofish_ocb_crypt;
568               h->bulk.ocb_auth  = _gcry_twofish_ocb_auth;
569               break;
570 #endif /*USE_TWOFISH*/
571
572             default:
573               break;
574             }
575
576           /* Setup defaults depending on the mode.  */
577           switch (mode)
578             {
579             case GCRY_CIPHER_MODE_OCB:
580               h->u_mode.ocb.taglen = 16; /* Bytes.  */
581               break;
582
583             default:
584               break;
585             }
586
587         }
588     }
589
590   /* Done.  */
591
592   *handle = err ? NULL : h;
593
594   return err;
595 }
596
597
598 /* Release all resources associated with the cipher handle H. H may be
599    NULL in which case this is a no-operation. */
600 void
601 _gcry_cipher_close (gcry_cipher_hd_t h)
602 {
603   size_t off;
604
605   if (!h)
606     return;
607
608   if ((h->magic != CTX_MAGIC_SECURE)
609       && (h->magic != CTX_MAGIC_NORMAL))
610     _gcry_fatal_error(GPG_ERR_INTERNAL,
611                       "gcry_cipher_close: already closed/invalid handle");
612   else
613     h->magic = 0;
614
615   /* We always want to wipe out the memory even when the context has
616      been allocated in secure memory.  The user might have disabled
617      secure memory or is using his own implementation which does not
618      do the wiping.  To accomplish this we need to keep track of the
619      actual size of this structure because we have no way to known
620      how large the allocated area was when using a standard malloc. */
621   off = h->handle_offset;
622   wipememory (h, h->actual_handle_size);
623
624   xfree ((char*)h - off);
625 }
626
627
628 /* Set the key to be used for the encryption context C to KEY with
629    length KEYLEN.  The length should match the required length. */
630 static gcry_err_code_t
631 cipher_setkey (gcry_cipher_hd_t c, byte *key, size_t keylen)
632 {
633   gcry_err_code_t rc;
634
635   rc = c->spec->setkey (&c->context.c, key, keylen);
636   if (!rc)
637     {
638       /* Duplicate initial context.  */
639       memcpy ((void *) ((char *) &c->context.c + c->spec->contextsize),
640               (void *) &c->context.c,
641               c->spec->contextsize);
642       c->marks.key = 1;
643
644       switch (c->mode)
645         {
646         case GCRY_CIPHER_MODE_CMAC:
647           _gcry_cipher_cmac_set_subkeys (c);
648           break;
649
650         case GCRY_CIPHER_MODE_GCM:
651           _gcry_cipher_gcm_setkey (c);
652           break;
653
654         case GCRY_CIPHER_MODE_POLY1305:
655           _gcry_cipher_poly1305_setkey (c);
656           break;
657
658         default:
659           break;
660         };
661     }
662   else
663     c->marks.key = 0;
664
665   return rc;
666 }
667
668
669 /* Set the IV to be used for the encryption context C to IV with
670    length IVLEN.  The length should match the required length. */
671 static gcry_err_code_t
672 cipher_setiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
673 {
674   /* If the cipher has its own IV handler, we use only this one.  This
675      is currently used for stream ciphers requiring a nonce.  */
676   if (c->spec->setiv)
677     {
678       c->spec->setiv (&c->context.c, iv, ivlen);
679       return 0;
680     }
681
682   memset (c->u_iv.iv, 0, c->spec->blocksize);
683   if (iv)
684     {
685       if (ivlen != c->spec->blocksize)
686         {
687           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
688                     (unsigned int)ivlen, (unsigned int)c->spec->blocksize);
689           fips_signal_error ("IV length does not match blocklength");
690         }
691       if (ivlen > c->spec->blocksize)
692         ivlen = c->spec->blocksize;
693       memcpy (c->u_iv.iv, iv, ivlen);
694       c->marks.iv = 1;
695     }
696   else
697       c->marks.iv = 0;
698   c->unused = 0;
699
700   return 0;
701 }
702
703
704 /* Reset the cipher context to the initial context.  This is basically
705    the same as an release followed by a new. */
706 static void
707 cipher_reset (gcry_cipher_hd_t c)
708 {
709   unsigned int marks_key;
710
711   marks_key = c->marks.key;
712
713   memcpy (&c->context.c,
714           (char *) &c->context.c + c->spec->contextsize,
715           c->spec->contextsize);
716   memset (&c->marks, 0, sizeof c->marks);
717   memset (c->u_iv.iv, 0, c->spec->blocksize);
718   memset (c->lastiv, 0, c->spec->blocksize);
719   memset (c->u_ctr.ctr, 0, c->spec->blocksize);
720   c->unused = 0;
721
722   c->marks.key = marks_key;
723
724   switch (c->mode)
725     {
726     case GCRY_CIPHER_MODE_CMAC:
727       /* Only clear 'tag' for cmac, keep subkeys. */
728       c->u_mode.cmac.tag = 0;
729       break;
730
731     case GCRY_CIPHER_MODE_GCM:
732       /* Only clear head of u_mode, keep ghash_key and gcm_table. */
733       {
734         byte *u_mode_pos = (void *)&c->u_mode;
735         byte *ghash_key_pos = c->u_mode.gcm.u_ghash_key.key;
736         size_t u_mode_head_length = ghash_key_pos - u_mode_pos;
737
738         memset (&c->u_mode, 0, u_mode_head_length);
739       }
740       break;
741
742     case GCRY_CIPHER_MODE_POLY1305:
743       memset (&c->u_mode.poly1305, 0, sizeof c->u_mode.poly1305);
744       break;
745
746 #ifdef HAVE_U64_TYPEDEF
747     case GCRY_CIPHER_MODE_CCM:
748       memset (&c->u_mode.ccm, 0, sizeof c->u_mode.ccm);
749       break;
750 #endif
751
752     case GCRY_CIPHER_MODE_OCB:
753       memset (&c->u_mode.ocb, 0, sizeof c->u_mode.ocb);
754       /* Setup default taglen.  */
755       c->u_mode.ocb.taglen = 16;
756       break;
757
758     default:
759       break; /* u_mode unused by other modes. */
760     }
761 }
762
763
764 \f
765 static gcry_err_code_t
766 do_ecb_crypt (gcry_cipher_hd_t c,
767               unsigned char *outbuf, size_t outbuflen,
768               const unsigned char *inbuf, size_t inbuflen,
769               gcry_cipher_encrypt_t crypt_fn)
770 {
771   unsigned int blocksize = c->spec->blocksize;
772   size_t n, nblocks;
773   unsigned int burn, nburn;
774
775   if (outbuflen < inbuflen)
776     return GPG_ERR_BUFFER_TOO_SHORT;
777   if ((inbuflen % blocksize))
778     return GPG_ERR_INV_LENGTH;
779
780   nblocks = inbuflen / blocksize;
781   burn = 0;
782
783   for (n=0; n < nblocks; n++ )
784     {
785       nburn = crypt_fn (&c->context.c, outbuf, inbuf);
786       burn = nburn > burn ? nburn : burn;
787       inbuf  += blocksize;
788       outbuf += blocksize;
789     }
790
791   if (burn > 0)
792     _gcry_burn_stack (burn + 4 * sizeof(void *));
793
794   return 0;
795 }
796
797 static gcry_err_code_t
798 do_ecb_encrypt (gcry_cipher_hd_t c,
799                 unsigned char *outbuf, size_t outbuflen,
800                 const unsigned char *inbuf, size_t inbuflen)
801 {
802   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->encrypt);
803 }
804
805 static gcry_err_code_t
806 do_ecb_decrypt (gcry_cipher_hd_t c,
807                 unsigned char *outbuf, size_t outbuflen,
808                 const unsigned char *inbuf, size_t inbuflen)
809 {
810   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->decrypt);
811 }
812
813
814 /****************
815  * Encrypt INBUF to OUTBUF with the mode selected at open.
816  * inbuf and outbuf may overlap or be the same.
817  * Depending on the mode some constraints apply to INBUFLEN.
818  */
819 static gcry_err_code_t
820 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
821                 const byte *inbuf, size_t inbuflen)
822 {
823   gcry_err_code_t rc;
824
825   switch (c->mode)
826     {
827     case GCRY_CIPHER_MODE_ECB:
828       rc = do_ecb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
829       break;
830
831     case GCRY_CIPHER_MODE_CBC:
832       rc = _gcry_cipher_cbc_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
833       break;
834
835     case GCRY_CIPHER_MODE_CFB:
836       rc = _gcry_cipher_cfb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
837       break;
838
839     case GCRY_CIPHER_MODE_OFB:
840       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
841       break;
842
843     case GCRY_CIPHER_MODE_CTR:
844       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
845       break;
846
847     case GCRY_CIPHER_MODE_AESWRAP:
848       rc = _gcry_cipher_aeswrap_encrypt (c, outbuf, outbuflen,
849                                          inbuf, inbuflen);
850       break;
851
852     case GCRY_CIPHER_MODE_CCM:
853       rc = _gcry_cipher_ccm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
854       break;
855
856     case GCRY_CIPHER_MODE_CMAC:
857       rc = GPG_ERR_INV_CIPHER_MODE;
858       break;
859
860     case GCRY_CIPHER_MODE_GCM:
861       rc = _gcry_cipher_gcm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
862       break;
863
864     case GCRY_CIPHER_MODE_POLY1305:
865       rc = _gcry_cipher_poly1305_encrypt (c, outbuf, outbuflen,
866                                           inbuf, inbuflen);
867       break;
868
869     case GCRY_CIPHER_MODE_OCB:
870       rc = _gcry_cipher_ocb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
871       break;
872
873     case GCRY_CIPHER_MODE_STREAM:
874       c->spec->stencrypt (&c->context.c,
875                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
876       rc = 0;
877       break;
878
879     case GCRY_CIPHER_MODE_NONE:
880       if (fips_mode () || !_gcry_get_debug_flag (0))
881         {
882           fips_signal_error ("cipher mode NONE used");
883           rc = GPG_ERR_INV_CIPHER_MODE;
884         }
885       else
886         {
887           if (inbuf != outbuf)
888             memmove (outbuf, inbuf, inbuflen);
889           rc = 0;
890         }
891       break;
892
893     default:
894       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
895       rc = GPG_ERR_INV_CIPHER_MODE;
896       break;
897     }
898
899   return rc;
900 }
901
902
903 /****************
904  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
905  * been requested.
906  */
907 gcry_err_code_t
908 _gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
909                       const void *in, size_t inlen)
910 {
911   gcry_err_code_t rc;
912
913   if (!in)  /* Caller requested in-place encryption.  */
914     {
915       in = out;
916       inlen = outsize;
917     }
918
919   rc = cipher_encrypt (h, out, outsize, in, inlen);
920
921   /* Failsafe: Make sure that the plaintext will never make it into
922      OUT if the encryption returned an error.  */
923   if (rc && out)
924     memset (out, 0x42, outsize);
925
926   return rc;
927 }
928
929
930
931 /****************
932  * Decrypt INBUF to OUTBUF with the mode selected at open.
933  * inbuf and outbuf may overlap or be the same.
934  * Depending on the mode some some contraints apply to INBUFLEN.
935  */
936 static gcry_err_code_t
937 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
938                 const byte *inbuf, size_t inbuflen)
939 {
940   gcry_err_code_t rc;
941
942   switch (c->mode)
943     {
944     case GCRY_CIPHER_MODE_ECB:
945       rc = do_ecb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
946       break;
947
948     case GCRY_CIPHER_MODE_CBC:
949       rc = _gcry_cipher_cbc_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
950       break;
951
952     case GCRY_CIPHER_MODE_CFB:
953       rc = _gcry_cipher_cfb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
954       break;
955
956     case GCRY_CIPHER_MODE_OFB:
957       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
958       break;
959
960     case GCRY_CIPHER_MODE_CTR:
961       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
962       break;
963
964     case GCRY_CIPHER_MODE_AESWRAP:
965       rc = _gcry_cipher_aeswrap_decrypt (c, outbuf, outbuflen,
966                                          inbuf, inbuflen);
967       break;
968
969     case GCRY_CIPHER_MODE_CCM:
970       rc = _gcry_cipher_ccm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
971       break;
972
973     case GCRY_CIPHER_MODE_CMAC:
974       rc = GPG_ERR_INV_CIPHER_MODE;
975       break;
976
977     case GCRY_CIPHER_MODE_GCM:
978       rc = _gcry_cipher_gcm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
979       break;
980
981     case GCRY_CIPHER_MODE_POLY1305:
982       rc = _gcry_cipher_poly1305_decrypt (c, outbuf, outbuflen,
983                                           inbuf, inbuflen);
984       break;
985
986     case GCRY_CIPHER_MODE_OCB:
987       rc = _gcry_cipher_ocb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
988       break;
989
990     case GCRY_CIPHER_MODE_STREAM:
991       c->spec->stdecrypt (&c->context.c,
992                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
993       rc = 0;
994       break;
995
996     case GCRY_CIPHER_MODE_NONE:
997       if (fips_mode () || !_gcry_get_debug_flag (0))
998         {
999           fips_signal_error ("cipher mode NONE used");
1000           rc = GPG_ERR_INV_CIPHER_MODE;
1001         }
1002       else
1003         {
1004           if (inbuf != outbuf)
1005             memmove (outbuf, inbuf, inbuflen);
1006           rc = 0;
1007         }
1008       break;
1009
1010     default:
1011       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1012       rc = GPG_ERR_INV_CIPHER_MODE;
1013       break;
1014     }
1015
1016   return rc;
1017 }
1018
1019
1020 gcry_err_code_t
1021 _gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1022                       const void *in, size_t inlen)
1023 {
1024   if (!in) /* Caller requested in-place encryption. */
1025     {
1026       in = out;
1027       inlen = outsize;
1028     }
1029
1030   return cipher_decrypt (h, out, outsize, in, inlen);
1031 }
1032
1033
1034
1035 /****************
1036  * Used for PGP's somewhat strange CFB mode. Only works if
1037  * the corresponding flag is set.
1038  */
1039 static void
1040 cipher_sync (gcry_cipher_hd_t c)
1041 {
1042   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1043     {
1044       memmove (c->u_iv.iv + c->unused,
1045                c->u_iv.iv, c->spec->blocksize - c->unused);
1046       memcpy (c->u_iv.iv,
1047               c->lastiv + c->spec->blocksize - c->unused, c->unused);
1048       c->unused = 0;
1049     }
1050 }
1051
1052
1053 gcry_err_code_t
1054 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
1055 {
1056   return cipher_setkey (hd, (void*)key, keylen);
1057 }
1058
1059
1060 gcry_err_code_t
1061 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
1062 {
1063   gcry_err_code_t rc = 0;
1064
1065   switch (hd->mode)
1066     {
1067       case GCRY_CIPHER_MODE_CCM:
1068         rc = _gcry_cipher_ccm_set_nonce (hd, iv, ivlen);
1069         break;
1070
1071       case GCRY_CIPHER_MODE_GCM:
1072         rc =  _gcry_cipher_gcm_setiv (hd, iv, ivlen);
1073         break;
1074
1075       case GCRY_CIPHER_MODE_POLY1305:
1076         rc =  _gcry_cipher_poly1305_setiv (hd, iv, ivlen);
1077         break;
1078
1079       case GCRY_CIPHER_MODE_OCB:
1080         rc = _gcry_cipher_ocb_set_nonce (hd, iv, ivlen);
1081         break;
1082
1083       default:
1084         rc = cipher_setiv (hd, iv, ivlen);
1085         break;
1086     }
1087   return rc;
1088 }
1089
1090 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1091    block size length, or (NULL,0) to set the CTR to the all-zero
1092    block. */
1093 gpg_err_code_t
1094 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1095 {
1096   if (ctr && ctrlen == hd->spec->blocksize)
1097     {
1098       memcpy (hd->u_ctr.ctr, ctr, hd->spec->blocksize);
1099       hd->unused = 0;
1100     }
1101   else if (!ctr || !ctrlen)
1102     {
1103       memset (hd->u_ctr.ctr, 0, hd->spec->blocksize);
1104       hd->unused = 0;
1105     }
1106   else
1107     return GPG_ERR_INV_ARG;
1108
1109   return 0;
1110 }
1111
1112
1113 gcry_err_code_t
1114 _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
1115                            size_t abuflen)
1116 {
1117   gcry_err_code_t rc;
1118
1119   switch (hd->mode)
1120     {
1121     case GCRY_CIPHER_MODE_CCM:
1122       rc = _gcry_cipher_ccm_authenticate (hd, abuf, abuflen);
1123       break;
1124
1125     case GCRY_CIPHER_MODE_CMAC:
1126       rc = _gcry_cipher_cmac_authenticate (hd, abuf, abuflen);
1127       break;
1128
1129     case GCRY_CIPHER_MODE_GCM:
1130       rc = _gcry_cipher_gcm_authenticate (hd, abuf, abuflen);
1131       break;
1132
1133     case GCRY_CIPHER_MODE_POLY1305:
1134       rc = _gcry_cipher_poly1305_authenticate (hd, abuf, abuflen);
1135       break;
1136
1137     case GCRY_CIPHER_MODE_OCB:
1138       rc = _gcry_cipher_ocb_authenticate (hd, abuf, abuflen);
1139       break;
1140
1141     default:
1142       log_error ("gcry_cipher_authenticate: invalid mode %d\n", hd->mode);
1143       rc = GPG_ERR_INV_CIPHER_MODE;
1144       break;
1145     }
1146
1147   return rc;
1148 }
1149
1150
1151 gcry_err_code_t
1152 _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
1153 {
1154   gcry_err_code_t rc;
1155
1156   switch (hd->mode)
1157     {
1158     case GCRY_CIPHER_MODE_CCM:
1159       rc = _gcry_cipher_ccm_get_tag (hd, outtag, taglen);
1160       break;
1161
1162     case GCRY_CIPHER_MODE_CMAC:
1163       rc = _gcry_cipher_cmac_get_tag (hd, outtag, taglen);
1164       break;
1165
1166     case GCRY_CIPHER_MODE_GCM:
1167       rc = _gcry_cipher_gcm_get_tag (hd, outtag, taglen);
1168       break;
1169
1170     case GCRY_CIPHER_MODE_POLY1305:
1171       rc = _gcry_cipher_poly1305_get_tag (hd, outtag, taglen);
1172       break;
1173
1174     case GCRY_CIPHER_MODE_OCB:
1175       rc = _gcry_cipher_ocb_get_tag (hd, outtag, taglen);
1176       break;
1177
1178     default:
1179       log_error ("gcry_cipher_gettag: invalid mode %d\n", hd->mode);
1180       rc = GPG_ERR_INV_CIPHER_MODE;
1181       break;
1182     }
1183
1184   return rc;
1185 }
1186
1187
1188 gcry_err_code_t
1189 _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
1190 {
1191   gcry_err_code_t rc;
1192
1193   switch (hd->mode)
1194     {
1195     case GCRY_CIPHER_MODE_CCM:
1196       rc = _gcry_cipher_ccm_check_tag (hd, intag, taglen);
1197       break;
1198
1199     case GCRY_CIPHER_MODE_CMAC:
1200       rc = _gcry_cipher_cmac_check_tag (hd, intag, taglen);
1201       break;
1202
1203     case GCRY_CIPHER_MODE_GCM:
1204       rc = _gcry_cipher_gcm_check_tag (hd, intag, taglen);
1205       break;
1206
1207     case GCRY_CIPHER_MODE_POLY1305:
1208       rc = _gcry_cipher_poly1305_check_tag (hd, intag, taglen);
1209       break;
1210
1211     case GCRY_CIPHER_MODE_OCB:
1212       rc = _gcry_cipher_ocb_check_tag (hd, intag, taglen);
1213       break;
1214
1215     default:
1216       log_error ("gcry_cipher_checktag: invalid mode %d\n", hd->mode);
1217       rc = GPG_ERR_INV_CIPHER_MODE;
1218       break;
1219     }
1220
1221   return rc;
1222 }
1223
1224
1225 gcry_err_code_t
1226 _gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1227 {
1228   gcry_err_code_t rc = 0;
1229
1230   switch (cmd)
1231     {
1232     case GCRYCTL_RESET:
1233       cipher_reset (h);
1234       break;
1235
1236     case GCRYCTL_FINALIZE:
1237       if (!h || buffer || buflen)
1238         return GPG_ERR_INV_ARG;
1239       h->marks.finalize = 1;
1240       break;
1241
1242     case GCRYCTL_CFB_SYNC:
1243       cipher_sync( h );
1244       break;
1245
1246     case GCRYCTL_SET_CBC_CTS:
1247       if (buflen)
1248         if (h->flags & GCRY_CIPHER_CBC_MAC)
1249           rc = GPG_ERR_INV_FLAG;
1250         else
1251           h->flags |= GCRY_CIPHER_CBC_CTS;
1252       else
1253         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1254       break;
1255
1256     case GCRYCTL_SET_CBC_MAC:
1257       if (buflen)
1258         if (h->flags & GCRY_CIPHER_CBC_CTS)
1259           rc = GPG_ERR_INV_FLAG;
1260         else
1261           h->flags |= GCRY_CIPHER_CBC_MAC;
1262       else
1263         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1264       break;
1265
1266     case GCRYCTL_SET_CCM_LENGTHS:
1267 #ifdef HAVE_U64_TYPEDEF
1268       {
1269         u64 params[3];
1270         size_t encryptedlen;
1271         size_t aadlen;
1272         size_t authtaglen;
1273
1274         if (h->mode != GCRY_CIPHER_MODE_CCM)
1275           return GPG_ERR_INV_CIPHER_MODE;
1276
1277         if (!buffer || buflen != 3 * sizeof(u64))
1278           return GPG_ERR_INV_ARG;
1279
1280         /* This command is used to pass additional length parameters needed
1281            by CCM mode to initialize CBC-MAC.  */
1282         memcpy (params, buffer, sizeof(params));
1283         encryptedlen = params[0];
1284         aadlen = params[1];
1285         authtaglen = params[2];
1286
1287         rc = _gcry_cipher_ccm_set_lengths (h, encryptedlen, aadlen, authtaglen);
1288       }
1289 #else
1290       rc = GPG_ERR_NOT_SUPPORTED;
1291 #endif
1292       break;
1293
1294     case GCRYCTL_SET_TAGLEN:
1295       if (!h || !buffer || buflen != sizeof(int) )
1296         return GPG_ERR_INV_ARG;
1297       switch (h->mode)
1298         {
1299         case GCRY_CIPHER_MODE_OCB:
1300           switch (*(int*)buffer)
1301             {
1302             case 8: case 12: case 16:
1303               h->u_mode.ocb.taglen = *(int*)buffer;
1304               break;
1305             default:
1306               rc = GPG_ERR_INV_LENGTH; /* Invalid tag length. */
1307               break;
1308             }
1309           break;
1310
1311         default:
1312           rc =GPG_ERR_INV_CIPHER_MODE;
1313           break;
1314         }
1315       break;
1316
1317     case GCRYCTL_DISABLE_ALGO:
1318       /* This command expects NULL for H and BUFFER to point to an
1319          integer with the algo number.  */
1320       if( h || !buffer || buflen != sizeof(int) )
1321         return GPG_ERR_CIPHER_ALGO;
1322       disable_cipher_algo( *(int*)buffer );
1323       break;
1324
1325     case PRIV_CIPHERCTL_DISABLE_WEAK_KEY:  /* (private)  */
1326       if (h->spec->set_extra_info)
1327         rc = h->spec->set_extra_info
1328           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1329       else
1330         rc = GPG_ERR_NOT_SUPPORTED;
1331       break;
1332
1333     case PRIV_CIPHERCTL_GET_INPUT_VECTOR: /* (private)  */
1334       /* This is the input block as used in CFB and OFB mode which has
1335          initially been set as IV.  The returned format is:
1336            1 byte  Actual length of the block in bytes.
1337            n byte  The block.
1338          If the provided buffer is too short, an error is returned. */
1339       if (buflen < (1 + h->spec->blocksize))
1340         rc = GPG_ERR_TOO_SHORT;
1341       else
1342         {
1343           unsigned char *ivp;
1344           unsigned char *dst = buffer;
1345           int n = h->unused;
1346
1347           if (!n)
1348             n = h->spec->blocksize;
1349           gcry_assert (n <= h->spec->blocksize);
1350           *dst++ = n;
1351           ivp = h->u_iv.iv + h->spec->blocksize - n;
1352           while (n--)
1353             *dst++ = *ivp++;
1354         }
1355       break;
1356
1357     case GCRYCTL_SET_SBOX:
1358       if (h->spec->set_extra_info)
1359         rc = h->spec->set_extra_info
1360           (&h->context.c, GCRYCTL_SET_SBOX, buffer, buflen);
1361       else
1362         rc = GPG_ERR_NOT_SUPPORTED;
1363       break;
1364
1365     default:
1366       rc = GPG_ERR_INV_OP;
1367     }
1368
1369   return rc;
1370 }
1371
1372
1373 /* Return information about the cipher handle H.  CMD is the kind of
1374    information requested.  BUFFER and NBYTES are reserved for now.
1375
1376    There are no values for CMD yet defined.
1377
1378    The function always returns GPG_ERR_INV_OP.
1379
1380  */
1381 gcry_err_code_t
1382 _gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1383 {
1384   gcry_err_code_t rc = 0;
1385
1386   (void)h;
1387   (void)buffer;
1388   (void)nbytes;
1389
1390   switch (cmd)
1391     {
1392     default:
1393       rc = GPG_ERR_INV_OP;
1394     }
1395
1396   return rc;
1397 }
1398
1399 /* Return information about the given cipher algorithm ALGO.
1400
1401    WHAT select the kind of information returned:
1402
1403     GCRYCTL_GET_KEYLEN:
1404         Return the length of the key.  If the algorithm ALGO
1405         supports multiple key lengths, the maximum supported key length
1406         is returned.  The key length is returned as number of octets.
1407         BUFFER and NBYTES must be zero.
1408
1409     GCRYCTL_GET_BLKLEN:
1410         Return the blocklength of the algorithm ALGO counted in octets.
1411         BUFFER and NBYTES must be zero.
1412
1413     GCRYCTL_TEST_ALGO:
1414         Returns 0 if the specified algorithm ALGO is available for use.
1415         BUFFER and NBYTES must be zero.
1416
1417    Note: Because this function is in most cases used to return an
1418    integer value, we can make it easier for the caller to just look at
1419    the return value.  The caller will in all cases consult the value
1420    and thereby detecting whether a error occurred or not (i.e. while
1421    checking the block size)
1422  */
1423 gcry_err_code_t
1424 _gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1425 {
1426   gcry_err_code_t rc = 0;
1427   unsigned int ui;
1428
1429   switch (what)
1430     {
1431     case GCRYCTL_GET_KEYLEN:
1432       if (buffer || (! nbytes))
1433         rc = GPG_ERR_CIPHER_ALGO;
1434       else
1435         {
1436           ui = cipher_get_keylen (algo);
1437           if ((ui > 0) && (ui <= 512))
1438             *nbytes = (size_t) ui / 8;
1439           else
1440             /* The only reason for an error is an invalid algo.  */
1441             rc = GPG_ERR_CIPHER_ALGO;
1442         }
1443       break;
1444
1445     case GCRYCTL_GET_BLKLEN:
1446       if (buffer || (! nbytes))
1447         rc = GPG_ERR_CIPHER_ALGO;
1448       else
1449         {
1450           ui = cipher_get_blocksize (algo);
1451           if ((ui > 0) && (ui < 10000))
1452             *nbytes = ui;
1453           else
1454             {
1455               /* The only reason is an invalid algo or a strange
1456                  blocksize.  */
1457               rc = GPG_ERR_CIPHER_ALGO;
1458             }
1459         }
1460       break;
1461
1462     case GCRYCTL_TEST_ALGO:
1463       if (buffer || nbytes)
1464         rc = GPG_ERR_INV_ARG;
1465       else
1466         rc = check_cipher_algo (algo);
1467       break;
1468
1469       default:
1470         rc = GPG_ERR_INV_OP;
1471     }
1472
1473   return rc;
1474 }
1475
1476
1477 /* This function returns length of the key for algorithm ALGO.  If the
1478    algorithm supports multiple key lengths, the maximum supported key
1479    length is returned.  On error 0 is returned.  The key length is
1480    returned as number of octets.
1481
1482    This is a convenience functions which should be preferred over
1483    gcry_cipher_algo_info because it allows for proper type
1484    checking.  */
1485 size_t
1486 _gcry_cipher_get_algo_keylen (int algo)
1487 {
1488   size_t n;
1489
1490   if (_gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1491     n = 0;
1492   return n;
1493 }
1494
1495
1496 /* This functions returns the blocklength of the algorithm ALGO
1497    counted in octets.  On error 0 is returned.
1498
1499    This is a convenience functions which should be preferred over
1500    gcry_cipher_algo_info because it allows for proper type
1501    checking.  */
1502 size_t
1503 _gcry_cipher_get_algo_blklen (int algo)
1504 {
1505   size_t n;
1506
1507   if (_gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1508     n = 0;
1509   return n;
1510 }
1511
1512
1513 /* Explicitly initialize this module.  */
1514 gcry_err_code_t
1515 _gcry_cipher_init (void)
1516 {
1517   return 0;
1518 }
1519
1520
1521 /* Run the selftests for cipher algorithm ALGO with optional reporting
1522    function REPORT.  */
1523 gpg_error_t
1524 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
1525 {
1526   gcry_err_code_t ec = 0;
1527   gcry_cipher_spec_t *spec;
1528
1529   spec = spec_from_algo (algo);
1530   if (spec && !spec->flags.disabled && spec->selftest)
1531     ec = spec->selftest (algo, extended, report);
1532   else
1533     {
1534       ec = GPG_ERR_CIPHER_ALGO;
1535       if (report)
1536         report ("cipher", algo, "module",
1537                 (spec && !spec->flags.disabled)?
1538                 "no selftest available" :
1539                 spec? "algorithm disabled" : "algorithm not found");
1540     }
1541
1542   return gpg_error (ec);
1543 }