8c5a0b4ed8a38a738cc418a8125b80091beebaca
[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 "cipher.h"
30 #include "ath.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     NULL
88   };
89
90
91
92 \f
93 static int
94 map_algo (int algo)
95 {
96   return algo;
97 }
98
99
100 /* Return the spec structure for the cipher algorithm ALGO.  For
101    an unknown algorithm NULL is returned.  */
102 static gcry_cipher_spec_t *
103 spec_from_algo (int algo)
104 {
105   int idx;
106   gcry_cipher_spec_t *spec;
107
108   algo = map_algo (algo);
109
110   for (idx = 0; (spec = cipher_list[idx]); idx++)
111     if (algo == spec->algo)
112       return spec;
113   return NULL;
114 }
115
116
117 /* Lookup a cipher's spec by its name.  */
118 static gcry_cipher_spec_t *
119 spec_from_name (const char *name)
120 {
121   gcry_cipher_spec_t *spec;
122   int idx;
123   const char **aliases;
124
125   for (idx=0; (spec = cipher_list[idx]); idx++)
126     {
127       if (!stricmp (name, spec->name))
128         return spec;
129       if (spec->aliases)
130         {
131           for (aliases = spec->aliases; *aliases; aliases++)
132             if (!stricmp (name, *aliases))
133               return spec;
134         }
135     }
136
137   return NULL;
138 }
139
140
141 /* Lookup a cipher's spec by its OID.  */
142 static gcry_cipher_spec_t *
143 spec_from_oid (const char *oid)
144 {
145   gcry_cipher_spec_t *spec;
146   gcry_cipher_oid_spec_t *oid_specs;
147   int idx, j;
148
149   for (idx=0; (spec = cipher_list[idx]); idx++)
150     {
151       oid_specs = spec->oids;
152       if (oid_specs)
153         {
154           for (j = 0; oid_specs[j].oid; j++)
155             if (!stricmp (oid, oid_specs[j].oid))
156               return spec;
157         }
158     }
159
160   return NULL;
161 }
162
163
164 /* Locate the OID in the oid table and return the spec or NULL if not
165    found.  An optional "oid." or "OID." prefix in OID is ignored, the
166    OID is expected to be in standard IETF dotted notation.  A pointer
167    to the OID specification of the module implementing this algorithm
168    is return in OID_SPEC unless passed as NULL.*/
169 static gcry_cipher_spec_t *
170 search_oid (const char *oid, gcry_cipher_oid_spec_t *oid_spec)
171 {
172   gcry_cipher_spec_t *spec;
173   int i;
174
175   if (oid && ((! strncmp (oid, "oid.", 4))
176               || (! strncmp (oid, "OID.", 4))))
177     oid += 4;
178
179   spec = spec_from_oid (oid);
180   if (spec && spec->oids)
181     {
182       for (i = 0; spec->oids[i].oid; i++)
183         if (!stricmp (oid, spec->oids[i].oid))
184           {
185             if (oid_spec)
186               *oid_spec = spec->oids[i];
187             return spec;
188           }
189     }
190
191   return NULL;
192 }
193
194
195 /* Map STRING to the cipher algorithm identifier.  Returns the
196    algorithm ID of the cipher for the given name or 0 if the name is
197    not known.  It is valid to pass NULL for STRING which results in a
198    return value of 0. */
199 int
200 _gcry_cipher_map_name (const char *string)
201 {
202   gcry_cipher_spec_t *spec;
203
204   if (!string)
205     return 0;
206
207   /* If the string starts with a digit (optionally prefixed with
208      either "OID." or "oid."), we first look into our table of ASN.1
209      object identifiers to figure out the algorithm */
210
211   spec = search_oid (string, NULL);
212   if (spec)
213     return spec->algo;
214
215   spec = spec_from_name (string);
216   if (spec)
217     return spec->algo;
218
219   return 0;
220 }
221
222
223 /* Given a STRING with an OID in dotted decimal notation, this
224    function returns the cipher mode (GCRY_CIPHER_MODE_*) associated
225    with that OID or 0 if no mode is known.  Passing NULL for string
226    yields a return value of 0. */
227 int
228 _gcry_cipher_mode_from_oid (const char *string)
229 {
230   gcry_cipher_spec_t *spec;
231   gcry_cipher_oid_spec_t oid_spec;
232
233   if (!string)
234     return 0;
235
236   spec = search_oid (string, &oid_spec);
237   if (spec)
238     return oid_spec.mode;
239
240   return 0;
241 }
242
243
244 /* Map the cipher algorithm identifier ALGORITHM to a string
245    representing this algorithm.  This string is the default name as
246    used by Libgcrypt.  A "?" is returned for an unknown algorithm.
247    NULL is never returned. */
248 const char *
249 _gcry_cipher_algo_name (int algorithm)
250 {
251   gcry_cipher_spec_t *spec;
252
253   spec = spec_from_algo (algorithm);
254   return spec? spec->name : "?";
255 }
256
257
258 /* Flag the cipher algorithm with the identifier ALGORITHM as
259    disabled.  There is no error return, the function does nothing for
260    unknown algorithms.  Disabled algorithms are virtually not
261    available in Libgcrypt.  This is not thread safe and should thus be
262    called early. */
263 static void
264 disable_cipher_algo (int algo)
265 {
266   gcry_cipher_spec_t *spec = spec_from_algo (algo);
267
268   if (spec)
269     spec->flags.disabled = 1;
270 }
271
272
273 /* Return 0 if the cipher algorithm with identifier ALGORITHM is
274    available. Returns a basic error code value if it is not
275    available.  */
276 static gcry_err_code_t
277 check_cipher_algo (int algorithm)
278 {
279   gcry_cipher_spec_t *spec;
280
281   spec = spec_from_algo (algorithm);
282   if (spec && !spec->flags.disabled)
283     return 0;
284
285   return GPG_ERR_CIPHER_ALGO;
286 }
287
288
289 /* Return the standard length in bits of the key for the cipher
290    algorithm with the identifier ALGORITHM.  */
291 static unsigned int
292 cipher_get_keylen (int algorithm)
293 {
294   gcry_cipher_spec_t *spec;
295   unsigned len = 0;
296
297   spec = spec_from_algo (algorithm);
298   if (spec)
299     {
300       len = spec->keylen;
301       if (!len)
302         log_bug ("cipher %d w/o key length\n", algorithm);
303     }
304
305   return len;
306 }
307
308
309 /* Return the block length of the cipher algorithm with the identifier
310    ALGORITHM.  This function return 0 for an invalid algorithm.  */
311 static unsigned int
312 cipher_get_blocksize (int algorithm)
313 {
314   gcry_cipher_spec_t *spec;
315   unsigned len = 0;
316
317   spec = spec_from_algo (algorithm);
318   if (spec)
319     {
320       len = spec->blocksize;
321       if (!len)
322         log_bug ("cipher %d w/o blocksize\n", algorithm);
323     }
324
325   return len;
326 }
327
328
329 /*
330    Open a cipher handle for use with cipher algorithm ALGORITHM, using
331    the cipher mode MODE (one of the GCRY_CIPHER_MODE_*) and return a
332    handle in HANDLE.  Put NULL into HANDLE and return an error code if
333    something goes wrong.  FLAGS may be used to modify the
334    operation.  The defined flags are:
335
336    GCRY_CIPHER_SECURE:  allocate all internal buffers in secure memory.
337    GCRY_CIPHER_ENABLE_SYNC:  Enable the sync operation as used in OpenPGP.
338    GCRY_CIPHER_CBC_CTS:  Enable CTS mode.
339    GCRY_CIPHER_CBC_MAC:  Enable MAC mode.
340
341    Values for these flags may be combined using OR.
342  */
343 gcry_err_code_t
344 _gcry_cipher_open (gcry_cipher_hd_t *handle,
345                    int algo, int mode, unsigned int flags)
346 {
347   gcry_err_code_t rc;
348   gcry_cipher_hd_t h = NULL;
349
350   if (mode >= GCRY_CIPHER_MODE_INTERNAL)
351     rc = GPG_ERR_INV_CIPHER_MODE;
352   else
353     rc = _gcry_cipher_open_internal (&h, algo, mode, flags);
354
355   *handle = rc ? NULL : h;
356
357   return rc;
358 }
359
360
361 gcry_err_code_t
362 _gcry_cipher_open_internal (gcry_cipher_hd_t *handle,
363                             int algo, int mode, unsigned int flags)
364 {
365   int secure = (flags & GCRY_CIPHER_SECURE);
366   gcry_cipher_spec_t *spec;
367   gcry_cipher_hd_t h = NULL;
368   gcry_err_code_t err;
369
370   /* If the application missed to call the random poll function, we do
371      it here to ensure that it is used once in a while. */
372   _gcry_fast_random_poll ();
373
374   spec = spec_from_algo (algo);
375   if (!spec)
376     err = GPG_ERR_CIPHER_ALGO;
377   else if (spec->flags.disabled)
378     err = GPG_ERR_CIPHER_ALGO;
379   else
380     err = 0;
381
382   /* check flags */
383   if ((! err)
384       && ((flags & ~(0
385                      | GCRY_CIPHER_SECURE
386                      | GCRY_CIPHER_ENABLE_SYNC
387                      | GCRY_CIPHER_CBC_CTS
388                      | GCRY_CIPHER_CBC_MAC))
389           || (flags & GCRY_CIPHER_CBC_CTS & GCRY_CIPHER_CBC_MAC)))
390     err = GPG_ERR_CIPHER_ALGO;
391
392   /* check that a valid mode has been requested */
393   if (! err)
394     switch (mode)
395       {
396       case GCRY_CIPHER_MODE_CCM:
397 #ifdef HAVE_U64_TYPEDEF
398         if (spec->blocksize != GCRY_CCM_BLOCK_LEN)
399           err = GPG_ERR_INV_CIPHER_MODE;
400         if (!spec->encrypt || !spec->decrypt)
401           err = GPG_ERR_INV_CIPHER_MODE;
402         break;
403 #else
404         err = GPG_ERR_NOT_SUPPORTED;
405 #endif
406
407       case GCRY_CIPHER_MODE_ECB:
408       case GCRY_CIPHER_MODE_CBC:
409       case GCRY_CIPHER_MODE_CFB:
410       case GCRY_CIPHER_MODE_OFB:
411       case GCRY_CIPHER_MODE_CTR:
412       case GCRY_CIPHER_MODE_AESWRAP:
413       case GCRY_CIPHER_MODE_CMAC:
414       case GCRY_CIPHER_MODE_GCM:
415         if (!spec->encrypt || !spec->decrypt)
416           err = GPG_ERR_INV_CIPHER_MODE;
417         break;
418
419       case GCRY_CIPHER_MODE_STREAM:
420         if (!spec->stencrypt || !spec->stdecrypt)
421           err = GPG_ERR_INV_CIPHER_MODE;
422         break;
423
424       case GCRY_CIPHER_MODE_NONE:
425         /* This mode may be used for debugging.  It copies the main
426            text verbatim to the ciphertext.  We do not allow this in
427            fips mode or if no debug flag has been set.  */
428         if (fips_mode () || !_gcry_get_debug_flag (0))
429           err = GPG_ERR_INV_CIPHER_MODE;
430         break;
431
432       default:
433         err = GPG_ERR_INV_CIPHER_MODE;
434       }
435
436   /* Perform selftest here and mark this with a flag in cipher_table?
437      No, we should not do this as it takes too long.  Further it does
438      not make sense to exclude algorithms with failing selftests at
439      runtime: If a selftest fails there is something seriously wrong with the system and thus we better die immediately. */
440
441   if (! err)
442     {
443       size_t size = (sizeof (*h)
444                      + 2 * spec->contextsize
445                      - sizeof (cipher_context_alignment_t)
446 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
447                      + 15  /* Space for leading alignment gap.  */
448 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
449                      );
450
451       if (secure)
452         h = xtrycalloc_secure (1, size);
453       else
454         h = xtrycalloc (1, size);
455
456       if (! h)
457         err = gpg_err_code_from_syserror ();
458       else
459         {
460           size_t off = 0;
461
462 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
463           if ( ((unsigned long)h & 0x0f) )
464             {
465               /* The malloced block is not aligned on a 16 byte
466                  boundary.  Correct for this.  */
467               off = 16 - ((unsigned long)h & 0x0f);
468               h = (void*)((char*)h + off);
469             }
470 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
471
472           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
473           h->actual_handle_size = size - off;
474           h->handle_offset = off;
475           h->spec = spec;
476           h->algo = algo;
477           h->mode = mode;
478           h->flags = flags;
479
480           /* Setup bulk encryption routines.  */
481           switch (algo)
482             {
483 #ifdef USE_AES
484             case GCRY_CIPHER_AES128:
485             case GCRY_CIPHER_AES192:
486             case GCRY_CIPHER_AES256:
487               h->bulk.cfb_enc = _gcry_aes_cfb_enc;
488               h->bulk.cfb_dec = _gcry_aes_cfb_dec;
489               h->bulk.cbc_enc = _gcry_aes_cbc_enc;
490               h->bulk.cbc_dec = _gcry_aes_cbc_dec;
491               h->bulk.ctr_enc = _gcry_aes_ctr_enc;
492               break;
493 #endif /*USE_AES*/
494 #ifdef USE_BLOWFISH
495             case GCRY_CIPHER_BLOWFISH:
496               h->bulk.cfb_dec = _gcry_blowfish_cfb_dec;
497               h->bulk.cbc_dec = _gcry_blowfish_cbc_dec;
498               h->bulk.ctr_enc = _gcry_blowfish_ctr_enc;
499               break;
500 #endif /*USE_BLOWFISH*/
501 #ifdef USE_CAST5
502             case GCRY_CIPHER_CAST5:
503               h->bulk.cfb_dec = _gcry_cast5_cfb_dec;
504               h->bulk.cbc_dec = _gcry_cast5_cbc_dec;
505               h->bulk.ctr_enc = _gcry_cast5_ctr_enc;
506               break;
507 #endif /*USE_CAMELLIA*/
508 #ifdef USE_CAMELLIA
509             case GCRY_CIPHER_CAMELLIA128:
510             case GCRY_CIPHER_CAMELLIA192:
511             case GCRY_CIPHER_CAMELLIA256:
512               h->bulk.cbc_dec = _gcry_camellia_cbc_dec;
513               h->bulk.cfb_dec = _gcry_camellia_cfb_dec;
514               h->bulk.ctr_enc = _gcry_camellia_ctr_enc;
515               break;
516 #endif /*USE_CAMELLIA*/
517 #ifdef USE_SERPENT
518             case GCRY_CIPHER_SERPENT128:
519             case GCRY_CIPHER_SERPENT192:
520             case GCRY_CIPHER_SERPENT256:
521               h->bulk.cbc_dec = _gcry_serpent_cbc_dec;
522               h->bulk.cfb_dec = _gcry_serpent_cfb_dec;
523               h->bulk.ctr_enc = _gcry_serpent_ctr_enc;
524               break;
525 #endif /*USE_SERPENT*/
526 #ifdef USE_TWOFISH
527             case GCRY_CIPHER_TWOFISH:
528             case GCRY_CIPHER_TWOFISH128:
529               h->bulk.cbc_dec = _gcry_twofish_cbc_dec;
530               h->bulk.cfb_dec = _gcry_twofish_cfb_dec;
531               h->bulk.ctr_enc = _gcry_twofish_ctr_enc;
532               break;
533 #endif /*USE_TWOFISH*/
534
535             default:
536               break;
537             }
538         }
539     }
540
541   /* Done.  */
542
543   *handle = err ? NULL : h;
544
545   return gcry_error (err);
546 }
547
548
549 /* Release all resources associated with the cipher handle H. H may be
550    NULL in which case this is a no-operation. */
551 void
552 _gcry_cipher_close (gcry_cipher_hd_t h)
553 {
554   size_t off;
555
556   if (!h)
557     return;
558
559   if ((h->magic != CTX_MAGIC_SECURE)
560       && (h->magic != CTX_MAGIC_NORMAL))
561     _gcry_fatal_error(GPG_ERR_INTERNAL,
562                       "gcry_cipher_close: already closed/invalid handle");
563   else
564     h->magic = 0;
565
566   /* We always want to wipe out the memory even when the context has
567      been allocated in secure memory.  The user might have disabled
568      secure memory or is using his own implementation which does not
569      do the wiping.  To accomplish this we need to keep track of the
570      actual size of this structure because we have no way to known
571      how large the allocated area was when using a standard malloc. */
572   off = h->handle_offset;
573   wipememory (h, h->actual_handle_size);
574
575   xfree ((char*)h - off);
576 }
577
578
579 /* Set the key to be used for the encryption context C to KEY with
580    length KEYLEN.  The length should match the required length. */
581 static gcry_err_code_t
582 cipher_setkey (gcry_cipher_hd_t c, byte *key, size_t keylen)
583 {
584   gcry_err_code_t rc;
585
586   rc = c->spec->setkey (&c->context.c, key, keylen);
587   if (!rc)
588     {
589       /* Duplicate initial context.  */
590       memcpy ((void *) ((char *) &c->context.c + c->spec->contextsize),
591               (void *) &c->context.c,
592               c->spec->contextsize);
593       c->marks.key = 1;
594
595       switch (c->mode)
596         {
597         case GCRY_CIPHER_MODE_CMAC:
598           _gcry_cipher_cmac_set_subkeys (c);
599           break;
600
601         case GCRY_CIPHER_MODE_GCM:
602           _gcry_cipher_gcm_setkey (c);
603           break;
604
605         default:
606           break;
607         };
608     }
609   else
610     c->marks.key = 0;
611
612   return rc;
613 }
614
615
616 /* Set the IV to be used for the encryption context C to IV with
617    length IVLEN.  The length should match the required length. */
618 static gcry_err_code_t
619 cipher_setiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
620 {
621   /* GCM has its own IV handler */
622   if (c->mode == GCRY_CIPHER_MODE_GCM)
623     return _gcry_cipher_gcm_setiv (c, iv, ivlen);
624
625   /* If the cipher has its own IV handler, we use only this one.  This
626      is currently used for stream ciphers requiring a nonce.  */
627   if (c->spec->setiv)
628     {
629       c->spec->setiv (&c->context.c, iv, ivlen);
630       return 0;
631     }
632
633   memset (c->u_iv.iv, 0, c->spec->blocksize);
634   if (iv)
635     {
636       if (ivlen != c->spec->blocksize)
637         {
638           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
639                     (unsigned int)ivlen, (unsigned int)c->spec->blocksize);
640           fips_signal_error ("IV length does not match blocklength");
641         }
642       if (ivlen > c->spec->blocksize)
643         ivlen = c->spec->blocksize;
644       memcpy (c->u_iv.iv, iv, ivlen);
645       c->marks.iv = 1;
646     }
647   else
648       c->marks.iv = 0;
649   c->unused = 0;
650
651   return 0;
652 }
653
654
655 /* Reset the cipher context to the initial context.  This is basically
656    the same as an release followed by a new. */
657 static void
658 cipher_reset (gcry_cipher_hd_t c)
659 {
660   unsigned int marks_key;
661
662   marks_key = c->marks.key;
663
664   memcpy (&c->context.c,
665           (char *) &c->context.c + c->spec->contextsize,
666           c->spec->contextsize);
667   memset (&c->marks, 0, sizeof c->marks);
668   memset (c->u_iv.iv, 0, c->spec->blocksize);
669   memset (c->lastiv, 0, c->spec->blocksize);
670   memset (c->u_ctr.ctr, 0, c->spec->blocksize);
671   c->unused = 0;
672
673   c->marks.key = marks_key;
674
675   switch (c->mode)
676     {
677     case GCRY_CIPHER_MODE_CMAC:
678       /* Only clear 'tag' for cmac, keep subkeys. */
679       c->u_mode.cmac.tag = 0;
680       break;
681
682     case GCRY_CIPHER_MODE_GCM:
683       /* Only clear head of u_mode, keep ghash_key and gcm_table. */
684       {
685         byte *u_mode_pos = (void *)&c->u_mode;
686         byte *ghash_key_pos = c->u_mode.gcm.u_ghash_key.key;
687         size_t u_mode_head_length = ghash_key_pos - u_mode_pos;
688
689         memset (&c->u_mode, 0, u_mode_head_length);
690       }
691       break;
692
693 #ifdef HAVE_U64_TYPEDEF
694     case GCRY_CIPHER_MODE_CCM:
695       memset (&c->u_mode.ccm, 0, sizeof c->u_mode.ccm);
696       break;
697 #endif
698
699     default:
700       break; /* u_mode unused by other modes. */
701     }
702 }
703
704
705 \f
706 static gcry_err_code_t
707 do_ecb_crypt (gcry_cipher_hd_t c,
708               unsigned char *outbuf, size_t outbuflen,
709               const unsigned char *inbuf, size_t inbuflen,
710               gcry_cipher_encrypt_t crypt_fn)
711 {
712   unsigned int blocksize = c->spec->blocksize;
713   size_t n, nblocks;
714   unsigned int burn, nburn;
715
716   if (outbuflen < inbuflen)
717     return GPG_ERR_BUFFER_TOO_SHORT;
718   if ((inbuflen % blocksize))
719     return GPG_ERR_INV_LENGTH;
720
721   nblocks = inbuflen / blocksize;
722   burn = 0;
723
724   for (n=0; n < nblocks; n++ )
725     {
726       nburn = crypt_fn (&c->context.c, outbuf, inbuf);
727       burn = nburn > burn ? nburn : burn;
728       inbuf  += blocksize;
729       outbuf += blocksize;
730     }
731
732   if (burn > 0)
733     _gcry_burn_stack (burn + 4 * sizeof(void *));
734
735   return 0;
736 }
737
738 static gcry_err_code_t
739 do_ecb_encrypt (gcry_cipher_hd_t c,
740                 unsigned char *outbuf, size_t outbuflen,
741                 const unsigned char *inbuf, size_t inbuflen)
742 {
743   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->encrypt);
744 }
745
746 static gcry_err_code_t
747 do_ecb_decrypt (gcry_cipher_hd_t c,
748                 unsigned char *outbuf, size_t outbuflen,
749                 const unsigned char *inbuf, size_t inbuflen)
750 {
751   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->decrypt);
752 }
753
754
755 /****************
756  * Encrypt INBUF to OUTBUF with the mode selected at open.
757  * inbuf and outbuf may overlap or be the same.
758  * Depending on the mode some constraints apply to INBUFLEN.
759  */
760 static gcry_err_code_t
761 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
762                 const byte *inbuf, size_t inbuflen)
763 {
764   gcry_err_code_t rc;
765
766   switch (c->mode)
767     {
768     case GCRY_CIPHER_MODE_ECB:
769       rc = do_ecb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
770       break;
771
772     case GCRY_CIPHER_MODE_CBC:
773       rc = _gcry_cipher_cbc_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
774       break;
775
776     case GCRY_CIPHER_MODE_CFB:
777       rc = _gcry_cipher_cfb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
778       break;
779
780     case GCRY_CIPHER_MODE_OFB:
781       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
782       break;
783
784     case GCRY_CIPHER_MODE_CTR:
785       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
786       break;
787
788     case GCRY_CIPHER_MODE_AESWRAP:
789       rc = _gcry_cipher_aeswrap_encrypt (c, outbuf, outbuflen,
790                                          inbuf, inbuflen);
791       break;
792
793     case GCRY_CIPHER_MODE_CCM:
794       rc = _gcry_cipher_ccm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
795       break;
796
797     case GCRY_CIPHER_MODE_CMAC:
798       rc = GPG_ERR_INV_CIPHER_MODE;
799       break;
800
801     case GCRY_CIPHER_MODE_GCM:
802       rc = _gcry_cipher_gcm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
803       break;
804
805     case GCRY_CIPHER_MODE_STREAM:
806       c->spec->stencrypt (&c->context.c,
807                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
808       rc = 0;
809       break;
810
811     case GCRY_CIPHER_MODE_NONE:
812       if (fips_mode () || !_gcry_get_debug_flag (0))
813         {
814           fips_signal_error ("cipher mode NONE used");
815           rc = GPG_ERR_INV_CIPHER_MODE;
816         }
817       else
818         {
819           if (inbuf != outbuf)
820             memmove (outbuf, inbuf, inbuflen);
821           rc = 0;
822         }
823       break;
824
825     default:
826       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
827       rc = GPG_ERR_INV_CIPHER_MODE;
828       break;
829     }
830
831   return rc;
832 }
833
834
835 /****************
836  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
837  * been requested.
838  */
839 gcry_err_code_t
840 _gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
841                       const void *in, size_t inlen)
842 {
843   gcry_err_code_t rc;
844
845   if (!in)  /* Caller requested in-place encryption.  */
846     {
847       in = out;
848       inlen = outsize;
849     }
850
851   rc = cipher_encrypt (h, out, outsize, in, inlen);
852
853   /* Failsafe: Make sure that the plaintext will never make it into
854      OUT if the encryption returned an error.  */
855   if (rc && out)
856     memset (out, 0x42, outsize);
857
858   return rc;
859 }
860
861
862
863 /****************
864  * Decrypt INBUF to OUTBUF with the mode selected at open.
865  * inbuf and outbuf may overlap or be the same.
866  * Depending on the mode some some contraints apply to INBUFLEN.
867  */
868 static gcry_err_code_t
869 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
870                 const byte *inbuf, size_t inbuflen)
871 {
872   gcry_err_code_t rc;
873
874   switch (c->mode)
875     {
876     case GCRY_CIPHER_MODE_ECB:
877       rc = do_ecb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
878       break;
879
880     case GCRY_CIPHER_MODE_CBC:
881       rc = _gcry_cipher_cbc_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
882       break;
883
884     case GCRY_CIPHER_MODE_CFB:
885       rc = _gcry_cipher_cfb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
886       break;
887
888     case GCRY_CIPHER_MODE_OFB:
889       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
890       break;
891
892     case GCRY_CIPHER_MODE_CTR:
893       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
894       break;
895
896     case GCRY_CIPHER_MODE_AESWRAP:
897       rc = _gcry_cipher_aeswrap_decrypt (c, outbuf, outbuflen,
898                                          inbuf, inbuflen);
899       break;
900
901     case GCRY_CIPHER_MODE_CCM:
902       rc = _gcry_cipher_ccm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
903       break;
904
905     case GCRY_CIPHER_MODE_CMAC:
906       rc = GPG_ERR_INV_CIPHER_MODE;
907       break;
908
909     case GCRY_CIPHER_MODE_GCM:
910       rc = _gcry_cipher_gcm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
911       break;
912
913     case GCRY_CIPHER_MODE_STREAM:
914       c->spec->stdecrypt (&c->context.c,
915                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
916       rc = 0;
917       break;
918
919     case GCRY_CIPHER_MODE_NONE:
920       if (fips_mode () || !_gcry_get_debug_flag (0))
921         {
922           fips_signal_error ("cipher mode NONE used");
923           rc = GPG_ERR_INV_CIPHER_MODE;
924         }
925       else
926         {
927           if (inbuf != outbuf)
928             memmove (outbuf, inbuf, inbuflen);
929           rc = 0;
930         }
931       break;
932
933     default:
934       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
935       rc = GPG_ERR_INV_CIPHER_MODE;
936       break;
937     }
938
939   return rc;
940 }
941
942
943 gcry_err_code_t
944 _gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
945                       const void *in, size_t inlen)
946 {
947   if (!in) /* Caller requested in-place encryption. */
948     {
949       in = out;
950       inlen = outsize;
951     }
952
953   return cipher_decrypt (h, out, outsize, in, inlen);
954 }
955
956
957
958 /****************
959  * Used for PGP's somewhat strange CFB mode. Only works if
960  * the corresponding flag is set.
961  */
962 static void
963 cipher_sync (gcry_cipher_hd_t c)
964 {
965   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
966     {
967       memmove (c->u_iv.iv + c->unused,
968                c->u_iv.iv, c->spec->blocksize - c->unused);
969       memcpy (c->u_iv.iv,
970               c->lastiv + c->spec->blocksize - c->unused, c->unused);
971       c->unused = 0;
972     }
973 }
974
975
976 gcry_err_code_t
977 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
978 {
979   return cipher_setkey (hd, (void*)key, keylen);
980 }
981
982
983 gcry_err_code_t
984 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
985 {
986   gcry_err_code_t rc = 0;
987
988   switch (hd->mode)
989     {
990       case GCRY_CIPHER_MODE_CCM:
991         rc = _gcry_cipher_ccm_set_nonce (hd, iv, ivlen);
992         break;
993
994       default:
995         rc = cipher_setiv (hd, iv, ivlen);
996         break;
997     }
998   return rc;
999 }
1000
1001 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
1002    block size length, or (NULL,0) to set the CTR to the all-zero
1003    block. */
1004 gpg_err_code_t
1005 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1006 {
1007   if (ctr && ctrlen == hd->spec->blocksize)
1008     {
1009       memcpy (hd->u_ctr.ctr, ctr, hd->spec->blocksize);
1010       hd->unused = 0;
1011     }
1012   else if (!ctr || !ctrlen)
1013     {
1014       memset (hd->u_ctr.ctr, 0, hd->spec->blocksize);
1015       hd->unused = 0;
1016     }
1017   else
1018     return GPG_ERR_INV_ARG;
1019
1020   return 0;
1021 }
1022
1023
1024 gcry_err_code_t
1025 _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
1026                            size_t abuflen)
1027 {
1028   gcry_err_code_t rc;
1029
1030   switch (hd->mode)
1031     {
1032     case GCRY_CIPHER_MODE_CCM:
1033       rc = _gcry_cipher_ccm_authenticate (hd, abuf, abuflen);
1034       break;
1035
1036     case GCRY_CIPHER_MODE_CMAC:
1037       rc = _gcry_cipher_cmac_authenticate (hd, abuf, abuflen);
1038       break;
1039
1040     case GCRY_CIPHER_MODE_GCM:
1041       rc = _gcry_cipher_gcm_authenticate (hd, abuf, abuflen);
1042       break;
1043
1044     default:
1045       log_error ("gcry_cipher_authenticate: invalid mode %d\n", hd->mode);
1046       rc = GPG_ERR_INV_CIPHER_MODE;
1047       break;
1048     }
1049
1050   return rc;
1051 }
1052
1053
1054 gcry_err_code_t
1055 _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
1056 {
1057   gcry_err_code_t rc;
1058
1059   switch (hd->mode)
1060     {
1061     case GCRY_CIPHER_MODE_CCM:
1062       rc = _gcry_cipher_ccm_get_tag (hd, outtag, taglen);
1063       break;
1064
1065     case GCRY_CIPHER_MODE_CMAC:
1066       rc = _gcry_cipher_cmac_get_tag (hd, outtag, taglen);
1067       break;
1068
1069     case GCRY_CIPHER_MODE_GCM:
1070       rc = _gcry_cipher_gcm_get_tag (hd, outtag, taglen);
1071       break;
1072
1073     default:
1074       log_error ("gcry_cipher_gettag: invalid mode %d\n", hd->mode);
1075       rc = GPG_ERR_INV_CIPHER_MODE;
1076       break;
1077     }
1078
1079   return rc;
1080 }
1081
1082
1083 gcry_err_code_t
1084 _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
1085 {
1086   gcry_err_code_t rc;
1087
1088   switch (hd->mode)
1089     {
1090     case GCRY_CIPHER_MODE_CCM:
1091       rc = _gcry_cipher_ccm_check_tag (hd, intag, taglen);
1092       break;
1093
1094     case GCRY_CIPHER_MODE_CMAC:
1095       rc = _gcry_cipher_cmac_check_tag (hd, intag, taglen);
1096       break;
1097
1098     case GCRY_CIPHER_MODE_GCM:
1099       rc = _gcry_cipher_gcm_check_tag (hd, intag, taglen);
1100       break;
1101
1102     default:
1103       log_error ("gcry_cipher_checktag: invalid mode %d\n", hd->mode);
1104       rc = GPG_ERR_INV_CIPHER_MODE;
1105       break;
1106     }
1107
1108   return rc;
1109 }
1110
1111
1112 gcry_err_code_t
1113 _gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1114 {
1115   gcry_err_code_t rc = 0;
1116
1117   switch (cmd)
1118     {
1119     case GCRYCTL_RESET:
1120       cipher_reset (h);
1121       break;
1122
1123     case GCRYCTL_CFB_SYNC:
1124       cipher_sync( h );
1125       break;
1126
1127     case GCRYCTL_SET_CBC_CTS:
1128       if (buflen)
1129         if (h->flags & GCRY_CIPHER_CBC_MAC)
1130           rc = GPG_ERR_INV_FLAG;
1131         else
1132           h->flags |= GCRY_CIPHER_CBC_CTS;
1133       else
1134         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1135       break;
1136
1137     case GCRYCTL_SET_CBC_MAC:
1138       if (buflen)
1139         if (h->flags & GCRY_CIPHER_CBC_CTS)
1140           rc = GPG_ERR_INV_FLAG;
1141         else
1142           h->flags |= GCRY_CIPHER_CBC_MAC;
1143       else
1144         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1145       break;
1146
1147     case GCRYCTL_SET_CCM_LENGTHS:
1148 #ifdef HAVE_U64_TYPEDEF
1149       {
1150         u64 params[3];
1151         size_t encryptedlen;
1152         size_t aadlen;
1153         size_t authtaglen;
1154
1155         if (h->mode != GCRY_CIPHER_MODE_CCM)
1156           return gcry_error (GPG_ERR_INV_CIPHER_MODE);
1157
1158         if (!buffer || buflen != 3 * sizeof(u64))
1159           return gcry_error (GPG_ERR_INV_ARG);
1160
1161         /* This command is used to pass additional length parameters needed
1162            by CCM mode to initialize CBC-MAC.  */
1163         memcpy (params, buffer, sizeof(params));
1164         encryptedlen = params[0];
1165         aadlen = params[1];
1166         authtaglen = params[2];
1167
1168         rc = _gcry_cipher_ccm_set_lengths (h, encryptedlen, aadlen, authtaglen);
1169       }
1170 #else
1171       rc = GPG_ERR_NOT_SUPPORTED;
1172 #endif
1173       break;
1174
1175     case GCRYCTL_DISABLE_ALGO:
1176       /* This command expects NULL for H and BUFFER to point to an
1177          integer with the algo number.  */
1178       if( h || !buffer || buflen != sizeof(int) )
1179         return gcry_error (GPG_ERR_CIPHER_ALGO);
1180       disable_cipher_algo( *(int*)buffer );
1181       break;
1182
1183     case 61:  /* Disable weak key detection (private).  */
1184       if (h->spec->set_extra_info)
1185         rc = h->spec->set_extra_info
1186           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1187       else
1188         rc = GPG_ERR_NOT_SUPPORTED;
1189       break;
1190
1191     case 62: /* Return current input vector (private).  */
1192       /* This is the input block as used in CFB and OFB mode which has
1193          initially been set as IV.  The returned format is:
1194            1 byte  Actual length of the block in bytes.
1195            n byte  The block.
1196          If the provided buffer is too short, an error is returned. */
1197       if (buflen < (1 + h->spec->blocksize))
1198         rc = GPG_ERR_TOO_SHORT;
1199       else
1200         {
1201           unsigned char *ivp;
1202           unsigned char *dst = buffer;
1203           int n = h->unused;
1204
1205           if (!n)
1206             n = h->spec->blocksize;
1207           gcry_assert (n <= h->spec->blocksize);
1208           *dst++ = n;
1209           ivp = h->u_iv.iv + h->spec->blocksize - n;
1210           while (n--)
1211             *dst++ = *ivp++;
1212         }
1213       break;
1214
1215     default:
1216       rc = GPG_ERR_INV_OP;
1217     }
1218
1219   return rc;
1220 }
1221
1222
1223 /* Return information about the cipher handle H.  CMD is the kind of
1224    information requested.  BUFFER and NBYTES are reserved for now.
1225
1226    There are no values for CMD yet defined.
1227
1228    The function always returns GPG_ERR_INV_OP.
1229
1230  */
1231 gcry_err_code_t
1232 _gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1233 {
1234   gcry_err_code_t rc = 0;
1235
1236   (void)h;
1237   (void)buffer;
1238   (void)nbytes;
1239
1240   switch (cmd)
1241     {
1242     default:
1243       rc = GPG_ERR_INV_OP;
1244     }
1245
1246   return rc;
1247 }
1248
1249 /* Return information about the given cipher algorithm ALGO.
1250
1251    WHAT select the kind of information returned:
1252
1253     GCRYCTL_GET_KEYLEN:
1254         Return the length of the key.  If the algorithm ALGO
1255         supports multiple key lengths, the maximum supported key length
1256         is returned.  The key length is returned as number of octets.
1257         BUFFER and NBYTES must be zero.
1258
1259     GCRYCTL_GET_BLKLEN:
1260         Return the blocklength of the algorithm ALGO counted in octets.
1261         BUFFER and NBYTES must be zero.
1262
1263     GCRYCTL_TEST_ALGO:
1264         Returns 0 if the specified algorithm ALGO is available for use.
1265         BUFFER and NBYTES must be zero.
1266
1267    Note: Because this function is in most cases used to return an
1268    integer value, we can make it easier for the caller to just look at
1269    the return value.  The caller will in all cases consult the value
1270    and thereby detecting whether a error occurred or not (i.e. while
1271    checking the block size)
1272  */
1273 gcry_err_code_t
1274 _gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1275 {
1276   gcry_err_code_t rc = 0;
1277   unsigned int ui;
1278
1279   switch (what)
1280     {
1281     case GCRYCTL_GET_KEYLEN:
1282       if (buffer || (! nbytes))
1283         rc = GPG_ERR_CIPHER_ALGO;
1284       else
1285         {
1286           ui = cipher_get_keylen (algo);
1287           if ((ui > 0) && (ui <= 512))
1288             *nbytes = (size_t) ui / 8;
1289           else
1290             /* The only reason for an error is an invalid algo.  */
1291             rc = GPG_ERR_CIPHER_ALGO;
1292         }
1293       break;
1294
1295     case GCRYCTL_GET_BLKLEN:
1296       if (buffer || (! nbytes))
1297         rc = GPG_ERR_CIPHER_ALGO;
1298       else
1299         {
1300           ui = cipher_get_blocksize (algo);
1301           if ((ui > 0) && (ui < 10000))
1302             *nbytes = ui;
1303           else
1304             {
1305               /* The only reason is an invalid algo or a strange
1306                  blocksize.  */
1307               rc = GPG_ERR_CIPHER_ALGO;
1308             }
1309         }
1310       break;
1311
1312     case GCRYCTL_TEST_ALGO:
1313       if (buffer || nbytes)
1314         rc = GPG_ERR_INV_ARG;
1315       else
1316         rc = check_cipher_algo (algo);
1317       break;
1318
1319       default:
1320         rc = GPG_ERR_INV_OP;
1321     }
1322
1323   return rc;
1324 }
1325
1326
1327 /* This function returns length of the key for algorithm ALGO.  If the
1328    algorithm supports multiple key lengths, the maximum supported key
1329    length is returned.  On error 0 is returned.  The key length is
1330    returned as number of octets.
1331
1332    This is a convenience functions which should be preferred over
1333    gcry_cipher_algo_info because it allows for proper type
1334    checking.  */
1335 size_t
1336 _gcry_cipher_get_algo_keylen (int algo)
1337 {
1338   size_t n;
1339
1340   if (_gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1341     n = 0;
1342   return n;
1343 }
1344
1345
1346 /* This functions returns the blocklength of the algorithm ALGO
1347    counted in octets.  On error 0 is returned.
1348
1349    This is a convenience functions which should be preferred over
1350    gcry_cipher_algo_info because it allows for proper type
1351    checking.  */
1352 size_t
1353 _gcry_cipher_get_algo_blklen (int algo)
1354 {
1355   size_t n;
1356
1357   if (_gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1358     n = 0;
1359   return n;
1360 }
1361
1362
1363 /* Explicitly initialize this module.  */
1364 gcry_err_code_t
1365 _gcry_cipher_init (void)
1366 {
1367   return 0;
1368 }
1369
1370
1371 /* Run the selftests for cipher algorithm ALGO with optional reporting
1372    function REPORT.  */
1373 gpg_error_t
1374 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
1375 {
1376   gcry_err_code_t ec = 0;
1377   gcry_cipher_spec_t *spec;
1378
1379   spec = spec_from_algo (algo);
1380   if (spec && !spec->flags.disabled && spec->selftest)
1381     ec = spec->selftest (algo, extended, report);
1382   else
1383     {
1384       ec = GPG_ERR_CIPHER_ALGO;
1385       if (report)
1386         report ("cipher", algo, "module",
1387                 (spec && !spec->flags.disabled)?
1388                 "no selftest available" :
1389                 spec? "algorithm disabled" : "algorithm not found");
1390     }
1391
1392   return gpg_error (ec);
1393 }