Cast pointers to integers using uintptr_t instead of long
[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               break;
539 #endif /*USE_CAMELLIA*/
540 #ifdef USE_DES
541             case GCRY_CIPHER_3DES:
542               h->bulk.cbc_dec =  _gcry_3des_cbc_dec;
543               h->bulk.cfb_dec =  _gcry_3des_cfb_dec;
544               h->bulk.ctr_enc =  _gcry_3des_ctr_enc;
545               break;
546 #endif /*USE_DES*/
547 #ifdef USE_SERPENT
548             case GCRY_CIPHER_SERPENT128:
549             case GCRY_CIPHER_SERPENT192:
550             case GCRY_CIPHER_SERPENT256:
551               h->bulk.cbc_dec = _gcry_serpent_cbc_dec;
552               h->bulk.cfb_dec = _gcry_serpent_cfb_dec;
553               h->bulk.ctr_enc = _gcry_serpent_ctr_enc;
554               break;
555 #endif /*USE_SERPENT*/
556 #ifdef USE_TWOFISH
557             case GCRY_CIPHER_TWOFISH:
558             case GCRY_CIPHER_TWOFISH128:
559               h->bulk.cbc_dec = _gcry_twofish_cbc_dec;
560               h->bulk.cfb_dec = _gcry_twofish_cfb_dec;
561               h->bulk.ctr_enc = _gcry_twofish_ctr_enc;
562               break;
563 #endif /*USE_TWOFISH*/
564
565             default:
566               break;
567             }
568
569           /* Setup defaults depending on the mode.  */
570           switch (mode)
571             {
572             case GCRY_CIPHER_MODE_OCB:
573               h->u_mode.ocb.taglen = 16; /* Bytes.  */
574               break;
575
576             default:
577               break;
578             }
579
580         }
581     }
582
583   /* Done.  */
584
585   *handle = err ? NULL : h;
586
587   return gcry_error (err);
588 }
589
590
591 /* Release all resources associated with the cipher handle H. H may be
592    NULL in which case this is a no-operation. */
593 void
594 _gcry_cipher_close (gcry_cipher_hd_t h)
595 {
596   size_t off;
597
598   if (!h)
599     return;
600
601   if ((h->magic != CTX_MAGIC_SECURE)
602       && (h->magic != CTX_MAGIC_NORMAL))
603     _gcry_fatal_error(GPG_ERR_INTERNAL,
604                       "gcry_cipher_close: already closed/invalid handle");
605   else
606     h->magic = 0;
607
608   /* We always want to wipe out the memory even when the context has
609      been allocated in secure memory.  The user might have disabled
610      secure memory or is using his own implementation which does not
611      do the wiping.  To accomplish this we need to keep track of the
612      actual size of this structure because we have no way to known
613      how large the allocated area was when using a standard malloc. */
614   off = h->handle_offset;
615   wipememory (h, h->actual_handle_size);
616
617   xfree ((char*)h - off);
618 }
619
620
621 /* Set the key to be used for the encryption context C to KEY with
622    length KEYLEN.  The length should match the required length. */
623 static gcry_err_code_t
624 cipher_setkey (gcry_cipher_hd_t c, byte *key, size_t keylen)
625 {
626   gcry_err_code_t rc;
627
628   rc = c->spec->setkey (&c->context.c, key, keylen);
629   if (!rc)
630     {
631       /* Duplicate initial context.  */
632       memcpy ((void *) ((char *) &c->context.c + c->spec->contextsize),
633               (void *) &c->context.c,
634               c->spec->contextsize);
635       c->marks.key = 1;
636
637       switch (c->mode)
638         {
639         case GCRY_CIPHER_MODE_CMAC:
640           _gcry_cipher_cmac_set_subkeys (c);
641           break;
642
643         case GCRY_CIPHER_MODE_GCM:
644           _gcry_cipher_gcm_setkey (c);
645           break;
646
647         case GCRY_CIPHER_MODE_POLY1305:
648           _gcry_cipher_poly1305_setkey (c);
649           break;
650
651         default:
652           break;
653         };
654     }
655   else
656     c->marks.key = 0;
657
658   return rc;
659 }
660
661
662 /* Set the IV to be used for the encryption context C to IV with
663    length IVLEN.  The length should match the required length. */
664 static gcry_err_code_t
665 cipher_setiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
666 {
667   /* If the cipher has its own IV handler, we use only this one.  This
668      is currently used for stream ciphers requiring a nonce.  */
669   if (c->spec->setiv)
670     {
671       c->spec->setiv (&c->context.c, iv, ivlen);
672       return 0;
673     }
674
675   memset (c->u_iv.iv, 0, c->spec->blocksize);
676   if (iv)
677     {
678       if (ivlen != c->spec->blocksize)
679         {
680           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
681                     (unsigned int)ivlen, (unsigned int)c->spec->blocksize);
682           fips_signal_error ("IV length does not match blocklength");
683         }
684       if (ivlen > c->spec->blocksize)
685         ivlen = c->spec->blocksize;
686       memcpy (c->u_iv.iv, iv, ivlen);
687       c->marks.iv = 1;
688     }
689   else
690       c->marks.iv = 0;
691   c->unused = 0;
692
693   return 0;
694 }
695
696
697 /* Reset the cipher context to the initial context.  This is basically
698    the same as an release followed by a new. */
699 static void
700 cipher_reset (gcry_cipher_hd_t c)
701 {
702   unsigned int marks_key;
703
704   marks_key = c->marks.key;
705
706   memcpy (&c->context.c,
707           (char *) &c->context.c + c->spec->contextsize,
708           c->spec->contextsize);
709   memset (&c->marks, 0, sizeof c->marks);
710   memset (c->u_iv.iv, 0, c->spec->blocksize);
711   memset (c->lastiv, 0, c->spec->blocksize);
712   memset (c->u_ctr.ctr, 0, c->spec->blocksize);
713   c->unused = 0;
714
715   c->marks.key = marks_key;
716
717   switch (c->mode)
718     {
719     case GCRY_CIPHER_MODE_CMAC:
720       /* Only clear 'tag' for cmac, keep subkeys. */
721       c->u_mode.cmac.tag = 0;
722       break;
723
724     case GCRY_CIPHER_MODE_GCM:
725       /* Only clear head of u_mode, keep ghash_key and gcm_table. */
726       {
727         byte *u_mode_pos = (void *)&c->u_mode;
728         byte *ghash_key_pos = c->u_mode.gcm.u_ghash_key.key;
729         size_t u_mode_head_length = ghash_key_pos - u_mode_pos;
730
731         memset (&c->u_mode, 0, u_mode_head_length);
732       }
733       break;
734
735     case GCRY_CIPHER_MODE_POLY1305:
736       memset (&c->u_mode.poly1305, 0, sizeof c->u_mode.poly1305);
737       break;
738
739 #ifdef HAVE_U64_TYPEDEF
740     case GCRY_CIPHER_MODE_CCM:
741       memset (&c->u_mode.ccm, 0, sizeof c->u_mode.ccm);
742       break;
743 #endif
744
745     case GCRY_CIPHER_MODE_OCB:
746       memset (&c->u_mode.ocb, 0, sizeof c->u_mode.ocb);
747       /* Setup default taglen.  */
748       c->u_mode.ocb.taglen = 16;
749       break;
750
751     default:
752       break; /* u_mode unused by other modes. */
753     }
754 }
755
756
757 \f
758 static gcry_err_code_t
759 do_ecb_crypt (gcry_cipher_hd_t c,
760               unsigned char *outbuf, size_t outbuflen,
761               const unsigned char *inbuf, size_t inbuflen,
762               gcry_cipher_encrypt_t crypt_fn)
763 {
764   unsigned int blocksize = c->spec->blocksize;
765   size_t n, nblocks;
766   unsigned int burn, nburn;
767
768   if (outbuflen < inbuflen)
769     return GPG_ERR_BUFFER_TOO_SHORT;
770   if ((inbuflen % blocksize))
771     return GPG_ERR_INV_LENGTH;
772
773   nblocks = inbuflen / blocksize;
774   burn = 0;
775
776   for (n=0; n < nblocks; n++ )
777     {
778       nburn = crypt_fn (&c->context.c, outbuf, inbuf);
779       burn = nburn > burn ? nburn : burn;
780       inbuf  += blocksize;
781       outbuf += blocksize;
782     }
783
784   if (burn > 0)
785     _gcry_burn_stack (burn + 4 * sizeof(void *));
786
787   return 0;
788 }
789
790 static gcry_err_code_t
791 do_ecb_encrypt (gcry_cipher_hd_t c,
792                 unsigned char *outbuf, size_t outbuflen,
793                 const unsigned char *inbuf, size_t inbuflen)
794 {
795   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->encrypt);
796 }
797
798 static gcry_err_code_t
799 do_ecb_decrypt (gcry_cipher_hd_t c,
800                 unsigned char *outbuf, size_t outbuflen,
801                 const unsigned char *inbuf, size_t inbuflen)
802 {
803   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->decrypt);
804 }
805
806
807 /****************
808  * Encrypt INBUF to OUTBUF with the mode selected at open.
809  * inbuf and outbuf may overlap or be the same.
810  * Depending on the mode some constraints apply to INBUFLEN.
811  */
812 static gcry_err_code_t
813 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
814                 const byte *inbuf, size_t inbuflen)
815 {
816   gcry_err_code_t rc;
817
818   switch (c->mode)
819     {
820     case GCRY_CIPHER_MODE_ECB:
821       rc = do_ecb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
822       break;
823
824     case GCRY_CIPHER_MODE_CBC:
825       rc = _gcry_cipher_cbc_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
826       break;
827
828     case GCRY_CIPHER_MODE_CFB:
829       rc = _gcry_cipher_cfb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
830       break;
831
832     case GCRY_CIPHER_MODE_OFB:
833       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
834       break;
835
836     case GCRY_CIPHER_MODE_CTR:
837       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
838       break;
839
840     case GCRY_CIPHER_MODE_AESWRAP:
841       rc = _gcry_cipher_aeswrap_encrypt (c, outbuf, outbuflen,
842                                          inbuf, inbuflen);
843       break;
844
845     case GCRY_CIPHER_MODE_CCM:
846       rc = _gcry_cipher_ccm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
847       break;
848
849     case GCRY_CIPHER_MODE_CMAC:
850       rc = GPG_ERR_INV_CIPHER_MODE;
851       break;
852
853     case GCRY_CIPHER_MODE_GCM:
854       rc = _gcry_cipher_gcm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
855       break;
856
857     case GCRY_CIPHER_MODE_POLY1305:
858       rc = _gcry_cipher_poly1305_encrypt (c, outbuf, outbuflen,
859                                           inbuf, inbuflen);
860       break;
861
862     case GCRY_CIPHER_MODE_OCB:
863       rc = _gcry_cipher_ocb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
864       break;
865
866     case GCRY_CIPHER_MODE_STREAM:
867       c->spec->stencrypt (&c->context.c,
868                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
869       rc = 0;
870       break;
871
872     case GCRY_CIPHER_MODE_NONE:
873       if (fips_mode () || !_gcry_get_debug_flag (0))
874         {
875           fips_signal_error ("cipher mode NONE used");
876           rc = GPG_ERR_INV_CIPHER_MODE;
877         }
878       else
879         {
880           if (inbuf != outbuf)
881             memmove (outbuf, inbuf, inbuflen);
882           rc = 0;
883         }
884       break;
885
886     default:
887       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
888       rc = GPG_ERR_INV_CIPHER_MODE;
889       break;
890     }
891
892   return rc;
893 }
894
895
896 /****************
897  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
898  * been requested.
899  */
900 gcry_err_code_t
901 _gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
902                       const void *in, size_t inlen)
903 {
904   gcry_err_code_t rc;
905
906   if (!in)  /* Caller requested in-place encryption.  */
907     {
908       in = out;
909       inlen = outsize;
910     }
911
912   rc = cipher_encrypt (h, out, outsize, in, inlen);
913
914   /* Failsafe: Make sure that the plaintext will never make it into
915      OUT if the encryption returned an error.  */
916   if (rc && out)
917     memset (out, 0x42, outsize);
918
919   return rc;
920 }
921
922
923
924 /****************
925  * Decrypt INBUF to OUTBUF with the mode selected at open.
926  * inbuf and outbuf may overlap or be the same.
927  * Depending on the mode some some contraints apply to INBUFLEN.
928  */
929 static gcry_err_code_t
930 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
931                 const byte *inbuf, size_t inbuflen)
932 {
933   gcry_err_code_t rc;
934
935   switch (c->mode)
936     {
937     case GCRY_CIPHER_MODE_ECB:
938       rc = do_ecb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
939       break;
940
941     case GCRY_CIPHER_MODE_CBC:
942       rc = _gcry_cipher_cbc_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
943       break;
944
945     case GCRY_CIPHER_MODE_CFB:
946       rc = _gcry_cipher_cfb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
947       break;
948
949     case GCRY_CIPHER_MODE_OFB:
950       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
951       break;
952
953     case GCRY_CIPHER_MODE_CTR:
954       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
955       break;
956
957     case GCRY_CIPHER_MODE_AESWRAP:
958       rc = _gcry_cipher_aeswrap_decrypt (c, outbuf, outbuflen,
959                                          inbuf, inbuflen);
960       break;
961
962     case GCRY_CIPHER_MODE_CCM:
963       rc = _gcry_cipher_ccm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
964       break;
965
966     case GCRY_CIPHER_MODE_CMAC:
967       rc = GPG_ERR_INV_CIPHER_MODE;
968       break;
969
970     case GCRY_CIPHER_MODE_GCM:
971       rc = _gcry_cipher_gcm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
972       break;
973
974     case GCRY_CIPHER_MODE_POLY1305:
975       rc = _gcry_cipher_poly1305_decrypt (c, outbuf, outbuflen,
976                                           inbuf, inbuflen);
977       break;
978
979     case GCRY_CIPHER_MODE_OCB:
980       rc = _gcry_cipher_ocb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
981       break;
982
983     case GCRY_CIPHER_MODE_STREAM:
984       c->spec->stdecrypt (&c->context.c,
985                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
986       rc = 0;
987       break;
988
989     case GCRY_CIPHER_MODE_NONE:
990       if (fips_mode () || !_gcry_get_debug_flag (0))
991         {
992           fips_signal_error ("cipher mode NONE used");
993           rc = GPG_ERR_INV_CIPHER_MODE;
994         }
995       else
996         {
997           if (inbuf != outbuf)
998             memmove (outbuf, inbuf, inbuflen);
999           rc = 0;
1000         }
1001       break;
1002
1003     default:
1004       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1005       rc = GPG_ERR_INV_CIPHER_MODE;
1006       break;
1007     }
1008
1009   return rc;
1010 }
1011
1012
1013 gcry_err_code_t
1014 _gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1015                       const void *in, size_t inlen)
1016 {
1017   if (!in) /* Caller requested in-place encryption. */
1018     {
1019       in = out;
1020       inlen = outsize;
1021     }
1022
1023   return cipher_decrypt (h, out, outsize, in, inlen);
1024 }
1025
1026
1027
1028 /****************
1029  * Used for PGP's somewhat strange CFB mode. Only works if
1030  * the corresponding flag is set.
1031  */
1032 static void
1033 cipher_sync (gcry_cipher_hd_t c)
1034 {
1035   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1036     {
1037       memmove (c->u_iv.iv + c->unused,
1038                c->u_iv.iv, c->spec->blocksize - c->unused);
1039       memcpy (c->u_iv.iv,
1040               c->lastiv + c->spec->blocksize - c->unused, c->unused);
1041       c->unused = 0;
1042     }
1043 }
1044
1045
1046 gcry_err_code_t
1047 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
1048 {
1049   return cipher_setkey (hd, (void*)key, keylen);
1050 }
1051
1052
1053 gcry_err_code_t
1054 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
1055 {
1056   gcry_err_code_t rc = 0;
1057
1058   switch (hd->mode)
1059     {
1060       case GCRY_CIPHER_MODE_CCM:
1061         rc = _gcry_cipher_ccm_set_nonce (hd, iv, ivlen);
1062         break;
1063
1064       case GCRY_CIPHER_MODE_GCM:
1065         rc =  _gcry_cipher_gcm_setiv (hd, iv, ivlen);
1066         break;
1067
1068       case GCRY_CIPHER_MODE_POLY1305:
1069         rc =  _gcry_cipher_poly1305_setiv (hd, iv, ivlen);
1070         break;
1071
1072       case GCRY_CIPHER_MODE_OCB:
1073         rc = _gcry_cipher_ocb_set_nonce (hd, iv, ivlen);
1074         break;
1075
1076       default:
1077         rc = cipher_setiv (hd, iv, ivlen);
1078         break;
1079     }
1080   return rc;
1081 }
1082
1083 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1084    block size length, or (NULL,0) to set the CTR to the all-zero
1085    block. */
1086 gpg_err_code_t
1087 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1088 {
1089   if (ctr && ctrlen == hd->spec->blocksize)
1090     {
1091       memcpy (hd->u_ctr.ctr, ctr, hd->spec->blocksize);
1092       hd->unused = 0;
1093     }
1094   else if (!ctr || !ctrlen)
1095     {
1096       memset (hd->u_ctr.ctr, 0, hd->spec->blocksize);
1097       hd->unused = 0;
1098     }
1099   else
1100     return GPG_ERR_INV_ARG;
1101
1102   return 0;
1103 }
1104
1105
1106 gcry_err_code_t
1107 _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
1108                            size_t abuflen)
1109 {
1110   gcry_err_code_t rc;
1111
1112   switch (hd->mode)
1113     {
1114     case GCRY_CIPHER_MODE_CCM:
1115       rc = _gcry_cipher_ccm_authenticate (hd, abuf, abuflen);
1116       break;
1117
1118     case GCRY_CIPHER_MODE_CMAC:
1119       rc = _gcry_cipher_cmac_authenticate (hd, abuf, abuflen);
1120       break;
1121
1122     case GCRY_CIPHER_MODE_GCM:
1123       rc = _gcry_cipher_gcm_authenticate (hd, abuf, abuflen);
1124       break;
1125
1126     case GCRY_CIPHER_MODE_POLY1305:
1127       rc = _gcry_cipher_poly1305_authenticate (hd, abuf, abuflen);
1128       break;
1129
1130     case GCRY_CIPHER_MODE_OCB:
1131       rc = _gcry_cipher_ocb_authenticate (hd, abuf, abuflen);
1132       break;
1133
1134     default:
1135       log_error ("gcry_cipher_authenticate: invalid mode %d\n", hd->mode);
1136       rc = GPG_ERR_INV_CIPHER_MODE;
1137       break;
1138     }
1139
1140   return rc;
1141 }
1142
1143
1144 gcry_err_code_t
1145 _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
1146 {
1147   gcry_err_code_t rc;
1148
1149   switch (hd->mode)
1150     {
1151     case GCRY_CIPHER_MODE_CCM:
1152       rc = _gcry_cipher_ccm_get_tag (hd, outtag, taglen);
1153       break;
1154
1155     case GCRY_CIPHER_MODE_CMAC:
1156       rc = _gcry_cipher_cmac_get_tag (hd, outtag, taglen);
1157       break;
1158
1159     case GCRY_CIPHER_MODE_GCM:
1160       rc = _gcry_cipher_gcm_get_tag (hd, outtag, taglen);
1161       break;
1162
1163     case GCRY_CIPHER_MODE_POLY1305:
1164       rc = _gcry_cipher_poly1305_get_tag (hd, outtag, taglen);
1165       break;
1166
1167     case GCRY_CIPHER_MODE_OCB:
1168       rc = _gcry_cipher_ocb_get_tag (hd, outtag, taglen);
1169       break;
1170
1171     default:
1172       log_error ("gcry_cipher_gettag: invalid mode %d\n", hd->mode);
1173       rc = GPG_ERR_INV_CIPHER_MODE;
1174       break;
1175     }
1176
1177   return rc;
1178 }
1179
1180
1181 gcry_err_code_t
1182 _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
1183 {
1184   gcry_err_code_t rc;
1185
1186   switch (hd->mode)
1187     {
1188     case GCRY_CIPHER_MODE_CCM:
1189       rc = _gcry_cipher_ccm_check_tag (hd, intag, taglen);
1190       break;
1191
1192     case GCRY_CIPHER_MODE_CMAC:
1193       rc = _gcry_cipher_cmac_check_tag (hd, intag, taglen);
1194       break;
1195
1196     case GCRY_CIPHER_MODE_GCM:
1197       rc = _gcry_cipher_gcm_check_tag (hd, intag, taglen);
1198       break;
1199
1200     case GCRY_CIPHER_MODE_POLY1305:
1201       rc = _gcry_cipher_poly1305_check_tag (hd, intag, taglen);
1202       break;
1203
1204     case GCRY_CIPHER_MODE_OCB:
1205       rc = _gcry_cipher_ocb_check_tag (hd, intag, taglen);
1206       break;
1207
1208     default:
1209       log_error ("gcry_cipher_checktag: invalid mode %d\n", hd->mode);
1210       rc = GPG_ERR_INV_CIPHER_MODE;
1211       break;
1212     }
1213
1214   return rc;
1215 }
1216
1217
1218 gcry_err_code_t
1219 _gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1220 {
1221   gcry_err_code_t rc = 0;
1222
1223   switch (cmd)
1224     {
1225     case GCRYCTL_RESET:
1226       cipher_reset (h);
1227       break;
1228
1229     case GCRYCTL_FINALIZE:
1230       if (!h || buffer || buflen)
1231         return GPG_ERR_INV_ARG;
1232       h->marks.finalize = 1;
1233       break;
1234
1235     case GCRYCTL_CFB_SYNC:
1236       cipher_sync( h );
1237       break;
1238
1239     case GCRYCTL_SET_CBC_CTS:
1240       if (buflen)
1241         if (h->flags & GCRY_CIPHER_CBC_MAC)
1242           rc = GPG_ERR_INV_FLAG;
1243         else
1244           h->flags |= GCRY_CIPHER_CBC_CTS;
1245       else
1246         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1247       break;
1248
1249     case GCRYCTL_SET_CBC_MAC:
1250       if (buflen)
1251         if (h->flags & GCRY_CIPHER_CBC_CTS)
1252           rc = GPG_ERR_INV_FLAG;
1253         else
1254           h->flags |= GCRY_CIPHER_CBC_MAC;
1255       else
1256         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1257       break;
1258
1259     case GCRYCTL_SET_CCM_LENGTHS:
1260 #ifdef HAVE_U64_TYPEDEF
1261       {
1262         u64 params[3];
1263         size_t encryptedlen;
1264         size_t aadlen;
1265         size_t authtaglen;
1266
1267         if (h->mode != GCRY_CIPHER_MODE_CCM)
1268           return gcry_error (GPG_ERR_INV_CIPHER_MODE);
1269
1270         if (!buffer || buflen != 3 * sizeof(u64))
1271           return gcry_error (GPG_ERR_INV_ARG);
1272
1273         /* This command is used to pass additional length parameters needed
1274            by CCM mode to initialize CBC-MAC.  */
1275         memcpy (params, buffer, sizeof(params));
1276         encryptedlen = params[0];
1277         aadlen = params[1];
1278         authtaglen = params[2];
1279
1280         rc = _gcry_cipher_ccm_set_lengths (h, encryptedlen, aadlen, authtaglen);
1281       }
1282 #else
1283       rc = GPG_ERR_NOT_SUPPORTED;
1284 #endif
1285       break;
1286
1287     case GCRYCTL_SET_TAGLEN:
1288       if (!h || !buffer || buflen != sizeof(int) )
1289         return GPG_ERR_INV_ARG;
1290       switch (h->mode)
1291         {
1292         case GCRY_CIPHER_MODE_OCB:
1293           switch (*(int*)buffer)
1294             {
1295             case 8: case 12: case 16:
1296               h->u_mode.ocb.taglen = *(int*)buffer;
1297               break;
1298             default:
1299               rc = GPG_ERR_INV_LENGTH; /* Invalid tag length. */
1300               break;
1301             }
1302           break;
1303
1304         default:
1305           rc =GPG_ERR_INV_CIPHER_MODE;
1306           break;
1307         }
1308       break;
1309
1310     case GCRYCTL_DISABLE_ALGO:
1311       /* This command expects NULL for H and BUFFER to point to an
1312          integer with the algo number.  */
1313       if( h || !buffer || buflen != sizeof(int) )
1314         return gcry_error (GPG_ERR_CIPHER_ALGO);
1315       disable_cipher_algo( *(int*)buffer );
1316       break;
1317
1318     case 61:  /* Disable weak key detection (private).  */
1319       if (h->spec->set_extra_info)
1320         rc = h->spec->set_extra_info
1321           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1322       else
1323         rc = GPG_ERR_NOT_SUPPORTED;
1324       break;
1325
1326     case 62: /* Return current input vector (private).  */
1327       /* This is the input block as used in CFB and OFB mode which has
1328          initially been set as IV.  The returned format is:
1329            1 byte  Actual length of the block in bytes.
1330            n byte  The block.
1331          If the provided buffer is too short, an error is returned. */
1332       if (buflen < (1 + h->spec->blocksize))
1333         rc = GPG_ERR_TOO_SHORT;
1334       else
1335         {
1336           unsigned char *ivp;
1337           unsigned char *dst = buffer;
1338           int n = h->unused;
1339
1340           if (!n)
1341             n = h->spec->blocksize;
1342           gcry_assert (n <= h->spec->blocksize);
1343           *dst++ = n;
1344           ivp = h->u_iv.iv + h->spec->blocksize - n;
1345           while (n--)
1346             *dst++ = *ivp++;
1347         }
1348       break;
1349
1350     case GCRYCTL_SET_SBOX:
1351       if (h->spec->set_extra_info)
1352         rc = h->spec->set_extra_info
1353           (&h->context.c, GCRYCTL_SET_SBOX, buffer, buflen);
1354       else
1355         rc = GPG_ERR_NOT_SUPPORTED;
1356
1357     default:
1358       rc = GPG_ERR_INV_OP;
1359     }
1360
1361   return rc;
1362 }
1363
1364
1365 /* Return information about the cipher handle H.  CMD is the kind of
1366    information requested.  BUFFER and NBYTES are reserved for now.
1367
1368    There are no values for CMD yet defined.
1369
1370    The function always returns GPG_ERR_INV_OP.
1371
1372  */
1373 gcry_err_code_t
1374 _gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1375 {
1376   gcry_err_code_t rc = 0;
1377
1378   (void)h;
1379   (void)buffer;
1380   (void)nbytes;
1381
1382   switch (cmd)
1383     {
1384     default:
1385       rc = GPG_ERR_INV_OP;
1386     }
1387
1388   return rc;
1389 }
1390
1391 /* Return information about the given cipher algorithm ALGO.
1392
1393    WHAT select the kind of information returned:
1394
1395     GCRYCTL_GET_KEYLEN:
1396         Return the length of the key.  If the algorithm ALGO
1397         supports multiple key lengths, the maximum supported key length
1398         is returned.  The key length is returned as number of octets.
1399         BUFFER and NBYTES must be zero.
1400
1401     GCRYCTL_GET_BLKLEN:
1402         Return the blocklength of the algorithm ALGO counted in octets.
1403         BUFFER and NBYTES must be zero.
1404
1405     GCRYCTL_TEST_ALGO:
1406         Returns 0 if the specified algorithm ALGO is available for use.
1407         BUFFER and NBYTES must be zero.
1408
1409    Note: Because this function is in most cases used to return an
1410    integer value, we can make it easier for the caller to just look at
1411    the return value.  The caller will in all cases consult the value
1412    and thereby detecting whether a error occurred or not (i.e. while
1413    checking the block size)
1414  */
1415 gcry_err_code_t
1416 _gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1417 {
1418   gcry_err_code_t rc = 0;
1419   unsigned int ui;
1420
1421   switch (what)
1422     {
1423     case GCRYCTL_GET_KEYLEN:
1424       if (buffer || (! nbytes))
1425         rc = GPG_ERR_CIPHER_ALGO;
1426       else
1427         {
1428           ui = cipher_get_keylen (algo);
1429           if ((ui > 0) && (ui <= 512))
1430             *nbytes = (size_t) ui / 8;
1431           else
1432             /* The only reason for an error is an invalid algo.  */
1433             rc = GPG_ERR_CIPHER_ALGO;
1434         }
1435       break;
1436
1437     case GCRYCTL_GET_BLKLEN:
1438       if (buffer || (! nbytes))
1439         rc = GPG_ERR_CIPHER_ALGO;
1440       else
1441         {
1442           ui = cipher_get_blocksize (algo);
1443           if ((ui > 0) && (ui < 10000))
1444             *nbytes = ui;
1445           else
1446             {
1447               /* The only reason is an invalid algo or a strange
1448                  blocksize.  */
1449               rc = GPG_ERR_CIPHER_ALGO;
1450             }
1451         }
1452       break;
1453
1454     case GCRYCTL_TEST_ALGO:
1455       if (buffer || nbytes)
1456         rc = GPG_ERR_INV_ARG;
1457       else
1458         rc = check_cipher_algo (algo);
1459       break;
1460
1461       default:
1462         rc = GPG_ERR_INV_OP;
1463     }
1464
1465   return rc;
1466 }
1467
1468
1469 /* This function returns length of the key for algorithm ALGO.  If the
1470    algorithm supports multiple key lengths, the maximum supported key
1471    length is returned.  On error 0 is returned.  The key length is
1472    returned as number of octets.
1473
1474    This is a convenience functions which should be preferred over
1475    gcry_cipher_algo_info because it allows for proper type
1476    checking.  */
1477 size_t
1478 _gcry_cipher_get_algo_keylen (int algo)
1479 {
1480   size_t n;
1481
1482   if (_gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1483     n = 0;
1484   return n;
1485 }
1486
1487
1488 /* This functions returns the blocklength of the algorithm ALGO
1489    counted in octets.  On error 0 is returned.
1490
1491    This is a convenience functions which should be preferred over
1492    gcry_cipher_algo_info because it allows for proper type
1493    checking.  */
1494 size_t
1495 _gcry_cipher_get_algo_blklen (int algo)
1496 {
1497   size_t n;
1498
1499   if (_gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1500     n = 0;
1501   return n;
1502 }
1503
1504
1505 /* Explicitly initialize this module.  */
1506 gcry_err_code_t
1507 _gcry_cipher_init (void)
1508 {
1509   return 0;
1510 }
1511
1512
1513 /* Run the selftests for cipher algorithm ALGO with optional reporting
1514    function REPORT.  */
1515 gpg_error_t
1516 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
1517 {
1518   gcry_err_code_t ec = 0;
1519   gcry_cipher_spec_t *spec;
1520
1521   spec = spec_from_algo (algo);
1522   if (spec && !spec->flags.disabled && spec->selftest)
1523     ec = spec->selftest (algo, extended, report);
1524   else
1525     {
1526       ec = GPG_ERR_CIPHER_ALGO;
1527       if (report)
1528         report ("cipher", algo, "module",
1529                 (spec && !spec->flags.disabled)?
1530                 "no selftest available" :
1531                 spec? "algorithm disabled" : "algorithm not found");
1532     }
1533
1534   return gpg_error (ec);
1535 }