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