Add PowerPC extra CFLAGS also for chacha20-ppc and crc-ppc
[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, c);
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_OCB:
820           _gcry_cipher_ocb_setkey (c);
821           break;
822
823         case GCRY_CIPHER_MODE_POLY1305:
824           _gcry_cipher_poly1305_setkey (c);
825           break;
826
827         case GCRY_CIPHER_MODE_XTS:
828           /* Setup tweak cipher with second part of XTS key. */
829           rc = c->spec->setkey (c->u_mode.xts.tweak_context, key + keylen,
830                                 keylen, c);
831           if (!rc)
832             {
833               /* Duplicate initial tweak context.  */
834               memcpy (c->u_mode.xts.tweak_context + c->spec->contextsize,
835                       c->u_mode.xts.tweak_context, c->spec->contextsize);
836             }
837           else
838             c->marks.key = 0;
839           break;
840
841         default:
842           break;
843         };
844     }
845   else
846     c->marks.key = 0;
847
848   return rc;
849 }
850
851
852 /* Set the IV to be used for the encryption context C to IV with
853    length IVLEN.  The length should match the required length. */
854 static gcry_err_code_t
855 cipher_setiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
856 {
857   /* If the cipher has its own IV handler, we use only this one.  This
858      is currently used for stream ciphers requiring a nonce.  */
859   if (c->spec->setiv)
860     {
861       c->spec->setiv (&c->context.c, iv, ivlen);
862       return 0;
863     }
864
865   memset (c->u_iv.iv, 0, c->spec->blocksize);
866   if (iv)
867     {
868       if (ivlen != c->spec->blocksize)
869         {
870           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
871                     (unsigned int)ivlen, (unsigned int)c->spec->blocksize);
872           fips_signal_error ("IV length does not match blocklength");
873         }
874       if (ivlen > c->spec->blocksize)
875         ivlen = c->spec->blocksize;
876       memcpy (c->u_iv.iv, iv, ivlen);
877       c->marks.iv = 1;
878     }
879   else
880       c->marks.iv = 0;
881   c->unused = 0;
882
883   return 0;
884 }
885
886
887 /* Reset the cipher context to the initial context.  This is basically
888    the same as an release followed by a new. */
889 static void
890 cipher_reset (gcry_cipher_hd_t c)
891 {
892   unsigned int marks_key;
893
894   marks_key = c->marks.key;
895
896   memcpy (&c->context.c,
897           (char *) &c->context.c + c->spec->contextsize,
898           c->spec->contextsize);
899   memset (&c->marks, 0, sizeof c->marks);
900   memset (c->u_iv.iv, 0, c->spec->blocksize);
901   memset (c->lastiv, 0, c->spec->blocksize);
902   memset (c->u_ctr.ctr, 0, c->spec->blocksize);
903   c->unused = 0;
904
905   c->marks.key = marks_key;
906
907   switch (c->mode)
908     {
909     case GCRY_CIPHER_MODE_CMAC:
910       _gcry_cmac_reset(&c->u_mode.cmac);
911       break;
912
913     case GCRY_CIPHER_MODE_EAX:
914       _gcry_cmac_reset(&c->u_mode.eax.cmac_header);
915       _gcry_cmac_reset(&c->u_mode.eax.cmac_ciphertext);
916       break;
917
918     case GCRY_CIPHER_MODE_GCM:
919       /* Only clear head of u_mode, keep ghash_key and gcm_table. */
920       {
921         byte *u_mode_pos = (void *)&c->u_mode;
922         byte *ghash_key_pos = c->u_mode.gcm.u_ghash_key.key;
923         size_t u_mode_head_length = ghash_key_pos - u_mode_pos;
924
925         memset (&c->u_mode, 0, u_mode_head_length);
926       }
927       break;
928
929     case GCRY_CIPHER_MODE_POLY1305:
930       memset (&c->u_mode.poly1305, 0, sizeof c->u_mode.poly1305);
931       break;
932
933     case GCRY_CIPHER_MODE_CCM:
934       memset (&c->u_mode.ccm, 0, sizeof c->u_mode.ccm);
935       break;
936
937     case GCRY_CIPHER_MODE_OCB:
938       /* Do not clear precalculated L-values */
939       {
940         byte *u_mode_head_pos = (void *)&c->u_mode.ocb;
941         byte *u_mode_tail_pos = (void *)&c->u_mode.ocb.tag;
942         size_t u_mode_head_length = u_mode_tail_pos - u_mode_head_pos;
943         size_t u_mode_tail_length = sizeof(c->u_mode.ocb) - u_mode_head_length;
944
945         memset (u_mode_tail_pos, 0, u_mode_tail_length);
946
947         /* Setup default taglen.  */
948         c->u_mode.ocb.taglen = 16;
949       }
950       break;
951
952     case GCRY_CIPHER_MODE_XTS:
953       memcpy (c->u_mode.xts.tweak_context,
954               c->u_mode.xts.tweak_context + c->spec->contextsize,
955               c->spec->contextsize);
956       break;
957
958     default:
959       break; /* u_mode unused by other modes. */
960     }
961 }
962
963
964 \f
965 static gcry_err_code_t
966 do_ecb_crypt (gcry_cipher_hd_t c,
967               unsigned char *outbuf, size_t outbuflen,
968               const unsigned char *inbuf, size_t inbuflen,
969               gcry_cipher_encrypt_t crypt_fn)
970 {
971   unsigned int blocksize = c->spec->blocksize;
972   size_t n, nblocks;
973   unsigned int burn, nburn;
974
975   if (outbuflen < inbuflen)
976     return GPG_ERR_BUFFER_TOO_SHORT;
977   if ((inbuflen % blocksize))
978     return GPG_ERR_INV_LENGTH;
979
980   nblocks = inbuflen / blocksize;
981   burn = 0;
982
983   for (n=0; n < nblocks; n++ )
984     {
985       nburn = crypt_fn (&c->context.c, outbuf, inbuf);
986       burn = nburn > burn ? nburn : burn;
987       inbuf  += blocksize;
988       outbuf += blocksize;
989     }
990
991   if (burn > 0)
992     _gcry_burn_stack (burn + 4 * sizeof(void *));
993
994   return 0;
995 }
996
997 static gcry_err_code_t
998 do_ecb_encrypt (gcry_cipher_hd_t c,
999                 unsigned char *outbuf, size_t outbuflen,
1000                 const unsigned char *inbuf, size_t inbuflen)
1001 {
1002   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->encrypt);
1003 }
1004
1005 static gcry_err_code_t
1006 do_ecb_decrypt (gcry_cipher_hd_t c,
1007                 unsigned char *outbuf, size_t outbuflen,
1008                 const unsigned char *inbuf, size_t inbuflen)
1009 {
1010   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->decrypt);
1011 }
1012
1013
1014 static gcry_err_code_t
1015 do_stream_encrypt (gcry_cipher_hd_t c,
1016                 unsigned char *outbuf, size_t outbuflen,
1017                 const unsigned char *inbuf, size_t inbuflen)
1018 {
1019   (void)outbuflen;
1020   c->spec->stencrypt (&c->context.c, outbuf, (void *)inbuf, inbuflen);
1021   return 0;
1022 }
1023
1024 static gcry_err_code_t
1025 do_stream_decrypt (gcry_cipher_hd_t c,
1026                 unsigned char *outbuf, size_t outbuflen,
1027                 const unsigned char *inbuf, size_t inbuflen)
1028 {
1029   (void)outbuflen;
1030   c->spec->stdecrypt (&c->context.c, outbuf, (void *)inbuf, inbuflen);
1031   return 0;
1032 }
1033
1034
1035 static gcry_err_code_t
1036 do_encrypt_none_unknown (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
1037                          const byte *inbuf, size_t inbuflen)
1038 {
1039   gcry_err_code_t rc;
1040
1041   (void)outbuflen;
1042
1043   switch (c->mode)
1044     {
1045     case GCRY_CIPHER_MODE_CMAC:
1046       rc = GPG_ERR_INV_CIPHER_MODE;
1047       break;
1048
1049     case GCRY_CIPHER_MODE_NONE:
1050       if (fips_mode () || !_gcry_get_debug_flag (0))
1051         {
1052           fips_signal_error ("cipher mode NONE used");
1053           rc = GPG_ERR_INV_CIPHER_MODE;
1054         }
1055       else
1056         {
1057           if (inbuf != outbuf)
1058             memmove (outbuf, inbuf, inbuflen);
1059           rc = 0;
1060         }
1061       break;
1062
1063     default:
1064       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
1065       rc = GPG_ERR_INV_CIPHER_MODE;
1066       break;
1067     }
1068
1069   return rc;
1070 }
1071
1072 static gcry_err_code_t
1073 do_decrypt_none_unknown (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
1074                          const byte *inbuf, size_t inbuflen)
1075 {
1076   gcry_err_code_t rc;
1077
1078   (void)outbuflen;
1079
1080   switch (c->mode)
1081     {
1082     case GCRY_CIPHER_MODE_CMAC:
1083       rc = GPG_ERR_INV_CIPHER_MODE;
1084       break;
1085
1086     case GCRY_CIPHER_MODE_NONE:
1087       if (fips_mode () || !_gcry_get_debug_flag (0))
1088         {
1089           fips_signal_error ("cipher mode NONE used");
1090           rc = GPG_ERR_INV_CIPHER_MODE;
1091         }
1092       else
1093         {
1094           if (inbuf != outbuf)
1095             memmove (outbuf, inbuf, inbuflen);
1096           rc = 0;
1097         }
1098       break;
1099
1100     default:
1101       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1102       rc = GPG_ERR_INV_CIPHER_MODE;
1103       break;
1104     }
1105
1106   return rc;
1107 }
1108
1109
1110 /****************
1111  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
1112  * been requested.
1113  */
1114 gcry_err_code_t
1115 _gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1116                       const void *in, size_t inlen)
1117 {
1118   gcry_err_code_t rc;
1119
1120   if (!in)  /* Caller requested in-place encryption.  */
1121     {
1122       in = out;
1123       inlen = outsize;
1124     }
1125
1126   if (h->mode != GCRY_CIPHER_MODE_NONE && !h->marks.key)
1127     {
1128       log_error ("cipher_decrypt: key not set\n");
1129       return GPG_ERR_MISSING_KEY;
1130     }
1131
1132   rc = h->mode_ops.encrypt (h, out, outsize, in, inlen);
1133
1134   /* Failsafe: Make sure that the plaintext will never make it into
1135      OUT if the encryption returned an error.  */
1136   if (rc && out)
1137     memset (out, 0x42, outsize);
1138
1139   return rc;
1140 }
1141
1142
1143 /****************
1144  * Decrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
1145  * been requested.
1146  */
1147 gcry_err_code_t
1148 _gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1149                       const void *in, size_t inlen)
1150 {
1151   if (!in) /* Caller requested in-place encryption. */
1152     {
1153       in = out;
1154       inlen = outsize;
1155     }
1156
1157   if (h->mode != GCRY_CIPHER_MODE_NONE && !h->marks.key)
1158     {
1159       log_error ("cipher_decrypt: key not set\n");
1160       return GPG_ERR_MISSING_KEY;
1161     }
1162
1163   return h->mode_ops.decrypt (h, out, outsize, in, inlen);
1164 }
1165
1166
1167 /****************
1168  * Used for PGP's somewhat strange CFB mode. Only works if
1169  * the corresponding flag is set.
1170  */
1171 static void
1172 cipher_sync (gcry_cipher_hd_t c)
1173 {
1174   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1175     {
1176       memmove (c->u_iv.iv + c->unused,
1177                c->u_iv.iv, c->spec->blocksize - c->unused);
1178       memcpy (c->u_iv.iv,
1179               c->lastiv + c->spec->blocksize - c->unused, c->unused);
1180       c->unused = 0;
1181     }
1182 }
1183
1184
1185 gcry_err_code_t
1186 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
1187 {
1188   return cipher_setkey (hd, (void*)key, keylen);
1189 }
1190
1191
1192 gcry_err_code_t
1193 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
1194 {
1195   return hd->mode_ops.setiv (hd, iv, ivlen);
1196 }
1197
1198
1199 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1200    block size length, or (NULL,0) to set the CTR to the all-zero
1201    block. */
1202 gpg_err_code_t
1203 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1204 {
1205   if (ctr && ctrlen == hd->spec->blocksize)
1206     {
1207       memcpy (hd->u_ctr.ctr, ctr, hd->spec->blocksize);
1208       hd->unused = 0;
1209     }
1210   else if (!ctr || !ctrlen)
1211     {
1212       memset (hd->u_ctr.ctr, 0, hd->spec->blocksize);
1213       hd->unused = 0;
1214     }
1215   else
1216     return GPG_ERR_INV_ARG;
1217
1218   return 0;
1219 }
1220
1221 gpg_err_code_t
1222 _gcry_cipher_getctr (gcry_cipher_hd_t hd, void *ctr, size_t ctrlen)
1223 {
1224   if (ctr && ctrlen == hd->spec->blocksize)
1225     memcpy (ctr, hd->u_ctr.ctr, hd->spec->blocksize);
1226   else
1227     return GPG_ERR_INV_ARG;
1228
1229   return 0;
1230 }
1231
1232
1233 gcry_err_code_t
1234 _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
1235                            size_t abuflen)
1236 {
1237   gcry_err_code_t rc;
1238
1239   if (hd->mode_ops.authenticate)
1240     {
1241       rc = hd->mode_ops.authenticate (hd, abuf, abuflen);
1242     }
1243   else
1244     {
1245       log_error ("gcry_cipher_authenticate: invalid mode %d\n", hd->mode);
1246       rc = GPG_ERR_INV_CIPHER_MODE;
1247     }
1248
1249   return rc;
1250 }
1251
1252
1253 gcry_err_code_t
1254 _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
1255 {
1256   gcry_err_code_t rc;
1257
1258   if (hd->mode_ops.get_tag)
1259     {
1260       rc = hd->mode_ops.get_tag (hd, outtag, taglen);
1261     }
1262   else
1263     {
1264       log_error ("gcry_cipher_gettag: invalid mode %d\n", hd->mode);
1265       rc = GPG_ERR_INV_CIPHER_MODE;
1266     }
1267
1268   return rc;
1269 }
1270
1271
1272 gcry_err_code_t
1273 _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
1274 {
1275   gcry_err_code_t rc;
1276
1277   if (hd->mode_ops.check_tag)
1278     {
1279       rc = hd->mode_ops.check_tag (hd, intag, taglen);
1280     }
1281   else
1282     {
1283       log_error ("gcry_cipher_checktag: invalid mode %d\n", hd->mode);
1284       rc = GPG_ERR_INV_CIPHER_MODE;
1285     }
1286
1287   return rc;
1288 }
1289
1290
1291
1292 static void
1293 _gcry_cipher_setup_mode_ops(gcry_cipher_hd_t c, int mode)
1294 {
1295   /* Setup encryption and decryption routines. */
1296   switch (mode)
1297     {
1298     case GCRY_CIPHER_MODE_STREAM:
1299       c->mode_ops.encrypt = do_stream_encrypt;
1300       c->mode_ops.decrypt = do_stream_decrypt;
1301       break;
1302
1303     case GCRY_CIPHER_MODE_ECB:
1304       c->mode_ops.encrypt = do_ecb_encrypt;
1305       c->mode_ops.decrypt = do_ecb_decrypt;
1306       break;
1307
1308     case GCRY_CIPHER_MODE_CBC:
1309       if (!(c->flags & GCRY_CIPHER_CBC_CTS))
1310         {
1311           c->mode_ops.encrypt = _gcry_cipher_cbc_encrypt;
1312           c->mode_ops.decrypt = _gcry_cipher_cbc_decrypt;
1313         }
1314       else
1315         {
1316           c->mode_ops.encrypt = _gcry_cipher_cbc_cts_encrypt;
1317           c->mode_ops.decrypt = _gcry_cipher_cbc_cts_decrypt;
1318         }
1319       break;
1320
1321     case GCRY_CIPHER_MODE_CFB:
1322       c->mode_ops.encrypt = _gcry_cipher_cfb_encrypt;
1323       c->mode_ops.decrypt = _gcry_cipher_cfb_decrypt;
1324       break;
1325
1326     case GCRY_CIPHER_MODE_CFB8:
1327       c->mode_ops.encrypt = _gcry_cipher_cfb8_encrypt;
1328       c->mode_ops.decrypt = _gcry_cipher_cfb8_decrypt;
1329       break;
1330
1331     case GCRY_CIPHER_MODE_OFB:
1332       c->mode_ops.encrypt = _gcry_cipher_ofb_encrypt;
1333       c->mode_ops.decrypt = _gcry_cipher_ofb_encrypt;
1334       break;
1335
1336     case GCRY_CIPHER_MODE_CTR:
1337       c->mode_ops.encrypt = _gcry_cipher_ctr_encrypt;
1338       c->mode_ops.decrypt = _gcry_cipher_ctr_encrypt;
1339       break;
1340
1341     case GCRY_CIPHER_MODE_AESWRAP:
1342       c->mode_ops.encrypt = _gcry_cipher_aeswrap_encrypt;
1343       c->mode_ops.decrypt = _gcry_cipher_aeswrap_decrypt;
1344       break;
1345
1346     case GCRY_CIPHER_MODE_CCM:
1347       c->mode_ops.encrypt = _gcry_cipher_ccm_encrypt;
1348       c->mode_ops.decrypt = _gcry_cipher_ccm_decrypt;
1349       break;
1350
1351     case GCRY_CIPHER_MODE_EAX:
1352       c->mode_ops.encrypt = _gcry_cipher_eax_encrypt;
1353       c->mode_ops.decrypt = _gcry_cipher_eax_decrypt;
1354       break;
1355
1356     case GCRY_CIPHER_MODE_GCM:
1357       c->mode_ops.encrypt = _gcry_cipher_gcm_encrypt;
1358       c->mode_ops.decrypt = _gcry_cipher_gcm_decrypt;
1359       break;
1360
1361     case GCRY_CIPHER_MODE_POLY1305:
1362       c->mode_ops.encrypt = _gcry_cipher_poly1305_encrypt;
1363       c->mode_ops.decrypt = _gcry_cipher_poly1305_decrypt;
1364       break;
1365
1366     case GCRY_CIPHER_MODE_OCB:
1367       c->mode_ops.encrypt = _gcry_cipher_ocb_encrypt;
1368       c->mode_ops.decrypt = _gcry_cipher_ocb_decrypt;
1369       break;
1370
1371     case GCRY_CIPHER_MODE_XTS:
1372       c->mode_ops.encrypt = _gcry_cipher_xts_encrypt;
1373       c->mode_ops.decrypt = _gcry_cipher_xts_decrypt;
1374       break;
1375
1376     default:
1377       c->mode_ops.encrypt = do_encrypt_none_unknown;
1378       c->mode_ops.decrypt = do_decrypt_none_unknown;
1379       break;
1380     }
1381
1382   /* Setup IV setting routine. */
1383   switch (mode)
1384     {
1385     case GCRY_CIPHER_MODE_CCM:
1386       c->mode_ops.setiv = _gcry_cipher_ccm_set_nonce;
1387       break;
1388
1389     case GCRY_CIPHER_MODE_EAX:
1390       c->mode_ops.setiv = _gcry_cipher_eax_set_nonce;
1391       break;
1392
1393     case GCRY_CIPHER_MODE_GCM:
1394       c->mode_ops.setiv =  _gcry_cipher_gcm_setiv;
1395       break;
1396
1397     case GCRY_CIPHER_MODE_POLY1305:
1398       c->mode_ops.setiv = _gcry_cipher_poly1305_setiv;
1399       break;
1400
1401     case GCRY_CIPHER_MODE_OCB:
1402       c->mode_ops.setiv = _gcry_cipher_ocb_set_nonce;
1403       break;
1404
1405     default:
1406       c->mode_ops.setiv = cipher_setiv;
1407       break;
1408     }
1409
1410
1411   /* Setup authentication routines for AEAD modes. */
1412   switch (mode)
1413     {
1414     case GCRY_CIPHER_MODE_CCM:
1415       c->mode_ops.authenticate = _gcry_cipher_ccm_authenticate;
1416       c->mode_ops.get_tag      = _gcry_cipher_ccm_get_tag;
1417       c->mode_ops.check_tag    = _gcry_cipher_ccm_check_tag;
1418       break;
1419
1420     case GCRY_CIPHER_MODE_CMAC:
1421       c->mode_ops.authenticate = _gcry_cipher_cmac_authenticate;
1422       c->mode_ops.get_tag      = _gcry_cipher_cmac_get_tag;
1423       c->mode_ops.check_tag    = _gcry_cipher_cmac_check_tag;
1424       break;
1425
1426     case GCRY_CIPHER_MODE_EAX:
1427       c->mode_ops.authenticate = _gcry_cipher_eax_authenticate;
1428       c->mode_ops.get_tag      = _gcry_cipher_eax_get_tag;
1429       c->mode_ops.check_tag    = _gcry_cipher_eax_check_tag;
1430       break;
1431
1432     case GCRY_CIPHER_MODE_GCM:
1433       c->mode_ops.authenticate = _gcry_cipher_gcm_authenticate;
1434       c->mode_ops.get_tag      = _gcry_cipher_gcm_get_tag;
1435       c->mode_ops.check_tag    = _gcry_cipher_gcm_check_tag;
1436       break;
1437
1438     case GCRY_CIPHER_MODE_POLY1305:
1439       c->mode_ops.authenticate = _gcry_cipher_poly1305_authenticate;
1440       c->mode_ops.get_tag      = _gcry_cipher_poly1305_get_tag;
1441       c->mode_ops.check_tag    = _gcry_cipher_poly1305_check_tag;
1442       break;
1443
1444     case GCRY_CIPHER_MODE_OCB:
1445       c->mode_ops.authenticate = _gcry_cipher_ocb_authenticate;
1446       c->mode_ops.get_tag      = _gcry_cipher_ocb_get_tag;
1447       c->mode_ops.check_tag    = _gcry_cipher_ocb_check_tag;
1448       break;
1449
1450     default:
1451       c->mode_ops.authenticate = NULL;
1452       c->mode_ops.get_tag      = NULL;
1453       c->mode_ops.check_tag    = NULL;
1454       break;
1455     }
1456 }
1457
1458
1459 gcry_err_code_t
1460 _gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1461 {
1462   gcry_err_code_t rc = 0;
1463
1464   switch (cmd)
1465     {
1466     case GCRYCTL_RESET:
1467       cipher_reset (h);
1468       break;
1469
1470     case GCRYCTL_FINALIZE:
1471       if (!h || buffer || buflen)
1472         return GPG_ERR_INV_ARG;
1473       h->marks.finalize = 1;
1474       break;
1475
1476     case GCRYCTL_CFB_SYNC:
1477       cipher_sync( h );
1478       break;
1479
1480     case GCRYCTL_SET_CBC_CTS:
1481       if (buflen)
1482         if (h->flags & GCRY_CIPHER_CBC_MAC)
1483           rc = GPG_ERR_INV_FLAG;
1484         else
1485           h->flags |= GCRY_CIPHER_CBC_CTS;
1486       else
1487         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1488       break;
1489
1490     case GCRYCTL_SET_CBC_MAC:
1491       if (buflen)
1492         if (h->flags & GCRY_CIPHER_CBC_CTS)
1493           rc = GPG_ERR_INV_FLAG;
1494         else
1495           h->flags |= GCRY_CIPHER_CBC_MAC;
1496       else
1497         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1498       break;
1499
1500     case GCRYCTL_SET_CCM_LENGTHS:
1501       {
1502         u64 params[3];
1503         size_t encryptedlen;
1504         size_t aadlen;
1505         size_t authtaglen;
1506
1507         if (h->mode != GCRY_CIPHER_MODE_CCM)
1508           return GPG_ERR_INV_CIPHER_MODE;
1509
1510         if (!buffer || buflen != 3 * sizeof(u64))
1511           return GPG_ERR_INV_ARG;
1512
1513         /* This command is used to pass additional length parameters needed
1514            by CCM mode to initialize CBC-MAC.  */
1515         memcpy (params, buffer, sizeof(params));
1516         encryptedlen = params[0];
1517         aadlen = params[1];
1518         authtaglen = params[2];
1519
1520         rc = _gcry_cipher_ccm_set_lengths (h, encryptedlen, aadlen, authtaglen);
1521       }
1522       break;
1523
1524     case GCRYCTL_SET_TAGLEN:
1525       if (!h || !buffer || buflen != sizeof(int) )
1526         return GPG_ERR_INV_ARG;
1527       switch (h->mode)
1528         {
1529         case GCRY_CIPHER_MODE_OCB:
1530           switch (*(int*)buffer)
1531             {
1532             case 8: case 12: case 16:
1533               h->u_mode.ocb.taglen = *(int*)buffer;
1534               break;
1535             default:
1536               rc = GPG_ERR_INV_LENGTH; /* Invalid tag length. */
1537               break;
1538             }
1539           break;
1540
1541         default:
1542           rc =GPG_ERR_INV_CIPHER_MODE;
1543           break;
1544         }
1545       break;
1546
1547     case GCRYCTL_DISABLE_ALGO:
1548       /* This command expects NULL for H and BUFFER to point to an
1549          integer with the algo number.  */
1550       if( h || !buffer || buflen != sizeof(int) )
1551         return GPG_ERR_CIPHER_ALGO;
1552       disable_cipher_algo( *(int*)buffer );
1553       break;
1554
1555     case PRIV_CIPHERCTL_DISABLE_WEAK_KEY:  /* (private)  */
1556       if (h->spec->set_extra_info)
1557         rc = h->spec->set_extra_info
1558           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1559       else
1560         rc = GPG_ERR_NOT_SUPPORTED;
1561       break;
1562
1563     case PRIV_CIPHERCTL_GET_INPUT_VECTOR: /* (private)  */
1564       /* This is the input block as used in CFB and OFB mode which has
1565          initially been set as IV.  The returned format is:
1566            1 byte  Actual length of the block in bytes.
1567            n byte  The block.
1568          If the provided buffer is too short, an error is returned. */
1569       if (buflen < (1 + h->spec->blocksize))
1570         rc = GPG_ERR_TOO_SHORT;
1571       else
1572         {
1573           unsigned char *ivp;
1574           unsigned char *dst = buffer;
1575           int n = h->unused;
1576
1577           if (!n)
1578             n = h->spec->blocksize;
1579           gcry_assert (n <= h->spec->blocksize);
1580           *dst++ = n;
1581           ivp = h->u_iv.iv + h->spec->blocksize - n;
1582           while (n--)
1583             *dst++ = *ivp++;
1584         }
1585       break;
1586
1587     case GCRYCTL_SET_SBOX:
1588       if (h->spec->set_extra_info)
1589         rc = h->spec->set_extra_info
1590           (&h->context.c, GCRYCTL_SET_SBOX, buffer, buflen);
1591       else
1592         rc = GPG_ERR_NOT_SUPPORTED;
1593       break;
1594
1595     default:
1596       rc = GPG_ERR_INV_OP;
1597     }
1598
1599   return rc;
1600 }
1601
1602
1603 /* Return information about the cipher handle H.  CMD is the kind of
1604  * information requested.
1605  *
1606  * CMD may be one of:
1607  *
1608  *  GCRYCTL_GET_TAGLEN:
1609  *      Return the length of the tag for an AE algorithm mode.  An
1610  *      error is returned for modes which do not support a tag.
1611  *      BUFFER must be given as NULL.  On success the result is stored
1612  *      at NBYTES.  The taglen is returned in bytes.
1613  *
1614  * The function returns 0 on success or an error code.
1615  */
1616 gcry_err_code_t
1617 _gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1618 {
1619   gcry_err_code_t rc = 0;
1620
1621   switch (cmd)
1622     {
1623     case GCRYCTL_GET_TAGLEN:
1624       if (!h || buffer || !nbytes)
1625         rc = GPG_ERR_INV_ARG;
1626       else
1627         {
1628           switch (h->mode)
1629             {
1630             case GCRY_CIPHER_MODE_OCB:
1631               *nbytes = h->u_mode.ocb.taglen;
1632               break;
1633
1634             case GCRY_CIPHER_MODE_CCM:
1635               *nbytes = h->u_mode.ccm.authlen;
1636               break;
1637
1638             case GCRY_CIPHER_MODE_EAX:
1639               *nbytes = h->spec->blocksize;
1640               break;
1641
1642             case GCRY_CIPHER_MODE_GCM:
1643               *nbytes = GCRY_GCM_BLOCK_LEN;
1644               break;
1645
1646             case GCRY_CIPHER_MODE_POLY1305:
1647               *nbytes = POLY1305_TAGLEN;
1648               break;
1649
1650             default:
1651               rc = GPG_ERR_INV_CIPHER_MODE;
1652               break;
1653             }
1654         }
1655       break;
1656
1657     default:
1658       rc = GPG_ERR_INV_OP;
1659     }
1660
1661   return rc;
1662 }
1663
1664 /* Return information about the given cipher algorithm ALGO.
1665
1666    WHAT select the kind of information returned:
1667
1668     GCRYCTL_GET_KEYLEN:
1669         Return the length of the key.  If the algorithm ALGO
1670         supports multiple key lengths, the maximum supported key length
1671         is returned.  The key length is returned as number of octets.
1672         BUFFER and NBYTES must be zero.
1673
1674     GCRYCTL_GET_BLKLEN:
1675         Return the blocklength of the algorithm ALGO counted in octets.
1676         BUFFER and NBYTES must be zero.
1677
1678     GCRYCTL_TEST_ALGO:
1679         Returns 0 if the specified algorithm ALGO is available for use.
1680         BUFFER and NBYTES must be zero.
1681
1682    Note: Because this function is in most cases used to return an
1683    integer value, we can make it easier for the caller to just look at
1684    the return value.  The caller will in all cases consult the value
1685    and thereby detecting whether a error occurred or not (i.e. while
1686    checking the block size)
1687  */
1688 gcry_err_code_t
1689 _gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1690 {
1691   gcry_err_code_t rc = 0;
1692   unsigned int ui;
1693
1694   switch (what)
1695     {
1696     case GCRYCTL_GET_KEYLEN:
1697       if (buffer || (! nbytes))
1698         rc = GPG_ERR_CIPHER_ALGO;
1699       else
1700         {
1701           ui = cipher_get_keylen (algo);
1702           if ((ui > 0) && (ui <= 512))
1703             *nbytes = (size_t) ui / 8;
1704           else
1705             /* The only reason for an error is an invalid algo.  */
1706             rc = GPG_ERR_CIPHER_ALGO;
1707         }
1708       break;
1709
1710     case GCRYCTL_GET_BLKLEN:
1711       if (buffer || (! nbytes))
1712         rc = GPG_ERR_CIPHER_ALGO;
1713       else
1714         {
1715           ui = cipher_get_blocksize (algo);
1716           if ((ui > 0) && (ui < 10000))
1717             *nbytes = ui;
1718           else
1719             {
1720               /* The only reason is an invalid algo or a strange
1721                  blocksize.  */
1722               rc = GPG_ERR_CIPHER_ALGO;
1723             }
1724         }
1725       break;
1726
1727     case GCRYCTL_TEST_ALGO:
1728       if (buffer || nbytes)
1729         rc = GPG_ERR_INV_ARG;
1730       else
1731         rc = check_cipher_algo (algo);
1732       break;
1733
1734       default:
1735         rc = GPG_ERR_INV_OP;
1736     }
1737
1738   return rc;
1739 }
1740
1741
1742 /* This function returns length of the key for algorithm ALGO.  If the
1743    algorithm supports multiple key lengths, the maximum supported key
1744    length is returned.  On error 0 is returned.  The key length is
1745    returned as number of octets.
1746
1747    This is a convenience functions which should be preferred over
1748    gcry_cipher_algo_info because it allows for proper type
1749    checking.  */
1750 size_t
1751 _gcry_cipher_get_algo_keylen (int algo)
1752 {
1753   size_t n;
1754
1755   if (_gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1756     n = 0;
1757   return n;
1758 }
1759
1760
1761 /* This functions returns the blocklength of the algorithm ALGO
1762    counted in octets.  On error 0 is returned.
1763
1764    This is a convenience functions which should be preferred over
1765    gcry_cipher_algo_info because it allows for proper type
1766    checking.  */
1767 size_t
1768 _gcry_cipher_get_algo_blklen (int algo)
1769 {
1770   size_t n;
1771
1772   if (_gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1773     n = 0;
1774   return n;
1775 }
1776
1777
1778 /* Explicitly initialize this module.  */
1779 gcry_err_code_t
1780 _gcry_cipher_init (void)
1781 {
1782   if (fips_mode())
1783     {
1784       /* disable algorithms that are disallowed in fips */
1785       int idx;
1786       gcry_cipher_spec_t *spec;
1787
1788       for (idx = 0; (spec = cipher_list[idx]); idx++)
1789         if (!spec->flags.fips)
1790           spec->flags.disabled = 1;
1791     }
1792
1793   return 0;
1794 }
1795
1796
1797 /* Run the selftests for cipher algorithm ALGO with optional reporting
1798    function REPORT.  */
1799 gpg_error_t
1800 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
1801 {
1802   gcry_err_code_t ec = 0;
1803   gcry_cipher_spec_t *spec;
1804
1805   spec = spec_from_algo (algo);
1806   if (spec && !spec->flags.disabled && spec->selftest)
1807     ec = spec->selftest (algo, extended, report);
1808   else
1809     {
1810       ec = GPG_ERR_CIPHER_ALGO;
1811       if (report)
1812         report ("cipher", algo, "module",
1813                 (spec && !spec->flags.disabled)?
1814                 "no selftest available" :
1815                 spec? "algorithm disabled" : "algorithm not found");
1816     }
1817
1818   return gpg_error (ec);
1819 }