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