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