54d00b46dbd52d70fcd9147235d120dddbdc432a
[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       if (!(c->flags & GCRY_CIPHER_CBC_CTS))
1022         rc = _gcry_cipher_cbc_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1023       else
1024         rc = _gcry_cipher_cbc_cts_encrypt (c, outbuf, outbuflen, inbuf,
1025                                            inbuflen);
1026       break;
1027
1028     case GCRY_CIPHER_MODE_CFB:
1029       rc = _gcry_cipher_cfb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1030       break;
1031
1032     case GCRY_CIPHER_MODE_CFB8:
1033       rc = _gcry_cipher_cfb8_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1034       break;
1035
1036     case GCRY_CIPHER_MODE_OFB:
1037       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1038       break;
1039
1040     case GCRY_CIPHER_MODE_CTR:
1041       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1042       break;
1043
1044     case GCRY_CIPHER_MODE_AESWRAP:
1045       rc = _gcry_cipher_aeswrap_encrypt (c, outbuf, outbuflen,
1046                                          inbuf, inbuflen);
1047       break;
1048
1049     case GCRY_CIPHER_MODE_CCM:
1050       rc = _gcry_cipher_ccm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1051       break;
1052
1053     case GCRY_CIPHER_MODE_CMAC:
1054       rc = GPG_ERR_INV_CIPHER_MODE;
1055       break;
1056
1057     case GCRY_CIPHER_MODE_EAX:
1058       rc = _gcry_cipher_eax_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1059       break;
1060
1061     case GCRY_CIPHER_MODE_GCM:
1062       rc = _gcry_cipher_gcm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1063       break;
1064
1065     case GCRY_CIPHER_MODE_POLY1305:
1066       rc = _gcry_cipher_poly1305_encrypt (c, outbuf, outbuflen,
1067                                           inbuf, inbuflen);
1068       break;
1069
1070     case GCRY_CIPHER_MODE_OCB:
1071       rc = _gcry_cipher_ocb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1072       break;
1073
1074     case GCRY_CIPHER_MODE_XTS:
1075       rc = _gcry_cipher_xts_crypt (c, outbuf, outbuflen, inbuf, inbuflen, 1);
1076       break;
1077
1078     case GCRY_CIPHER_MODE_STREAM:
1079       c->spec->stencrypt (&c->context.c,
1080                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
1081       rc = 0;
1082       break;
1083
1084     case GCRY_CIPHER_MODE_NONE:
1085       if (fips_mode () || !_gcry_get_debug_flag (0))
1086         {
1087           fips_signal_error ("cipher mode NONE used");
1088           rc = GPG_ERR_INV_CIPHER_MODE;
1089         }
1090       else
1091         {
1092           if (inbuf != outbuf)
1093             memmove (outbuf, inbuf, inbuflen);
1094           rc = 0;
1095         }
1096       break;
1097
1098     default:
1099       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
1100       rc = GPG_ERR_INV_CIPHER_MODE;
1101       break;
1102     }
1103
1104   return rc;
1105 }
1106
1107
1108 /****************
1109  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
1110  * been requested.
1111  */
1112 gcry_err_code_t
1113 _gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1114                       const void *in, size_t inlen)
1115 {
1116   gcry_err_code_t rc;
1117
1118   if (!in)  /* Caller requested in-place encryption.  */
1119     {
1120       in = out;
1121       inlen = outsize;
1122     }
1123
1124   rc = cipher_encrypt (h, out, outsize, in, inlen);
1125
1126   /* Failsafe: Make sure that the plaintext will never make it into
1127      OUT if the encryption returned an error.  */
1128   if (rc && out)
1129     memset (out, 0x42, outsize);
1130
1131   return rc;
1132 }
1133
1134
1135
1136 /****************
1137  * Decrypt INBUF to OUTBUF with the mode selected at open.
1138  * inbuf and outbuf may overlap or be the same.
1139  * Depending on the mode some some constraints apply to INBUFLEN.
1140  */
1141 static gcry_err_code_t
1142 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
1143                 const byte *inbuf, size_t inbuflen)
1144 {
1145   gcry_err_code_t rc;
1146
1147   if (c->mode != GCRY_CIPHER_MODE_NONE && !c->marks.key)
1148     {
1149       log_error ("cipher_decrypt: key not set\n");
1150       return GPG_ERR_MISSING_KEY;
1151     }
1152
1153   switch (c->mode)
1154     {
1155     case GCRY_CIPHER_MODE_ECB:
1156       rc = do_ecb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1157       break;
1158
1159     case GCRY_CIPHER_MODE_CBC:
1160       if (!(c->flags & GCRY_CIPHER_CBC_CTS))
1161         rc = _gcry_cipher_cbc_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1162       else
1163         rc = _gcry_cipher_cbc_cts_decrypt (c, outbuf, outbuflen, inbuf,
1164                                           inbuflen);
1165       break;
1166
1167     case GCRY_CIPHER_MODE_CFB:
1168       rc = _gcry_cipher_cfb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1169       break;
1170
1171     case GCRY_CIPHER_MODE_CFB8:
1172       rc = _gcry_cipher_cfb8_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1173       break;
1174
1175     case GCRY_CIPHER_MODE_OFB:
1176       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1177       break;
1178
1179     case GCRY_CIPHER_MODE_CTR:
1180       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1181       break;
1182
1183     case GCRY_CIPHER_MODE_AESWRAP:
1184       rc = _gcry_cipher_aeswrap_decrypt (c, outbuf, outbuflen,
1185                                          inbuf, inbuflen);
1186       break;
1187
1188     case GCRY_CIPHER_MODE_CCM:
1189       rc = _gcry_cipher_ccm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1190       break;
1191
1192     case GCRY_CIPHER_MODE_CMAC:
1193       rc = GPG_ERR_INV_CIPHER_MODE;
1194       break;
1195
1196     case GCRY_CIPHER_MODE_EAX:
1197       rc = _gcry_cipher_eax_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1198       break;
1199
1200     case GCRY_CIPHER_MODE_GCM:
1201       rc = _gcry_cipher_gcm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1202       break;
1203
1204     case GCRY_CIPHER_MODE_POLY1305:
1205       rc = _gcry_cipher_poly1305_decrypt (c, outbuf, outbuflen,
1206                                           inbuf, inbuflen);
1207       break;
1208
1209     case GCRY_CIPHER_MODE_OCB:
1210       rc = _gcry_cipher_ocb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1211       break;
1212
1213     case GCRY_CIPHER_MODE_XTS:
1214       rc = _gcry_cipher_xts_crypt (c, outbuf, outbuflen, inbuf, inbuflen, 0);
1215       break;
1216
1217     case GCRY_CIPHER_MODE_STREAM:
1218       c->spec->stdecrypt (&c->context.c,
1219                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
1220       rc = 0;
1221       break;
1222
1223     case GCRY_CIPHER_MODE_NONE:
1224       if (fips_mode () || !_gcry_get_debug_flag (0))
1225         {
1226           fips_signal_error ("cipher mode NONE used");
1227           rc = GPG_ERR_INV_CIPHER_MODE;
1228         }
1229       else
1230         {
1231           if (inbuf != outbuf)
1232             memmove (outbuf, inbuf, inbuflen);
1233           rc = 0;
1234         }
1235       break;
1236
1237     default:
1238       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1239       rc = GPG_ERR_INV_CIPHER_MODE;
1240       break;
1241     }
1242
1243   return rc;
1244 }
1245
1246
1247 gcry_err_code_t
1248 _gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1249                       const void *in, size_t inlen)
1250 {
1251   if (!in) /* Caller requested in-place encryption. */
1252     {
1253       in = out;
1254       inlen = outsize;
1255     }
1256
1257   return cipher_decrypt (h, out, outsize, in, inlen);
1258 }
1259
1260
1261
1262 /****************
1263  * Used for PGP's somewhat strange CFB mode. Only works if
1264  * the corresponding flag is set.
1265  */
1266 static void
1267 cipher_sync (gcry_cipher_hd_t c)
1268 {
1269   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1270     {
1271       memmove (c->u_iv.iv + c->unused,
1272                c->u_iv.iv, c->spec->blocksize - c->unused);
1273       memcpy (c->u_iv.iv,
1274               c->lastiv + c->spec->blocksize - c->unused, c->unused);
1275       c->unused = 0;
1276     }
1277 }
1278
1279
1280 gcry_err_code_t
1281 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
1282 {
1283   return cipher_setkey (hd, (void*)key, keylen);
1284 }
1285
1286
1287 gcry_err_code_t
1288 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
1289 {
1290   gcry_err_code_t rc = 0;
1291
1292   switch (hd->mode)
1293     {
1294       case GCRY_CIPHER_MODE_CCM:
1295         rc = _gcry_cipher_ccm_set_nonce (hd, iv, ivlen);
1296         break;
1297
1298       case GCRY_CIPHER_MODE_EAX:
1299         rc =  _gcry_cipher_eax_set_nonce (hd, iv, ivlen);
1300         break;
1301
1302       case GCRY_CIPHER_MODE_GCM:
1303         rc =  _gcry_cipher_gcm_setiv (hd, iv, ivlen);
1304         break;
1305
1306       case GCRY_CIPHER_MODE_POLY1305:
1307         rc =  _gcry_cipher_poly1305_setiv (hd, iv, ivlen);
1308         break;
1309
1310       case GCRY_CIPHER_MODE_OCB:
1311         rc = _gcry_cipher_ocb_set_nonce (hd, iv, ivlen);
1312         break;
1313
1314       default:
1315         rc = cipher_setiv (hd, iv, ivlen);
1316         break;
1317     }
1318   return rc;
1319 }
1320
1321 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1322    block size length, or (NULL,0) to set the CTR to the all-zero
1323    block. */
1324 gpg_err_code_t
1325 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1326 {
1327   if (ctr && ctrlen == hd->spec->blocksize)
1328     {
1329       memcpy (hd->u_ctr.ctr, ctr, hd->spec->blocksize);
1330       hd->unused = 0;
1331     }
1332   else if (!ctr || !ctrlen)
1333     {
1334       memset (hd->u_ctr.ctr, 0, hd->spec->blocksize);
1335       hd->unused = 0;
1336     }
1337   else
1338     return GPG_ERR_INV_ARG;
1339
1340   return 0;
1341 }
1342
1343 gpg_err_code_t
1344 _gcry_cipher_getctr (gcry_cipher_hd_t hd, void *ctr, size_t ctrlen)
1345 {
1346   if (ctr && ctrlen == hd->spec->blocksize)
1347     memcpy (ctr, hd->u_ctr.ctr, hd->spec->blocksize);
1348   else
1349     return GPG_ERR_INV_ARG;
1350
1351   return 0;
1352 }
1353
1354 gcry_err_code_t
1355 _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
1356                            size_t abuflen)
1357 {
1358   gcry_err_code_t rc;
1359
1360   switch (hd->mode)
1361     {
1362     case GCRY_CIPHER_MODE_CCM:
1363       rc = _gcry_cipher_ccm_authenticate (hd, abuf, abuflen);
1364       break;
1365
1366     case GCRY_CIPHER_MODE_CMAC:
1367       rc = _gcry_cipher_cmac_authenticate (hd, abuf, abuflen);
1368       break;
1369
1370     case GCRY_CIPHER_MODE_EAX:
1371       rc = _gcry_cipher_eax_authenticate (hd, abuf, abuflen);
1372       break;
1373
1374     case GCRY_CIPHER_MODE_GCM:
1375       rc = _gcry_cipher_gcm_authenticate (hd, abuf, abuflen);
1376       break;
1377
1378     case GCRY_CIPHER_MODE_POLY1305:
1379       rc = _gcry_cipher_poly1305_authenticate (hd, abuf, abuflen);
1380       break;
1381
1382     case GCRY_CIPHER_MODE_OCB:
1383       rc = _gcry_cipher_ocb_authenticate (hd, abuf, abuflen);
1384       break;
1385
1386     default:
1387       log_error ("gcry_cipher_authenticate: invalid mode %d\n", hd->mode);
1388       rc = GPG_ERR_INV_CIPHER_MODE;
1389       break;
1390     }
1391
1392   return rc;
1393 }
1394
1395
1396 gcry_err_code_t
1397 _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
1398 {
1399   gcry_err_code_t rc;
1400
1401   switch (hd->mode)
1402     {
1403     case GCRY_CIPHER_MODE_CCM:
1404       rc = _gcry_cipher_ccm_get_tag (hd, outtag, taglen);
1405       break;
1406
1407     case GCRY_CIPHER_MODE_CMAC:
1408       rc = _gcry_cipher_cmac_get_tag (hd, outtag, taglen);
1409       break;
1410
1411     case GCRY_CIPHER_MODE_EAX:
1412       rc = _gcry_cipher_eax_get_tag (hd, outtag, taglen);
1413       break;
1414
1415     case GCRY_CIPHER_MODE_GCM:
1416       rc = _gcry_cipher_gcm_get_tag (hd, outtag, taglen);
1417       break;
1418
1419     case GCRY_CIPHER_MODE_POLY1305:
1420       rc = _gcry_cipher_poly1305_get_tag (hd, outtag, taglen);
1421       break;
1422
1423     case GCRY_CIPHER_MODE_OCB:
1424       rc = _gcry_cipher_ocb_get_tag (hd, outtag, taglen);
1425       break;
1426
1427     default:
1428       log_error ("gcry_cipher_gettag: invalid mode %d\n", hd->mode);
1429       rc = GPG_ERR_INV_CIPHER_MODE;
1430       break;
1431     }
1432
1433   return rc;
1434 }
1435
1436
1437 gcry_err_code_t
1438 _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
1439 {
1440   gcry_err_code_t rc;
1441
1442   switch (hd->mode)
1443     {
1444     case GCRY_CIPHER_MODE_CCM:
1445       rc = _gcry_cipher_ccm_check_tag (hd, intag, taglen);
1446       break;
1447
1448     case GCRY_CIPHER_MODE_CMAC:
1449       rc = _gcry_cipher_cmac_check_tag (hd, intag, taglen);
1450       break;
1451
1452     case GCRY_CIPHER_MODE_EAX:
1453       rc = _gcry_cipher_eax_check_tag (hd, intag, taglen);
1454       break;
1455
1456     case GCRY_CIPHER_MODE_GCM:
1457       rc = _gcry_cipher_gcm_check_tag (hd, intag, taglen);
1458       break;
1459
1460     case GCRY_CIPHER_MODE_POLY1305:
1461       rc = _gcry_cipher_poly1305_check_tag (hd, intag, taglen);
1462       break;
1463
1464     case GCRY_CIPHER_MODE_OCB:
1465       rc = _gcry_cipher_ocb_check_tag (hd, intag, taglen);
1466       break;
1467
1468     default:
1469       log_error ("gcry_cipher_checktag: invalid mode %d\n", hd->mode);
1470       rc = GPG_ERR_INV_CIPHER_MODE;
1471       break;
1472     }
1473
1474   return rc;
1475 }
1476
1477
1478 gcry_err_code_t
1479 _gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1480 {
1481   gcry_err_code_t rc = 0;
1482
1483   switch (cmd)
1484     {
1485     case GCRYCTL_RESET:
1486       cipher_reset (h);
1487       break;
1488
1489     case GCRYCTL_FINALIZE:
1490       if (!h || buffer || buflen)
1491         return GPG_ERR_INV_ARG;
1492       h->marks.finalize = 1;
1493       break;
1494
1495     case GCRYCTL_CFB_SYNC:
1496       cipher_sync( h );
1497       break;
1498
1499     case GCRYCTL_SET_CBC_CTS:
1500       if (buflen)
1501         if (h->flags & GCRY_CIPHER_CBC_MAC)
1502           rc = GPG_ERR_INV_FLAG;
1503         else
1504           h->flags |= GCRY_CIPHER_CBC_CTS;
1505       else
1506         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1507       break;
1508
1509     case GCRYCTL_SET_CBC_MAC:
1510       if (buflen)
1511         if (h->flags & GCRY_CIPHER_CBC_CTS)
1512           rc = GPG_ERR_INV_FLAG;
1513         else
1514           h->flags |= GCRY_CIPHER_CBC_MAC;
1515       else
1516         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1517       break;
1518
1519     case GCRYCTL_SET_CCM_LENGTHS:
1520       {
1521         u64 params[3];
1522         size_t encryptedlen;
1523         size_t aadlen;
1524         size_t authtaglen;
1525
1526         if (h->mode != GCRY_CIPHER_MODE_CCM)
1527           return GPG_ERR_INV_CIPHER_MODE;
1528
1529         if (!buffer || buflen != 3 * sizeof(u64))
1530           return GPG_ERR_INV_ARG;
1531
1532         /* This command is used to pass additional length parameters needed
1533            by CCM mode to initialize CBC-MAC.  */
1534         memcpy (params, buffer, sizeof(params));
1535         encryptedlen = params[0];
1536         aadlen = params[1];
1537         authtaglen = params[2];
1538
1539         rc = _gcry_cipher_ccm_set_lengths (h, encryptedlen, aadlen, authtaglen);
1540       }
1541       break;
1542
1543     case GCRYCTL_SET_TAGLEN:
1544       if (!h || !buffer || buflen != sizeof(int) )
1545         return GPG_ERR_INV_ARG;
1546       switch (h->mode)
1547         {
1548         case GCRY_CIPHER_MODE_OCB:
1549           switch (*(int*)buffer)
1550             {
1551             case 8: case 12: case 16:
1552               h->u_mode.ocb.taglen = *(int*)buffer;
1553               break;
1554             default:
1555               rc = GPG_ERR_INV_LENGTH; /* Invalid tag length. */
1556               break;
1557             }
1558           break;
1559
1560         default:
1561           rc =GPG_ERR_INV_CIPHER_MODE;
1562           break;
1563         }
1564       break;
1565
1566     case GCRYCTL_DISABLE_ALGO:
1567       /* This command expects NULL for H and BUFFER to point to an
1568          integer with the algo number.  */
1569       if( h || !buffer || buflen != sizeof(int) )
1570         return GPG_ERR_CIPHER_ALGO;
1571       disable_cipher_algo( *(int*)buffer );
1572       break;
1573
1574     case PRIV_CIPHERCTL_DISABLE_WEAK_KEY:  /* (private)  */
1575       if (h->spec->set_extra_info)
1576         rc = h->spec->set_extra_info
1577           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1578       else
1579         rc = GPG_ERR_NOT_SUPPORTED;
1580       break;
1581
1582     case PRIV_CIPHERCTL_GET_INPUT_VECTOR: /* (private)  */
1583       /* This is the input block as used in CFB and OFB mode which has
1584          initially been set as IV.  The returned format is:
1585            1 byte  Actual length of the block in bytes.
1586            n byte  The block.
1587          If the provided buffer is too short, an error is returned. */
1588       if (buflen < (1 + h->spec->blocksize))
1589         rc = GPG_ERR_TOO_SHORT;
1590       else
1591         {
1592           unsigned char *ivp;
1593           unsigned char *dst = buffer;
1594           int n = h->unused;
1595
1596           if (!n)
1597             n = h->spec->blocksize;
1598           gcry_assert (n <= h->spec->blocksize);
1599           *dst++ = n;
1600           ivp = h->u_iv.iv + h->spec->blocksize - n;
1601           while (n--)
1602             *dst++ = *ivp++;
1603         }
1604       break;
1605
1606     case GCRYCTL_SET_SBOX:
1607       if (h->spec->set_extra_info)
1608         rc = h->spec->set_extra_info
1609           (&h->context.c, GCRYCTL_SET_SBOX, buffer, buflen);
1610       else
1611         rc = GPG_ERR_NOT_SUPPORTED;
1612       break;
1613
1614     default:
1615       rc = GPG_ERR_INV_OP;
1616     }
1617
1618   return rc;
1619 }
1620
1621
1622 /* Return information about the cipher handle H.  CMD is the kind of
1623  * information requested.
1624  *
1625  * CMD may be one of:
1626  *
1627  *  GCRYCTL_GET_TAGLEN:
1628  *      Return the length of the tag for an AE algorithm mode.  An
1629  *      error is returned for modes which do not support a tag.
1630  *      BUFFER must be given as NULL.  On success the result is stored
1631  *      at NBYTES.  The taglen is returned in bytes.
1632  *
1633  * The function returns 0 on success or an error code.
1634  */
1635 gcry_err_code_t
1636 _gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1637 {
1638   gcry_err_code_t rc = 0;
1639
1640   switch (cmd)
1641     {
1642     case GCRYCTL_GET_TAGLEN:
1643       if (!h || buffer || !nbytes)
1644         rc = GPG_ERR_INV_ARG;
1645       else
1646         {
1647           switch (h->mode)
1648             {
1649             case GCRY_CIPHER_MODE_OCB:
1650               *nbytes = h->u_mode.ocb.taglen;
1651               break;
1652
1653             case GCRY_CIPHER_MODE_CCM:
1654               *nbytes = h->u_mode.ccm.authlen;
1655               break;
1656
1657             case GCRY_CIPHER_MODE_EAX:
1658               *nbytes = h->spec->blocksize;
1659               break;
1660
1661             case GCRY_CIPHER_MODE_GCM:
1662               *nbytes = GCRY_GCM_BLOCK_LEN;
1663               break;
1664
1665             case GCRY_CIPHER_MODE_POLY1305:
1666               *nbytes = POLY1305_TAGLEN;
1667               break;
1668
1669             default:
1670               rc = GPG_ERR_INV_CIPHER_MODE;
1671               break;
1672             }
1673         }
1674       break;
1675
1676     default:
1677       rc = GPG_ERR_INV_OP;
1678     }
1679
1680   return rc;
1681 }
1682
1683 /* Return information about the given cipher algorithm ALGO.
1684
1685    WHAT select the kind of information returned:
1686
1687     GCRYCTL_GET_KEYLEN:
1688         Return the length of the key.  If the algorithm ALGO
1689         supports multiple key lengths, the maximum supported key length
1690         is returned.  The key length is returned as number of octets.
1691         BUFFER and NBYTES must be zero.
1692
1693     GCRYCTL_GET_BLKLEN:
1694         Return the blocklength of the algorithm ALGO counted in octets.
1695         BUFFER and NBYTES must be zero.
1696
1697     GCRYCTL_TEST_ALGO:
1698         Returns 0 if the specified algorithm ALGO is available for use.
1699         BUFFER and NBYTES must be zero.
1700
1701    Note: Because this function is in most cases used to return an
1702    integer value, we can make it easier for the caller to just look at
1703    the return value.  The caller will in all cases consult the value
1704    and thereby detecting whether a error occurred or not (i.e. while
1705    checking the block size)
1706  */
1707 gcry_err_code_t
1708 _gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1709 {
1710   gcry_err_code_t rc = 0;
1711   unsigned int ui;
1712
1713   switch (what)
1714     {
1715     case GCRYCTL_GET_KEYLEN:
1716       if (buffer || (! nbytes))
1717         rc = GPG_ERR_CIPHER_ALGO;
1718       else
1719         {
1720           ui = cipher_get_keylen (algo);
1721           if ((ui > 0) && (ui <= 512))
1722             *nbytes = (size_t) ui / 8;
1723           else
1724             /* The only reason for an error is an invalid algo.  */
1725             rc = GPG_ERR_CIPHER_ALGO;
1726         }
1727       break;
1728
1729     case GCRYCTL_GET_BLKLEN:
1730       if (buffer || (! nbytes))
1731         rc = GPG_ERR_CIPHER_ALGO;
1732       else
1733         {
1734           ui = cipher_get_blocksize (algo);
1735           if ((ui > 0) && (ui < 10000))
1736             *nbytes = ui;
1737           else
1738             {
1739               /* The only reason is an invalid algo or a strange
1740                  blocksize.  */
1741               rc = GPG_ERR_CIPHER_ALGO;
1742             }
1743         }
1744       break;
1745
1746     case GCRYCTL_TEST_ALGO:
1747       if (buffer || nbytes)
1748         rc = GPG_ERR_INV_ARG;
1749       else
1750         rc = check_cipher_algo (algo);
1751       break;
1752
1753       default:
1754         rc = GPG_ERR_INV_OP;
1755     }
1756
1757   return rc;
1758 }
1759
1760
1761 /* This function returns length of the key for algorithm ALGO.  If the
1762    algorithm supports multiple key lengths, the maximum supported key
1763    length is returned.  On error 0 is returned.  The key length is
1764    returned as number of octets.
1765
1766    This is a convenience functions which should be preferred over
1767    gcry_cipher_algo_info because it allows for proper type
1768    checking.  */
1769 size_t
1770 _gcry_cipher_get_algo_keylen (int algo)
1771 {
1772   size_t n;
1773
1774   if (_gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1775     n = 0;
1776   return n;
1777 }
1778
1779
1780 /* This functions returns the blocklength of the algorithm ALGO
1781    counted in octets.  On error 0 is returned.
1782
1783    This is a convenience functions which should be preferred over
1784    gcry_cipher_algo_info because it allows for proper type
1785    checking.  */
1786 size_t
1787 _gcry_cipher_get_algo_blklen (int algo)
1788 {
1789   size_t n;
1790
1791   if (_gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1792     n = 0;
1793   return n;
1794 }
1795
1796
1797 /* Explicitly initialize this module.  */
1798 gcry_err_code_t
1799 _gcry_cipher_init (void)
1800 {
1801   if (fips_mode())
1802     {
1803       /* disable algorithms that are disallowed in fips */
1804       int idx;
1805       gcry_cipher_spec_t *spec;
1806
1807       for (idx = 0; (spec = cipher_list[idx]); idx++)
1808         if (!spec->flags.fips)
1809           spec->flags.disabled = 1;
1810     }
1811
1812   return 0;
1813 }
1814
1815
1816 /* Run the selftests for cipher algorithm ALGO with optional reporting
1817    function REPORT.  */
1818 gpg_error_t
1819 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
1820 {
1821   gcry_err_code_t ec = 0;
1822   gcry_cipher_spec_t *spec;
1823
1824   spec = spec_from_algo (algo);
1825   if (spec && !spec->flags.disabled && spec->selftest)
1826     ec = spec->selftest (algo, extended, report);
1827   else
1828     {
1829       ec = GPG_ERR_CIPHER_ALGO;
1830       if (report)
1831         report ("cipher", algo, "module",
1832                 (spec && !spec->flags.disabled)?
1833                 "no selftest available" :
1834                 spec? "algorithm disabled" : "algorithm not found");
1835     }
1836
1837   return gpg_error (ec);
1838 }