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