Add XTS cipher mode
[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_OFB:
419       case GCRY_CIPHER_MODE_CTR:
420       case GCRY_CIPHER_MODE_AESWRAP:
421       case GCRY_CIPHER_MODE_CMAC:
422       case GCRY_CIPHER_MODE_GCM:
423         if (!spec->encrypt || !spec->decrypt)
424           err = GPG_ERR_INV_CIPHER_MODE;
425         break;
426
427       case GCRY_CIPHER_MODE_POLY1305:
428         if (!spec->stencrypt || !spec->stdecrypt || !spec->setiv)
429           err = GPG_ERR_INV_CIPHER_MODE;
430         else if (spec->algo != GCRY_CIPHER_CHACHA20)
431           err = GPG_ERR_INV_CIPHER_MODE;
432         break;
433
434       case GCRY_CIPHER_MODE_OCB:
435         /* Note that our implementation allows only for 128 bit block
436            length algorithms.  Lower block lengths would be possible
437            but we do not implement them because they limit the
438            security too much.  */
439         if (!spec->encrypt || !spec->decrypt)
440           err = GPG_ERR_INV_CIPHER_MODE;
441         else if (spec->blocksize != (128/8))
442           err = GPG_ERR_INV_CIPHER_MODE;
443         break;
444
445       case GCRY_CIPHER_MODE_STREAM:
446         if (!spec->stencrypt || !spec->stdecrypt)
447           err = GPG_ERR_INV_CIPHER_MODE;
448         break;
449
450       case GCRY_CIPHER_MODE_NONE:
451         /* This mode may be used for debugging.  It copies the main
452            text verbatim to the ciphertext.  We do not allow this in
453            fips mode or if no debug flag has been set.  */
454         if (fips_mode () || !_gcry_get_debug_flag (0))
455           err = GPG_ERR_INV_CIPHER_MODE;
456         break;
457
458       default:
459         err = GPG_ERR_INV_CIPHER_MODE;
460       }
461
462   /* Perform selftest here and mark this with a flag in cipher_table?
463      No, we should not do this as it takes too long.  Further it does
464      not make sense to exclude algorithms with failing selftests at
465      runtime: If a selftest fails there is something seriously wrong
466      with the system and thus we better die immediately. */
467
468   if (! err)
469     {
470       size_t size = (sizeof (*h)
471                      + 2 * spec->contextsize
472                      - sizeof (cipher_context_alignment_t)
473 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
474                      + 15  /* Space for leading alignment gap.  */
475 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
476                      );
477
478       /* Space needed per mode.  */
479       switch (mode)
480         {
481         case GCRY_CIPHER_MODE_XTS:
482           /* Additional cipher context for tweak. */
483           size += 2 * spec->contextsize + 15;
484           break;
485
486         default:
487           break;
488         }
489
490       if (secure)
491         h = xtrycalloc_secure (1, size);
492       else
493         h = xtrycalloc (1, size);
494
495       if (! h)
496         err = gpg_err_code_from_syserror ();
497       else
498         {
499           size_t off = 0;
500           char *tc;
501
502 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
503           if ( ((uintptr_t)h & 0x0f) )
504             {
505               /* The malloced block is not aligned on a 16 byte
506                  boundary.  Correct for this.  */
507               off = 16 - ((uintptr_t)h & 0x0f);
508               h = (void*)((char*)h + off);
509             }
510 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
511
512           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
513           h->actual_handle_size = size - off;
514           h->handle_offset = off;
515           h->spec = spec;
516           h->algo = algo;
517           h->mode = mode;
518           h->flags = flags;
519
520           /* Setup bulk encryption routines.  */
521           switch (algo)
522             {
523 #ifdef USE_AES
524             case GCRY_CIPHER_AES128:
525             case GCRY_CIPHER_AES192:
526             case GCRY_CIPHER_AES256:
527               h->bulk.cfb_enc = _gcry_aes_cfb_enc;
528               h->bulk.cfb_dec = _gcry_aes_cfb_dec;
529               h->bulk.cbc_enc = _gcry_aes_cbc_enc;
530               h->bulk.cbc_dec = _gcry_aes_cbc_dec;
531               h->bulk.ctr_enc = _gcry_aes_ctr_enc;
532               h->bulk.ocb_crypt = _gcry_aes_ocb_crypt;
533               h->bulk.ocb_auth  = _gcry_aes_ocb_auth;
534               break;
535 #endif /*USE_AES*/
536 #ifdef USE_BLOWFISH
537             case GCRY_CIPHER_BLOWFISH:
538               h->bulk.cfb_dec = _gcry_blowfish_cfb_dec;
539               h->bulk.cbc_dec = _gcry_blowfish_cbc_dec;
540               h->bulk.ctr_enc = _gcry_blowfish_ctr_enc;
541               break;
542 #endif /*USE_BLOWFISH*/
543 #ifdef USE_CAST5
544             case GCRY_CIPHER_CAST5:
545               h->bulk.cfb_dec = _gcry_cast5_cfb_dec;
546               h->bulk.cbc_dec = _gcry_cast5_cbc_dec;
547               h->bulk.ctr_enc = _gcry_cast5_ctr_enc;
548               break;
549 #endif /*USE_CAMELLIA*/
550 #ifdef USE_CAMELLIA
551             case GCRY_CIPHER_CAMELLIA128:
552             case GCRY_CIPHER_CAMELLIA192:
553             case GCRY_CIPHER_CAMELLIA256:
554               h->bulk.cbc_dec = _gcry_camellia_cbc_dec;
555               h->bulk.cfb_dec = _gcry_camellia_cfb_dec;
556               h->bulk.ctr_enc = _gcry_camellia_ctr_enc;
557               h->bulk.ocb_crypt = _gcry_camellia_ocb_crypt;
558               h->bulk.ocb_auth  = _gcry_camellia_ocb_auth;
559               break;
560 #endif /*USE_CAMELLIA*/
561 #ifdef USE_DES
562             case GCRY_CIPHER_3DES:
563               h->bulk.cbc_dec =  _gcry_3des_cbc_dec;
564               h->bulk.cfb_dec =  _gcry_3des_cfb_dec;
565               h->bulk.ctr_enc =  _gcry_3des_ctr_enc;
566               break;
567 #endif /*USE_DES*/
568 #ifdef USE_SERPENT
569             case GCRY_CIPHER_SERPENT128:
570             case GCRY_CIPHER_SERPENT192:
571             case GCRY_CIPHER_SERPENT256:
572               h->bulk.cbc_dec = _gcry_serpent_cbc_dec;
573               h->bulk.cfb_dec = _gcry_serpent_cfb_dec;
574               h->bulk.ctr_enc = _gcry_serpent_ctr_enc;
575               h->bulk.ocb_crypt = _gcry_serpent_ocb_crypt;
576               h->bulk.ocb_auth  = _gcry_serpent_ocb_auth;
577               break;
578 #endif /*USE_SERPENT*/
579 #ifdef USE_TWOFISH
580             case GCRY_CIPHER_TWOFISH:
581             case GCRY_CIPHER_TWOFISH128:
582               h->bulk.cbc_dec = _gcry_twofish_cbc_dec;
583               h->bulk.cfb_dec = _gcry_twofish_cfb_dec;
584               h->bulk.ctr_enc = _gcry_twofish_ctr_enc;
585               h->bulk.ocb_crypt = _gcry_twofish_ocb_crypt;
586               h->bulk.ocb_auth  = _gcry_twofish_ocb_auth;
587               break;
588 #endif /*USE_TWOFISH*/
589
590             default:
591               break;
592             }
593
594           /* Setup defaults depending on the mode.  */
595           switch (mode)
596             {
597             case GCRY_CIPHER_MODE_OCB:
598               h->u_mode.ocb.taglen = 16; /* Bytes.  */
599               break;
600
601             case GCRY_CIPHER_MODE_XTS:
602               tc = h->context.c + spec->contextsize * 2;
603               tc += (16 - (uintptr_t)tc % 16) % 16;
604               h->u_mode.xts.tweak_context = tc;
605
606               break;
607
608             default:
609               break;
610             }
611
612         }
613     }
614
615   /* Done.  */
616
617   *handle = err ? NULL : h;
618
619   return err;
620 }
621
622
623 /* Release all resources associated with the cipher handle H. H may be
624    NULL in which case this is a no-operation. */
625 void
626 _gcry_cipher_close (gcry_cipher_hd_t h)
627 {
628   size_t off;
629
630   if (!h)
631     return;
632
633   if ((h->magic != CTX_MAGIC_SECURE)
634       && (h->magic != CTX_MAGIC_NORMAL))
635     _gcry_fatal_error(GPG_ERR_INTERNAL,
636                       "gcry_cipher_close: already closed/invalid handle");
637   else
638     h->magic = 0;
639
640   /* We always want to wipe out the memory even when the context has
641      been allocated in secure memory.  The user might have disabled
642      secure memory or is using his own implementation which does not
643      do the wiping.  To accomplish this we need to keep track of the
644      actual size of this structure because we have no way to known
645      how large the allocated area was when using a standard malloc. */
646   off = h->handle_offset;
647   wipememory (h, h->actual_handle_size);
648
649   xfree ((char*)h - off);
650 }
651
652
653 /* Set the key to be used for the encryption context C to KEY with
654    length KEYLEN.  The length should match the required length. */
655 static gcry_err_code_t
656 cipher_setkey (gcry_cipher_hd_t c, byte *key, size_t keylen)
657 {
658   gcry_err_code_t rc;
659
660   if (c->mode == GCRY_CIPHER_MODE_XTS)
661     {
662       /* XTS uses two keys. */
663       if (keylen % 2)
664         return GPG_ERR_INV_KEYLEN;
665       keylen /= 2;
666
667       if (fips_mode ())
668         {
669           /* Reject key if subkeys Key_1 and Key_2 are equal.
670              See "Implementation Guidance for FIPS 140-2, A.9 XTS-AES
671              Key Generation Requirements" for details.  */
672           if (buf_eq_const (key, key + keylen, keylen))
673             return GPG_ERR_WEAK_KEY;
674         }
675     }
676
677   rc = c->spec->setkey (&c->context.c, key, keylen);
678   if (!rc)
679     {
680       /* Duplicate initial context.  */
681       memcpy ((void *) ((char *) &c->context.c + c->spec->contextsize),
682               (void *) &c->context.c,
683               c->spec->contextsize);
684       c->marks.key = 1;
685
686       switch (c->mode)
687         {
688         case GCRY_CIPHER_MODE_CMAC:
689           _gcry_cipher_cmac_set_subkeys (c);
690           break;
691
692         case GCRY_CIPHER_MODE_GCM:
693           _gcry_cipher_gcm_setkey (c);
694           break;
695
696         case GCRY_CIPHER_MODE_POLY1305:
697           _gcry_cipher_poly1305_setkey (c);
698           break;
699
700         case GCRY_CIPHER_MODE_XTS:
701           /* Setup tweak cipher with second part of XTS key. */
702           rc = c->spec->setkey (c->u_mode.xts.tweak_context, key + keylen,
703                                 keylen);
704           if (!rc)
705             {
706               /* Duplicate initial tweak context.  */
707               memcpy (c->u_mode.xts.tweak_context + c->spec->contextsize,
708                       c->u_mode.xts.tweak_context, c->spec->contextsize);
709             }
710           else
711             c->marks.key = 0;
712           break;
713
714         default:
715           break;
716         };
717     }
718   else
719     c->marks.key = 0;
720
721   return rc;
722 }
723
724
725 /* Set the IV to be used for the encryption context C to IV with
726    length IVLEN.  The length should match the required length. */
727 static gcry_err_code_t
728 cipher_setiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
729 {
730   /* If the cipher has its own IV handler, we use only this one.  This
731      is currently used for stream ciphers requiring a nonce.  */
732   if (c->spec->setiv)
733     {
734       c->spec->setiv (&c->context.c, iv, ivlen);
735       return 0;
736     }
737
738   memset (c->u_iv.iv, 0, c->spec->blocksize);
739   if (iv)
740     {
741       if (ivlen != c->spec->blocksize)
742         {
743           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
744                     (unsigned int)ivlen, (unsigned int)c->spec->blocksize);
745           fips_signal_error ("IV length does not match blocklength");
746         }
747       if (ivlen > c->spec->blocksize)
748         ivlen = c->spec->blocksize;
749       memcpy (c->u_iv.iv, iv, ivlen);
750       c->marks.iv = 1;
751     }
752   else
753       c->marks.iv = 0;
754   c->unused = 0;
755
756   return 0;
757 }
758
759
760 /* Reset the cipher context to the initial context.  This is basically
761    the same as an release followed by a new. */
762 static void
763 cipher_reset (gcry_cipher_hd_t c)
764 {
765   unsigned int marks_key;
766
767   marks_key = c->marks.key;
768
769   memcpy (&c->context.c,
770           (char *) &c->context.c + c->spec->contextsize,
771           c->spec->contextsize);
772   memset (&c->marks, 0, sizeof c->marks);
773   memset (c->u_iv.iv, 0, c->spec->blocksize);
774   memset (c->lastiv, 0, c->spec->blocksize);
775   memset (c->u_ctr.ctr, 0, c->spec->blocksize);
776   c->unused = 0;
777
778   c->marks.key = marks_key;
779
780   switch (c->mode)
781     {
782     case GCRY_CIPHER_MODE_CMAC:
783       /* Only clear 'tag' for cmac, keep subkeys. */
784       c->u_mode.cmac.tag = 0;
785       break;
786
787     case GCRY_CIPHER_MODE_GCM:
788       /* Only clear head of u_mode, keep ghash_key and gcm_table. */
789       {
790         byte *u_mode_pos = (void *)&c->u_mode;
791         byte *ghash_key_pos = c->u_mode.gcm.u_ghash_key.key;
792         size_t u_mode_head_length = ghash_key_pos - u_mode_pos;
793
794         memset (&c->u_mode, 0, u_mode_head_length);
795       }
796       break;
797
798     case GCRY_CIPHER_MODE_POLY1305:
799       memset (&c->u_mode.poly1305, 0, sizeof c->u_mode.poly1305);
800       break;
801
802     case GCRY_CIPHER_MODE_CCM:
803       memset (&c->u_mode.ccm, 0, sizeof c->u_mode.ccm);
804       break;
805
806     case GCRY_CIPHER_MODE_OCB:
807       memset (&c->u_mode.ocb, 0, sizeof c->u_mode.ocb);
808       /* Setup default taglen.  */
809       c->u_mode.ocb.taglen = 16;
810       break;
811
812     case GCRY_CIPHER_MODE_XTS:
813       memcpy (c->u_mode.xts.tweak_context,
814               c->u_mode.xts.tweak_context + c->spec->contextsize,
815               c->spec->contextsize);
816       break;
817
818     default:
819       break; /* u_mode unused by other modes. */
820     }
821 }
822
823
824 \f
825 static gcry_err_code_t
826 do_ecb_crypt (gcry_cipher_hd_t c,
827               unsigned char *outbuf, size_t outbuflen,
828               const unsigned char *inbuf, size_t inbuflen,
829               gcry_cipher_encrypt_t crypt_fn)
830 {
831   unsigned int blocksize = c->spec->blocksize;
832   size_t n, nblocks;
833   unsigned int burn, nburn;
834
835   if (outbuflen < inbuflen)
836     return GPG_ERR_BUFFER_TOO_SHORT;
837   if ((inbuflen % blocksize))
838     return GPG_ERR_INV_LENGTH;
839
840   nblocks = inbuflen / blocksize;
841   burn = 0;
842
843   for (n=0; n < nblocks; n++ )
844     {
845       nburn = crypt_fn (&c->context.c, outbuf, inbuf);
846       burn = nburn > burn ? nburn : burn;
847       inbuf  += blocksize;
848       outbuf += blocksize;
849     }
850
851   if (burn > 0)
852     _gcry_burn_stack (burn + 4 * sizeof(void *));
853
854   return 0;
855 }
856
857 static gcry_err_code_t
858 do_ecb_encrypt (gcry_cipher_hd_t c,
859                 unsigned char *outbuf, size_t outbuflen,
860                 const unsigned char *inbuf, size_t inbuflen)
861 {
862   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->encrypt);
863 }
864
865 static gcry_err_code_t
866 do_ecb_decrypt (gcry_cipher_hd_t c,
867                 unsigned char *outbuf, size_t outbuflen,
868                 const unsigned char *inbuf, size_t inbuflen)
869 {
870   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->decrypt);
871 }
872
873
874 /****************
875  * Encrypt INBUF to OUTBUF with the mode selected at open.
876  * inbuf and outbuf may overlap or be the same.
877  * Depending on the mode some constraints apply to INBUFLEN.
878  */
879 static gcry_err_code_t
880 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
881                 const byte *inbuf, size_t inbuflen)
882 {
883   gcry_err_code_t rc;
884
885   if (c->mode != GCRY_CIPHER_MODE_NONE && !c->marks.key)
886     {
887       log_error ("cipher_encrypt: key not set\n");
888       return GPG_ERR_MISSING_KEY;
889     }
890
891   switch (c->mode)
892     {
893     case GCRY_CIPHER_MODE_ECB:
894       rc = do_ecb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
895       break;
896
897     case GCRY_CIPHER_MODE_CBC:
898       rc = _gcry_cipher_cbc_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
899       break;
900
901     case GCRY_CIPHER_MODE_CFB:
902       rc = _gcry_cipher_cfb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
903       break;
904
905     case GCRY_CIPHER_MODE_OFB:
906       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
907       break;
908
909     case GCRY_CIPHER_MODE_CTR:
910       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
911       break;
912
913     case GCRY_CIPHER_MODE_AESWRAP:
914       rc = _gcry_cipher_aeswrap_encrypt (c, outbuf, outbuflen,
915                                          inbuf, inbuflen);
916       break;
917
918     case GCRY_CIPHER_MODE_CCM:
919       rc = _gcry_cipher_ccm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
920       break;
921
922     case GCRY_CIPHER_MODE_CMAC:
923       rc = GPG_ERR_INV_CIPHER_MODE;
924       break;
925
926     case GCRY_CIPHER_MODE_GCM:
927       rc = _gcry_cipher_gcm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
928       break;
929
930     case GCRY_CIPHER_MODE_POLY1305:
931       rc = _gcry_cipher_poly1305_encrypt (c, outbuf, outbuflen,
932                                           inbuf, inbuflen);
933       break;
934
935     case GCRY_CIPHER_MODE_OCB:
936       rc = _gcry_cipher_ocb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
937       break;
938
939     case GCRY_CIPHER_MODE_XTS:
940       rc = _gcry_cipher_xts_crypt (c, outbuf, outbuflen, inbuf, inbuflen, 1);
941       break;
942
943     case GCRY_CIPHER_MODE_STREAM:
944       c->spec->stencrypt (&c->context.c,
945                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
946       rc = 0;
947       break;
948
949     case GCRY_CIPHER_MODE_NONE:
950       if (fips_mode () || !_gcry_get_debug_flag (0))
951         {
952           fips_signal_error ("cipher mode NONE used");
953           rc = GPG_ERR_INV_CIPHER_MODE;
954         }
955       else
956         {
957           if (inbuf != outbuf)
958             memmove (outbuf, inbuf, inbuflen);
959           rc = 0;
960         }
961       break;
962
963     default:
964       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
965       rc = GPG_ERR_INV_CIPHER_MODE;
966       break;
967     }
968
969   return rc;
970 }
971
972
973 /****************
974  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
975  * been requested.
976  */
977 gcry_err_code_t
978 _gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
979                       const void *in, size_t inlen)
980 {
981   gcry_err_code_t rc;
982
983   if (!in)  /* Caller requested in-place encryption.  */
984     {
985       in = out;
986       inlen = outsize;
987     }
988
989   rc = cipher_encrypt (h, out, outsize, in, inlen);
990
991   /* Failsafe: Make sure that the plaintext will never make it into
992      OUT if the encryption returned an error.  */
993   if (rc && out)
994     memset (out, 0x42, outsize);
995
996   return rc;
997 }
998
999
1000
1001 /****************
1002  * Decrypt INBUF to OUTBUF with the mode selected at open.
1003  * inbuf and outbuf may overlap or be the same.
1004  * Depending on the mode some some contraints apply to INBUFLEN.
1005  */
1006 static gcry_err_code_t
1007 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
1008                 const byte *inbuf, size_t inbuflen)
1009 {
1010   gcry_err_code_t rc;
1011
1012   if (c->mode != GCRY_CIPHER_MODE_NONE && !c->marks.key)
1013     {
1014       log_error ("cipher_decrypt: key not set\n");
1015       return GPG_ERR_MISSING_KEY;
1016     }
1017
1018   switch (c->mode)
1019     {
1020     case GCRY_CIPHER_MODE_ECB:
1021       rc = do_ecb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1022       break;
1023
1024     case GCRY_CIPHER_MODE_CBC:
1025       rc = _gcry_cipher_cbc_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1026       break;
1027
1028     case GCRY_CIPHER_MODE_CFB:
1029       rc = _gcry_cipher_cfb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1030       break;
1031
1032     case GCRY_CIPHER_MODE_OFB:
1033       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1034       break;
1035
1036     case GCRY_CIPHER_MODE_CTR:
1037       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1038       break;
1039
1040     case GCRY_CIPHER_MODE_AESWRAP:
1041       rc = _gcry_cipher_aeswrap_decrypt (c, outbuf, outbuflen,
1042                                          inbuf, inbuflen);
1043       break;
1044
1045     case GCRY_CIPHER_MODE_CCM:
1046       rc = _gcry_cipher_ccm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1047       break;
1048
1049     case GCRY_CIPHER_MODE_CMAC:
1050       rc = GPG_ERR_INV_CIPHER_MODE;
1051       break;
1052
1053     case GCRY_CIPHER_MODE_GCM:
1054       rc = _gcry_cipher_gcm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1055       break;
1056
1057     case GCRY_CIPHER_MODE_POLY1305:
1058       rc = _gcry_cipher_poly1305_decrypt (c, outbuf, outbuflen,
1059                                           inbuf, inbuflen);
1060       break;
1061
1062     case GCRY_CIPHER_MODE_OCB:
1063       rc = _gcry_cipher_ocb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
1064       break;
1065
1066     case GCRY_CIPHER_MODE_XTS:
1067       rc = _gcry_cipher_xts_crypt (c, outbuf, outbuflen, inbuf, inbuflen, 0);
1068       break;
1069
1070     case GCRY_CIPHER_MODE_STREAM:
1071       c->spec->stdecrypt (&c->context.c,
1072                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
1073       rc = 0;
1074       break;
1075
1076     case GCRY_CIPHER_MODE_NONE:
1077       if (fips_mode () || !_gcry_get_debug_flag (0))
1078         {
1079           fips_signal_error ("cipher mode NONE used");
1080           rc = GPG_ERR_INV_CIPHER_MODE;
1081         }
1082       else
1083         {
1084           if (inbuf != outbuf)
1085             memmove (outbuf, inbuf, inbuflen);
1086           rc = 0;
1087         }
1088       break;
1089
1090     default:
1091       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
1092       rc = GPG_ERR_INV_CIPHER_MODE;
1093       break;
1094     }
1095
1096   return rc;
1097 }
1098
1099
1100 gcry_err_code_t
1101 _gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
1102                       const void *in, size_t inlen)
1103 {
1104   if (!in) /* Caller requested in-place encryption. */
1105     {
1106       in = out;
1107       inlen = outsize;
1108     }
1109
1110   return cipher_decrypt (h, out, outsize, in, inlen);
1111 }
1112
1113
1114
1115 /****************
1116  * Used for PGP's somewhat strange CFB mode. Only works if
1117  * the corresponding flag is set.
1118  */
1119 static void
1120 cipher_sync (gcry_cipher_hd_t c)
1121 {
1122   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
1123     {
1124       memmove (c->u_iv.iv + c->unused,
1125                c->u_iv.iv, c->spec->blocksize - c->unused);
1126       memcpy (c->u_iv.iv,
1127               c->lastiv + c->spec->blocksize - c->unused, c->unused);
1128       c->unused = 0;
1129     }
1130 }
1131
1132
1133 gcry_err_code_t
1134 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
1135 {
1136   return cipher_setkey (hd, (void*)key, keylen);
1137 }
1138
1139
1140 gcry_err_code_t
1141 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
1142 {
1143   gcry_err_code_t rc = 0;
1144
1145   switch (hd->mode)
1146     {
1147       case GCRY_CIPHER_MODE_CCM:
1148         rc = _gcry_cipher_ccm_set_nonce (hd, iv, ivlen);
1149         break;
1150
1151       case GCRY_CIPHER_MODE_GCM:
1152         rc =  _gcry_cipher_gcm_setiv (hd, iv, ivlen);
1153         break;
1154
1155       case GCRY_CIPHER_MODE_POLY1305:
1156         rc =  _gcry_cipher_poly1305_setiv (hd, iv, ivlen);
1157         break;
1158
1159       case GCRY_CIPHER_MODE_OCB:
1160         rc = _gcry_cipher_ocb_set_nonce (hd, iv, ivlen);
1161         break;
1162
1163       default:
1164         rc = cipher_setiv (hd, iv, ivlen);
1165         break;
1166     }
1167   return rc;
1168 }
1169
1170 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1171    block size length, or (NULL,0) to set the CTR to the all-zero
1172    block. */
1173 gpg_err_code_t
1174 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1175 {
1176   if (ctr && ctrlen == hd->spec->blocksize)
1177     {
1178       memcpy (hd->u_ctr.ctr, ctr, hd->spec->blocksize);
1179       hd->unused = 0;
1180     }
1181   else if (!ctr || !ctrlen)
1182     {
1183       memset (hd->u_ctr.ctr, 0, hd->spec->blocksize);
1184       hd->unused = 0;
1185     }
1186   else
1187     return GPG_ERR_INV_ARG;
1188
1189   return 0;
1190 }
1191
1192 gpg_err_code_t
1193 _gcry_cipher_getctr (gcry_cipher_hd_t hd, void *ctr, size_t ctrlen)
1194 {
1195   if (ctr && ctrlen == hd->spec->blocksize)
1196     memcpy (ctr, hd->u_ctr.ctr, hd->spec->blocksize);
1197   else
1198     return GPG_ERR_INV_ARG;
1199
1200   return 0;
1201 }
1202
1203 gcry_err_code_t
1204 _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
1205                            size_t abuflen)
1206 {
1207   gcry_err_code_t rc;
1208
1209   switch (hd->mode)
1210     {
1211     case GCRY_CIPHER_MODE_CCM:
1212       rc = _gcry_cipher_ccm_authenticate (hd, abuf, abuflen);
1213       break;
1214
1215     case GCRY_CIPHER_MODE_CMAC:
1216       rc = _gcry_cipher_cmac_authenticate (hd, abuf, abuflen);
1217       break;
1218
1219     case GCRY_CIPHER_MODE_GCM:
1220       rc = _gcry_cipher_gcm_authenticate (hd, abuf, abuflen);
1221       break;
1222
1223     case GCRY_CIPHER_MODE_POLY1305:
1224       rc = _gcry_cipher_poly1305_authenticate (hd, abuf, abuflen);
1225       break;
1226
1227     case GCRY_CIPHER_MODE_OCB:
1228       rc = _gcry_cipher_ocb_authenticate (hd, abuf, abuflen);
1229       break;
1230
1231     default:
1232       log_error ("gcry_cipher_authenticate: invalid mode %d\n", hd->mode);
1233       rc = GPG_ERR_INV_CIPHER_MODE;
1234       break;
1235     }
1236
1237   return rc;
1238 }
1239
1240
1241 gcry_err_code_t
1242 _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
1243 {
1244   gcry_err_code_t rc;
1245
1246   switch (hd->mode)
1247     {
1248     case GCRY_CIPHER_MODE_CCM:
1249       rc = _gcry_cipher_ccm_get_tag (hd, outtag, taglen);
1250       break;
1251
1252     case GCRY_CIPHER_MODE_CMAC:
1253       rc = _gcry_cipher_cmac_get_tag (hd, outtag, taglen);
1254       break;
1255
1256     case GCRY_CIPHER_MODE_GCM:
1257       rc = _gcry_cipher_gcm_get_tag (hd, outtag, taglen);
1258       break;
1259
1260     case GCRY_CIPHER_MODE_POLY1305:
1261       rc = _gcry_cipher_poly1305_get_tag (hd, outtag, taglen);
1262       break;
1263
1264     case GCRY_CIPHER_MODE_OCB:
1265       rc = _gcry_cipher_ocb_get_tag (hd, outtag, taglen);
1266       break;
1267
1268     default:
1269       log_error ("gcry_cipher_gettag: invalid mode %d\n", hd->mode);
1270       rc = GPG_ERR_INV_CIPHER_MODE;
1271       break;
1272     }
1273
1274   return rc;
1275 }
1276
1277
1278 gcry_err_code_t
1279 _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
1280 {
1281   gcry_err_code_t rc;
1282
1283   switch (hd->mode)
1284     {
1285     case GCRY_CIPHER_MODE_CCM:
1286       rc = _gcry_cipher_ccm_check_tag (hd, intag, taglen);
1287       break;
1288
1289     case GCRY_CIPHER_MODE_CMAC:
1290       rc = _gcry_cipher_cmac_check_tag (hd, intag, taglen);
1291       break;
1292
1293     case GCRY_CIPHER_MODE_GCM:
1294       rc = _gcry_cipher_gcm_check_tag (hd, intag, taglen);
1295       break;
1296
1297     case GCRY_CIPHER_MODE_POLY1305:
1298       rc = _gcry_cipher_poly1305_check_tag (hd, intag, taglen);
1299       break;
1300
1301     case GCRY_CIPHER_MODE_OCB:
1302       rc = _gcry_cipher_ocb_check_tag (hd, intag, taglen);
1303       break;
1304
1305     default:
1306       log_error ("gcry_cipher_checktag: invalid mode %d\n", hd->mode);
1307       rc = GPG_ERR_INV_CIPHER_MODE;
1308       break;
1309     }
1310
1311   return rc;
1312 }
1313
1314
1315 gcry_err_code_t
1316 _gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1317 {
1318   gcry_err_code_t rc = 0;
1319
1320   switch (cmd)
1321     {
1322     case GCRYCTL_RESET:
1323       cipher_reset (h);
1324       break;
1325
1326     case GCRYCTL_FINALIZE:
1327       if (!h || buffer || buflen)
1328         return GPG_ERR_INV_ARG;
1329       h->marks.finalize = 1;
1330       break;
1331
1332     case GCRYCTL_CFB_SYNC:
1333       cipher_sync( h );
1334       break;
1335
1336     case GCRYCTL_SET_CBC_CTS:
1337       if (buflen)
1338         if (h->flags & GCRY_CIPHER_CBC_MAC)
1339           rc = GPG_ERR_INV_FLAG;
1340         else
1341           h->flags |= GCRY_CIPHER_CBC_CTS;
1342       else
1343         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1344       break;
1345
1346     case GCRYCTL_SET_CBC_MAC:
1347       if (buflen)
1348         if (h->flags & GCRY_CIPHER_CBC_CTS)
1349           rc = GPG_ERR_INV_FLAG;
1350         else
1351           h->flags |= GCRY_CIPHER_CBC_MAC;
1352       else
1353         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1354       break;
1355
1356     case GCRYCTL_SET_CCM_LENGTHS:
1357       {
1358         u64 params[3];
1359         size_t encryptedlen;
1360         size_t aadlen;
1361         size_t authtaglen;
1362
1363         if (h->mode != GCRY_CIPHER_MODE_CCM)
1364           return GPG_ERR_INV_CIPHER_MODE;
1365
1366         if (!buffer || buflen != 3 * sizeof(u64))
1367           return GPG_ERR_INV_ARG;
1368
1369         /* This command is used to pass additional length parameters needed
1370            by CCM mode to initialize CBC-MAC.  */
1371         memcpy (params, buffer, sizeof(params));
1372         encryptedlen = params[0];
1373         aadlen = params[1];
1374         authtaglen = params[2];
1375
1376         rc = _gcry_cipher_ccm_set_lengths (h, encryptedlen, aadlen, authtaglen);
1377       }
1378       break;
1379
1380     case GCRYCTL_SET_TAGLEN:
1381       if (!h || !buffer || buflen != sizeof(int) )
1382         return GPG_ERR_INV_ARG;
1383       switch (h->mode)
1384         {
1385         case GCRY_CIPHER_MODE_OCB:
1386           switch (*(int*)buffer)
1387             {
1388             case 8: case 12: case 16:
1389               h->u_mode.ocb.taglen = *(int*)buffer;
1390               break;
1391             default:
1392               rc = GPG_ERR_INV_LENGTH; /* Invalid tag length. */
1393               break;
1394             }
1395           break;
1396
1397         default:
1398           rc =GPG_ERR_INV_CIPHER_MODE;
1399           break;
1400         }
1401       break;
1402
1403     case GCRYCTL_DISABLE_ALGO:
1404       /* This command expects NULL for H and BUFFER to point to an
1405          integer with the algo number.  */
1406       if( h || !buffer || buflen != sizeof(int) )
1407         return GPG_ERR_CIPHER_ALGO;
1408       disable_cipher_algo( *(int*)buffer );
1409       break;
1410
1411     case PRIV_CIPHERCTL_DISABLE_WEAK_KEY:  /* (private)  */
1412       if (h->spec->set_extra_info)
1413         rc = h->spec->set_extra_info
1414           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1415       else
1416         rc = GPG_ERR_NOT_SUPPORTED;
1417       break;
1418
1419     case PRIV_CIPHERCTL_GET_INPUT_VECTOR: /* (private)  */
1420       /* This is the input block as used in CFB and OFB mode which has
1421          initially been set as IV.  The returned format is:
1422            1 byte  Actual length of the block in bytes.
1423            n byte  The block.
1424          If the provided buffer is too short, an error is returned. */
1425       if (buflen < (1 + h->spec->blocksize))
1426         rc = GPG_ERR_TOO_SHORT;
1427       else
1428         {
1429           unsigned char *ivp;
1430           unsigned char *dst = buffer;
1431           int n = h->unused;
1432
1433           if (!n)
1434             n = h->spec->blocksize;
1435           gcry_assert (n <= h->spec->blocksize);
1436           *dst++ = n;
1437           ivp = h->u_iv.iv + h->spec->blocksize - n;
1438           while (n--)
1439             *dst++ = *ivp++;
1440         }
1441       break;
1442
1443     case GCRYCTL_SET_SBOX:
1444       if (h->spec->set_extra_info)
1445         rc = h->spec->set_extra_info
1446           (&h->context.c, GCRYCTL_SET_SBOX, buffer, buflen);
1447       else
1448         rc = GPG_ERR_NOT_SUPPORTED;
1449       break;
1450
1451     default:
1452       rc = GPG_ERR_INV_OP;
1453     }
1454
1455   return rc;
1456 }
1457
1458
1459 /* Return information about the cipher handle H.  CMD is the kind of
1460  * information requested.
1461  *
1462  * CMD may be one of:
1463  *
1464  *  GCRYCTL_GET_TAGLEN:
1465  *      Return the length of the tag for an AE algorithm mode.  An
1466  *      error is returned for modes which do not support a tag.
1467  *      BUFFER must be given as NULL.  On success the result is stored
1468  *      at NBYTES.  The taglen is returned in bytes.
1469  *
1470  * The function returns 0 on success or an error code.
1471  */
1472 gcry_err_code_t
1473 _gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1474 {
1475   gcry_err_code_t rc = 0;
1476
1477   switch (cmd)
1478     {
1479     case GCRYCTL_GET_TAGLEN:
1480       if (!h || buffer || !nbytes)
1481         rc = GPG_ERR_INV_ARG;
1482       else
1483         {
1484           switch (h->mode)
1485             {
1486             case GCRY_CIPHER_MODE_OCB:
1487               *nbytes = h->u_mode.ocb.taglen;
1488               break;
1489
1490             case GCRY_CIPHER_MODE_CCM:
1491               *nbytes = h->u_mode.ccm.authlen;
1492               break;
1493
1494             case GCRY_CIPHER_MODE_GCM:
1495               *nbytes = GCRY_GCM_BLOCK_LEN;
1496               break;
1497
1498             case GCRY_CIPHER_MODE_POLY1305:
1499               *nbytes = POLY1305_TAGLEN;
1500               break;
1501
1502             default:
1503               rc = GPG_ERR_INV_CIPHER_MODE;
1504               break;
1505             }
1506         }
1507       break;
1508
1509     default:
1510       rc = GPG_ERR_INV_OP;
1511     }
1512
1513   return rc;
1514 }
1515
1516 /* Return information about the given cipher algorithm ALGO.
1517
1518    WHAT select the kind of information returned:
1519
1520     GCRYCTL_GET_KEYLEN:
1521         Return the length of the key.  If the algorithm ALGO
1522         supports multiple key lengths, the maximum supported key length
1523         is returned.  The key length is returned as number of octets.
1524         BUFFER and NBYTES must be zero.
1525
1526     GCRYCTL_GET_BLKLEN:
1527         Return the blocklength of the algorithm ALGO counted in octets.
1528         BUFFER and NBYTES must be zero.
1529
1530     GCRYCTL_TEST_ALGO:
1531         Returns 0 if the specified algorithm ALGO is available for use.
1532         BUFFER and NBYTES must be zero.
1533
1534    Note: Because this function is in most cases used to return an
1535    integer value, we can make it easier for the caller to just look at
1536    the return value.  The caller will in all cases consult the value
1537    and thereby detecting whether a error occurred or not (i.e. while
1538    checking the block size)
1539  */
1540 gcry_err_code_t
1541 _gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1542 {
1543   gcry_err_code_t rc = 0;
1544   unsigned int ui;
1545
1546   switch (what)
1547     {
1548     case GCRYCTL_GET_KEYLEN:
1549       if (buffer || (! nbytes))
1550         rc = GPG_ERR_CIPHER_ALGO;
1551       else
1552         {
1553           ui = cipher_get_keylen (algo);
1554           if ((ui > 0) && (ui <= 512))
1555             *nbytes = (size_t) ui / 8;
1556           else
1557             /* The only reason for an error is an invalid algo.  */
1558             rc = GPG_ERR_CIPHER_ALGO;
1559         }
1560       break;
1561
1562     case GCRYCTL_GET_BLKLEN:
1563       if (buffer || (! nbytes))
1564         rc = GPG_ERR_CIPHER_ALGO;
1565       else
1566         {
1567           ui = cipher_get_blocksize (algo);
1568           if ((ui > 0) && (ui < 10000))
1569             *nbytes = ui;
1570           else
1571             {
1572               /* The only reason is an invalid algo or a strange
1573                  blocksize.  */
1574               rc = GPG_ERR_CIPHER_ALGO;
1575             }
1576         }
1577       break;
1578
1579     case GCRYCTL_TEST_ALGO:
1580       if (buffer || nbytes)
1581         rc = GPG_ERR_INV_ARG;
1582       else
1583         rc = check_cipher_algo (algo);
1584       break;
1585
1586       default:
1587         rc = GPG_ERR_INV_OP;
1588     }
1589
1590   return rc;
1591 }
1592
1593
1594 /* This function returns length of the key for algorithm ALGO.  If the
1595    algorithm supports multiple key lengths, the maximum supported key
1596    length is returned.  On error 0 is returned.  The key length is
1597    returned as number of octets.
1598
1599    This is a convenience functions which should be preferred over
1600    gcry_cipher_algo_info because it allows for proper type
1601    checking.  */
1602 size_t
1603 _gcry_cipher_get_algo_keylen (int algo)
1604 {
1605   size_t n;
1606
1607   if (_gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1608     n = 0;
1609   return n;
1610 }
1611
1612
1613 /* This functions returns the blocklength of the algorithm ALGO
1614    counted in octets.  On error 0 is returned.
1615
1616    This is a convenience functions which should be preferred over
1617    gcry_cipher_algo_info because it allows for proper type
1618    checking.  */
1619 size_t
1620 _gcry_cipher_get_algo_blklen (int algo)
1621 {
1622   size_t n;
1623
1624   if (_gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1625     n = 0;
1626   return n;
1627 }
1628
1629
1630 /* Explicitly initialize this module.  */
1631 gcry_err_code_t
1632 _gcry_cipher_init (void)
1633 {
1634   if (fips_mode())
1635     {
1636       /* disable algorithms that are disallowed in fips */
1637       int idx;
1638       gcry_cipher_spec_t *spec;
1639
1640       for (idx = 0; (spec = cipher_list[idx]); idx++)
1641         if (!spec->flags.fips)
1642           spec->flags.disabled = 1;
1643     }
1644
1645   return 0;
1646 }
1647
1648
1649 /* Run the selftests for cipher algorithm ALGO with optional reporting
1650    function REPORT.  */
1651 gpg_error_t
1652 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
1653 {
1654   gcry_err_code_t ec = 0;
1655   gcry_cipher_spec_t *spec;
1656
1657   spec = spec_from_algo (algo);
1658   if (spec && !spec->flags.disabled && spec->selftest)
1659     ec = spec->selftest (algo, extended, report);
1660   else
1661     {
1662       ec = GPG_ERR_CIPHER_ALGO;
1663       if (report)
1664         report ("cipher", algo, "module",
1665                 (spec && !spec->flags.disabled)?
1666                 "no selftest available" :
1667                 spec? "algorithm disabled" : "algorithm not found");
1668     }
1669
1670   return gpg_error (ec);
1671 }