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