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