Remove macro hacks for internal vs. external functions. Part 1.
[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         if (spec->blocksize != GCRY_CCM_BLOCK_LEN)
398           err = GPG_ERR_INV_CIPHER_MODE;
399         if (!spec->encrypt || !spec->decrypt)
400           err = GPG_ERR_INV_CIPHER_MODE;
401         break;
402
403       case GCRY_CIPHER_MODE_ECB:
404       case GCRY_CIPHER_MODE_CBC:
405       case GCRY_CIPHER_MODE_CFB:
406       case GCRY_CIPHER_MODE_OFB:
407       case GCRY_CIPHER_MODE_CTR:
408       case GCRY_CIPHER_MODE_AESWRAP:
409       case GCRY_CIPHER_MODE_CMAC:
410       case GCRY_CIPHER_MODE_GCM:
411         if (!spec->encrypt || !spec->decrypt)
412           err = GPG_ERR_INV_CIPHER_MODE;
413         break;
414
415       case GCRY_CIPHER_MODE_STREAM:
416         if (!spec->stencrypt || !spec->stdecrypt)
417           err = GPG_ERR_INV_CIPHER_MODE;
418         break;
419
420       case GCRY_CIPHER_MODE_NONE:
421         /* This mode may be used for debugging.  It copies the main
422            text verbatim to the ciphertext.  We do not allow this in
423            fips mode or if no debug flag has been set.  */
424         if (fips_mode () || !_gcry_get_debug_flag (0))
425           err = GPG_ERR_INV_CIPHER_MODE;
426         break;
427
428       default:
429         err = GPG_ERR_INV_CIPHER_MODE;
430       }
431
432   /* Perform selftest here and mark this with a flag in cipher_table?
433      No, we should not do this as it takes too long.  Further it does
434      not make sense to exclude algorithms with failing selftests at
435      runtime: If a selftest fails there is something seriously wrong with the system and thus we better die immediately. */
436
437   if (! err)
438     {
439       size_t size = (sizeof (*h)
440                      + 2 * spec->contextsize
441                      - sizeof (cipher_context_alignment_t)
442 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
443                      + 15  /* Space for leading alignment gap.  */
444 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
445                      );
446
447       if (secure)
448         h = gcry_calloc_secure (1, size);
449       else
450         h = gcry_calloc (1, size);
451
452       if (! h)
453         err = gpg_err_code_from_syserror ();
454       else
455         {
456           size_t off = 0;
457
458 #ifdef NEED_16BYTE_ALIGNED_CONTEXT
459           if ( ((unsigned long)h & 0x0f) )
460             {
461               /* The malloced block is not aligned on a 16 byte
462                  boundary.  Correct for this.  */
463               off = 16 - ((unsigned long)h & 0x0f);
464               h = (void*)((char*)h + off);
465             }
466 #endif /*NEED_16BYTE_ALIGNED_CONTEXT*/
467
468           h->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
469           h->actual_handle_size = size - off;
470           h->handle_offset = off;
471           h->spec = spec;
472           h->algo = algo;
473           h->mode = mode;
474           h->flags = flags;
475
476           /* Setup bulk encryption routines.  */
477           switch (algo)
478             {
479 #ifdef USE_AES
480             case GCRY_CIPHER_AES128:
481             case GCRY_CIPHER_AES192:
482             case GCRY_CIPHER_AES256:
483               h->bulk.cfb_enc = _gcry_aes_cfb_enc;
484               h->bulk.cfb_dec = _gcry_aes_cfb_dec;
485               h->bulk.cbc_enc = _gcry_aes_cbc_enc;
486               h->bulk.cbc_dec = _gcry_aes_cbc_dec;
487               h->bulk.ctr_enc = _gcry_aes_ctr_enc;
488               break;
489 #endif /*USE_AES*/
490 #ifdef USE_BLOWFISH
491             case GCRY_CIPHER_BLOWFISH:
492               h->bulk.cfb_dec = _gcry_blowfish_cfb_dec;
493               h->bulk.cbc_dec = _gcry_blowfish_cbc_dec;
494               h->bulk.ctr_enc = _gcry_blowfish_ctr_enc;
495               break;
496 #endif /*USE_BLOWFISH*/
497 #ifdef USE_CAST5
498             case GCRY_CIPHER_CAST5:
499               h->bulk.cfb_dec = _gcry_cast5_cfb_dec;
500               h->bulk.cbc_dec = _gcry_cast5_cbc_dec;
501               h->bulk.ctr_enc = _gcry_cast5_ctr_enc;
502               break;
503 #endif /*USE_CAMELLIA*/
504 #ifdef USE_CAMELLIA
505             case GCRY_CIPHER_CAMELLIA128:
506             case GCRY_CIPHER_CAMELLIA192:
507             case GCRY_CIPHER_CAMELLIA256:
508               h->bulk.cbc_dec = _gcry_camellia_cbc_dec;
509               h->bulk.cfb_dec = _gcry_camellia_cfb_dec;
510               h->bulk.ctr_enc = _gcry_camellia_ctr_enc;
511               break;
512 #endif /*USE_CAMELLIA*/
513 #ifdef USE_SERPENT
514             case GCRY_CIPHER_SERPENT128:
515             case GCRY_CIPHER_SERPENT192:
516             case GCRY_CIPHER_SERPENT256:
517               h->bulk.cbc_dec = _gcry_serpent_cbc_dec;
518               h->bulk.cfb_dec = _gcry_serpent_cfb_dec;
519               h->bulk.ctr_enc = _gcry_serpent_ctr_enc;
520               break;
521 #endif /*USE_SERPENT*/
522 #ifdef USE_TWOFISH
523             case GCRY_CIPHER_TWOFISH:
524             case GCRY_CIPHER_TWOFISH128:
525               h->bulk.cbc_dec = _gcry_twofish_cbc_dec;
526               h->bulk.cfb_dec = _gcry_twofish_cfb_dec;
527               h->bulk.ctr_enc = _gcry_twofish_ctr_enc;
528               break;
529 #endif /*USE_TWOFISH*/
530
531             default:
532               break;
533             }
534         }
535     }
536
537   /* Done.  */
538
539   *handle = err ? NULL : h;
540
541   return gcry_error (err);
542 }
543
544
545 /* Release all resources associated with the cipher handle H. H may be
546    NULL in which case this is a no-operation. */
547 void
548 _gcry_cipher_close (gcry_cipher_hd_t h)
549 {
550   size_t off;
551
552   if (!h)
553     return;
554
555   if ((h->magic != CTX_MAGIC_SECURE)
556       && (h->magic != CTX_MAGIC_NORMAL))
557     _gcry_fatal_error(GPG_ERR_INTERNAL,
558                       "gcry_cipher_close: already closed/invalid handle");
559   else
560     h->magic = 0;
561
562   /* We always want to wipe out the memory even when the context has
563      been allocated in secure memory.  The user might have disabled
564      secure memory or is using his own implementation which does not
565      do the wiping.  To accomplish this we need to keep track of the
566      actual size of this structure because we have no way to known
567      how large the allocated area was when using a standard malloc. */
568   off = h->handle_offset;
569   wipememory (h, h->actual_handle_size);
570
571   gcry_free ((char*)h - off);
572 }
573
574
575 /* Set the key to be used for the encryption context C to KEY with
576    length KEYLEN.  The length should match the required length. */
577 static gcry_err_code_t
578 cipher_setkey (gcry_cipher_hd_t c, byte *key, size_t keylen)
579 {
580   gcry_err_code_t rc;
581
582   rc = c->spec->setkey (&c->context.c, key, keylen);
583   if (!rc)
584     {
585       /* Duplicate initial context.  */
586       memcpy ((void *) ((char *) &c->context.c + c->spec->contextsize),
587               (void *) &c->context.c,
588               c->spec->contextsize);
589       c->marks.key = 1;
590
591       switch (c->mode)
592         {
593         case GCRY_CIPHER_MODE_CMAC:
594           _gcry_cipher_cmac_set_subkeys (c);
595           break;
596
597         case GCRY_CIPHER_MODE_GCM:
598           _gcry_cipher_gcm_setkey (c);
599           break;
600
601         default:
602           break;
603         };
604     }
605   else
606     c->marks.key = 0;
607
608   return rc;
609 }
610
611
612 /* Set the IV to be used for the encryption context C to IV with
613    length IVLEN.  The length should match the required length. */
614 static gcry_err_code_t
615 cipher_setiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
616 {
617   /* GCM has its own IV handler */
618   if (c->mode == GCRY_CIPHER_MODE_GCM)
619     return _gcry_cipher_gcm_setiv (c, iv, ivlen);
620
621   /* If the cipher has its own IV handler, we use only this one.  This
622      is currently used for stream ciphers requiring a nonce.  */
623   if (c->spec->setiv)
624     {
625       c->spec->setiv (&c->context.c, iv, ivlen);
626       return 0;
627     }
628
629   memset (c->u_iv.iv, 0, c->spec->blocksize);
630   if (iv)
631     {
632       if (ivlen != c->spec->blocksize)
633         {
634           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
635                     (unsigned int)ivlen, (unsigned int)c->spec->blocksize);
636           fips_signal_error ("IV length does not match blocklength");
637         }
638       if (ivlen > c->spec->blocksize)
639         ivlen = c->spec->blocksize;
640       memcpy (c->u_iv.iv, iv, ivlen);
641       c->marks.iv = 1;
642     }
643   else
644       c->marks.iv = 0;
645   c->unused = 0;
646
647   return 0;
648 }
649
650
651 /* Reset the cipher context to the initial context.  This is basically
652    the same as an release followed by a new. */
653 static void
654 cipher_reset (gcry_cipher_hd_t c)
655 {
656   unsigned int marks_key;
657
658   marks_key = c->marks.key;
659
660   memcpy (&c->context.c,
661           (char *) &c->context.c + c->spec->contextsize,
662           c->spec->contextsize);
663   memset (&c->marks, 0, sizeof c->marks);
664   memset (c->u_iv.iv, 0, c->spec->blocksize);
665   memset (c->lastiv, 0, c->spec->blocksize);
666   memset (c->u_ctr.ctr, 0, c->spec->blocksize);
667   c->unused = 0;
668
669   c->marks.key = marks_key;
670
671   switch (c->mode)
672     {
673     case GCRY_CIPHER_MODE_CMAC:
674       /* Only clear 'tag' for cmac, keep subkeys. */
675       c->u_mode.cmac.tag = 0;
676       break;
677
678     case GCRY_CIPHER_MODE_GCM:
679       /* Only clear head of u_mode, keep ghash_key and gcm_table. */
680       {
681         byte *u_mode_pos = (void *)&c->u_mode;
682         byte *ghash_key_pos = c->u_mode.gcm.u_ghash_key.key;
683         size_t u_mode_head_length = ghash_key_pos - u_mode_pos;
684
685         memset (&c->u_mode, 0, u_mode_head_length);
686       }
687       break;
688
689     case GCRY_CIPHER_MODE_CCM:
690       memset (&c->u_mode.ccm, 0, sizeof c->u_mode.ccm);
691       break;
692
693     default:
694       break; /* u_mode unused by other modes. */
695     }
696 }
697
698
699 \f
700 static gcry_err_code_t
701 do_ecb_crypt (gcry_cipher_hd_t c,
702               unsigned char *outbuf, size_t outbuflen,
703               const unsigned char *inbuf, size_t inbuflen,
704               gcry_cipher_encrypt_t crypt_fn)
705 {
706   unsigned int blocksize = c->spec->blocksize;
707   size_t n, nblocks;
708   unsigned int burn, nburn;
709
710   if (outbuflen < inbuflen)
711     return GPG_ERR_BUFFER_TOO_SHORT;
712   if ((inbuflen % blocksize))
713     return GPG_ERR_INV_LENGTH;
714
715   nblocks = inbuflen / blocksize;
716   burn = 0;
717
718   for (n=0; n < nblocks; n++ )
719     {
720       nburn = crypt_fn (&c->context.c, outbuf, inbuf);
721       burn = nburn > burn ? nburn : burn;
722       inbuf  += blocksize;
723       outbuf += blocksize;
724     }
725
726   if (burn > 0)
727     _gcry_burn_stack (burn + 4 * sizeof(void *));
728
729   return 0;
730 }
731
732 static gcry_err_code_t
733 do_ecb_encrypt (gcry_cipher_hd_t c,
734                 unsigned char *outbuf, size_t outbuflen,
735                 const unsigned char *inbuf, size_t inbuflen)
736 {
737   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->encrypt);
738 }
739
740 static gcry_err_code_t
741 do_ecb_decrypt (gcry_cipher_hd_t c,
742                 unsigned char *outbuf, size_t outbuflen,
743                 const unsigned char *inbuf, size_t inbuflen)
744 {
745   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->decrypt);
746 }
747
748
749 /****************
750  * Encrypt INBUF to OUTBUF with the mode selected at open.
751  * inbuf and outbuf may overlap or be the same.
752  * Depending on the mode some constraints apply to INBUFLEN.
753  */
754 static gcry_err_code_t
755 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
756                 const byte *inbuf, size_t inbuflen)
757 {
758   gcry_err_code_t rc;
759
760   switch (c->mode)
761     {
762     case GCRY_CIPHER_MODE_ECB:
763       rc = do_ecb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
764       break;
765
766     case GCRY_CIPHER_MODE_CBC:
767       rc = _gcry_cipher_cbc_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
768       break;
769
770     case GCRY_CIPHER_MODE_CFB:
771       rc = _gcry_cipher_cfb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
772       break;
773
774     case GCRY_CIPHER_MODE_OFB:
775       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
776       break;
777
778     case GCRY_CIPHER_MODE_CTR:
779       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
780       break;
781
782     case GCRY_CIPHER_MODE_AESWRAP:
783       rc = _gcry_cipher_aeswrap_encrypt (c, outbuf, outbuflen,
784                                          inbuf, inbuflen);
785       break;
786
787     case GCRY_CIPHER_MODE_CCM:
788       rc = _gcry_cipher_ccm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
789       break;
790
791     case GCRY_CIPHER_MODE_CMAC:
792       rc = GPG_ERR_INV_CIPHER_MODE;
793       break;
794
795     case GCRY_CIPHER_MODE_GCM:
796       rc = _gcry_cipher_gcm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
797       break;
798
799     case GCRY_CIPHER_MODE_STREAM:
800       c->spec->stencrypt (&c->context.c,
801                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
802       rc = 0;
803       break;
804
805     case GCRY_CIPHER_MODE_NONE:
806       if (fips_mode () || !_gcry_get_debug_flag (0))
807         {
808           fips_signal_error ("cipher mode NONE used");
809           rc = GPG_ERR_INV_CIPHER_MODE;
810         }
811       else
812         {
813           if (inbuf != outbuf)
814             memmove (outbuf, inbuf, inbuflen);
815           rc = 0;
816         }
817       break;
818
819     default:
820       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
821       rc = GPG_ERR_INV_CIPHER_MODE;
822       break;
823     }
824
825   return rc;
826 }
827
828
829 /****************
830  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
831  * been requested.
832  */
833 gcry_err_code_t
834 _gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
835                       const void *in, size_t inlen)
836 {
837   gcry_err_code_t rc;
838
839   if (!in)  /* Caller requested in-place encryption.  */
840     {
841       in = out;
842       inlen = outsize;
843     }
844
845   rc = cipher_encrypt (h, out, outsize, in, inlen);
846
847   /* Failsafe: Make sure that the plaintext will never make it into
848      OUT if the encryption returned an error.  */
849   if (rc && out)
850     memset (out, 0x42, outsize);
851
852   return rc;
853 }
854
855
856
857 /****************
858  * Decrypt INBUF to OUTBUF with the mode selected at open.
859  * inbuf and outbuf may overlap or be the same.
860  * Depending on the mode some some contraints apply to INBUFLEN.
861  */
862 static gcry_err_code_t
863 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
864                 const byte *inbuf, size_t inbuflen)
865 {
866   gcry_err_code_t rc;
867
868   switch (c->mode)
869     {
870     case GCRY_CIPHER_MODE_ECB:
871       rc = do_ecb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
872       break;
873
874     case GCRY_CIPHER_MODE_CBC:
875       rc = _gcry_cipher_cbc_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
876       break;
877
878     case GCRY_CIPHER_MODE_CFB:
879       rc = _gcry_cipher_cfb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
880       break;
881
882     case GCRY_CIPHER_MODE_OFB:
883       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
884       break;
885
886     case GCRY_CIPHER_MODE_CTR:
887       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
888       break;
889
890     case GCRY_CIPHER_MODE_AESWRAP:
891       rc = _gcry_cipher_aeswrap_decrypt (c, outbuf, outbuflen,
892                                          inbuf, inbuflen);
893       break;
894
895     case GCRY_CIPHER_MODE_CCM:
896       rc = _gcry_cipher_ccm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
897       break;
898
899     case GCRY_CIPHER_MODE_CMAC:
900       rc = GPG_ERR_INV_CIPHER_MODE;
901       break;
902
903     case GCRY_CIPHER_MODE_GCM:
904       rc = _gcry_cipher_gcm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
905       break;
906
907     case GCRY_CIPHER_MODE_STREAM:
908       c->spec->stdecrypt (&c->context.c,
909                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
910       rc = 0;
911       break;
912
913     case GCRY_CIPHER_MODE_NONE:
914       if (fips_mode () || !_gcry_get_debug_flag (0))
915         {
916           fips_signal_error ("cipher mode NONE used");
917           rc = GPG_ERR_INV_CIPHER_MODE;
918         }
919       else
920         {
921           if (inbuf != outbuf)
922             memmove (outbuf, inbuf, inbuflen);
923           rc = 0;
924         }
925       break;
926
927     default:
928       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
929       rc = GPG_ERR_INV_CIPHER_MODE;
930       break;
931     }
932
933   return rc;
934 }
935
936
937 gcry_err_code_t
938 _gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
939                       const void *in, size_t inlen)
940 {
941   if (!in) /* Caller requested in-place encryption. */
942     {
943       in = out;
944       inlen = outsize;
945     }
946
947   return cipher_decrypt (h, out, outsize, in, inlen);
948 }
949
950
951
952 /****************
953  * Used for PGP's somewhat strange CFB mode. Only works if
954  * the corresponding flag is set.
955  */
956 static void
957 cipher_sync (gcry_cipher_hd_t c)
958 {
959   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
960     {
961       memmove (c->u_iv.iv + c->unused,
962                c->u_iv.iv, c->spec->blocksize - c->unused);
963       memcpy (c->u_iv.iv,
964               c->lastiv + c->spec->blocksize - c->unused, c->unused);
965       c->unused = 0;
966     }
967 }
968
969
970 gcry_err_code_t
971 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
972 {
973   return cipher_setkey (hd, (void*)key, keylen);
974 }
975
976
977 gcry_err_code_t
978 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
979 {
980   gcry_err_code_t rc = 0;
981
982   switch (hd->mode)
983     {
984       case GCRY_CIPHER_MODE_CCM:
985         rc = _gcry_cipher_ccm_set_nonce (hd, iv, ivlen);
986         break;
987
988       default:
989         rc = cipher_setiv (hd, iv, ivlen);
990         break;
991     }
992   return rc;
993 }
994
995 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
996    block size length, or (NULL,0) to set the CTR to the all-zero
997    block. */
998 gpg_err_code_t
999 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
1000 {
1001   if (ctr && ctrlen == hd->spec->blocksize)
1002     {
1003       memcpy (hd->u_ctr.ctr, ctr, hd->spec->blocksize);
1004       hd->unused = 0;
1005     }
1006   else if (!ctr || !ctrlen)
1007     {
1008       memset (hd->u_ctr.ctr, 0, hd->spec->blocksize);
1009       hd->unused = 0;
1010     }
1011   else
1012     return GPG_ERR_INV_ARG;
1013
1014   return 0;
1015 }
1016
1017
1018 gcry_err_code_t
1019 _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
1020                            size_t abuflen)
1021 {
1022   gcry_err_code_t rc;
1023
1024   switch (hd->mode)
1025     {
1026     case GCRY_CIPHER_MODE_CCM:
1027       rc = _gcry_cipher_ccm_authenticate (hd, abuf, abuflen);
1028       break;
1029
1030     case GCRY_CIPHER_MODE_CMAC:
1031       rc = _gcry_cipher_cmac_authenticate (hd, abuf, abuflen);
1032       break;
1033
1034     case GCRY_CIPHER_MODE_GCM:
1035       rc = _gcry_cipher_gcm_authenticate (hd, abuf, abuflen);
1036       break;
1037
1038     default:
1039       log_error ("gcry_cipher_authenticate: invalid mode %d\n", hd->mode);
1040       rc = GPG_ERR_INV_CIPHER_MODE;
1041       break;
1042     }
1043
1044   return rc;
1045 }
1046
1047
1048 gcry_err_code_t
1049 _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
1050 {
1051   gcry_err_code_t rc;
1052
1053   switch (hd->mode)
1054     {
1055     case GCRY_CIPHER_MODE_CCM:
1056       rc = _gcry_cipher_ccm_get_tag (hd, outtag, taglen);
1057       break;
1058
1059     case GCRY_CIPHER_MODE_CMAC:
1060       rc = _gcry_cipher_cmac_get_tag (hd, outtag, taglen);
1061       break;
1062
1063     case GCRY_CIPHER_MODE_GCM:
1064       rc = _gcry_cipher_gcm_get_tag (hd, outtag, taglen);
1065       break;
1066
1067     default:
1068       log_error ("gcry_cipher_gettag: invalid mode %d\n", hd->mode);
1069       rc = GPG_ERR_INV_CIPHER_MODE;
1070       break;
1071     }
1072
1073   return rc;
1074 }
1075
1076
1077 gcry_err_code_t
1078 _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
1079 {
1080   gcry_err_code_t rc;
1081
1082   switch (hd->mode)
1083     {
1084     case GCRY_CIPHER_MODE_CCM:
1085       rc = _gcry_cipher_ccm_check_tag (hd, intag, taglen);
1086       break;
1087
1088     case GCRY_CIPHER_MODE_CMAC:
1089       rc = _gcry_cipher_cmac_check_tag (hd, intag, taglen);
1090       break;
1091
1092     case GCRY_CIPHER_MODE_GCM:
1093       rc = _gcry_cipher_gcm_check_tag (hd, intag, taglen);
1094       break;
1095
1096     default:
1097       log_error ("gcry_cipher_checktag: invalid mode %d\n", hd->mode);
1098       rc = GPG_ERR_INV_CIPHER_MODE;
1099       break;
1100     }
1101
1102   return rc;
1103 }
1104
1105
1106 gcry_err_code_t
1107 _gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1108 {
1109   gcry_err_code_t rc = 0;
1110
1111   switch (cmd)
1112     {
1113     case GCRYCTL_RESET:
1114       cipher_reset (h);
1115       break;
1116
1117     case GCRYCTL_CFB_SYNC:
1118       cipher_sync( h );
1119       break;
1120
1121     case GCRYCTL_SET_CBC_CTS:
1122       if (buflen)
1123         if (h->flags & GCRY_CIPHER_CBC_MAC)
1124           rc = GPG_ERR_INV_FLAG;
1125         else
1126           h->flags |= GCRY_CIPHER_CBC_CTS;
1127       else
1128         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1129       break;
1130
1131     case GCRYCTL_SET_CBC_MAC:
1132       if (buflen)
1133         if (h->flags & GCRY_CIPHER_CBC_CTS)
1134           rc = GPG_ERR_INV_FLAG;
1135         else
1136           h->flags |= GCRY_CIPHER_CBC_MAC;
1137       else
1138         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1139       break;
1140
1141     case GCRYCTL_SET_CCM_LENGTHS:
1142       {
1143         size_t params[3];
1144         size_t encryptedlen;
1145         size_t aadlen;
1146         size_t authtaglen;
1147
1148         if (h->mode != GCRY_CIPHER_MODE_CCM)
1149           return gcry_error (GPG_ERR_INV_CIPHER_MODE);
1150
1151         if (!buffer || buflen != 3 * sizeof(size_t))
1152           return gcry_error (GPG_ERR_INV_ARG);
1153
1154         /* This command is used to pass additional length parameters needed
1155            by CCM mode to initialize CBC-MAC.  */
1156         memcpy (params, buffer, sizeof(params));
1157         encryptedlen = params[0];
1158         aadlen = params[1];
1159         authtaglen = params[2];
1160
1161         rc = _gcry_cipher_ccm_set_lengths (h, encryptedlen, aadlen, authtaglen);
1162       }
1163       break;
1164
1165     case GCRYCTL_DISABLE_ALGO:
1166       /* This command expects NULL for H and BUFFER to point to an
1167          integer with the algo number.  */
1168       if( h || !buffer || buflen != sizeof(int) )
1169         return gcry_error (GPG_ERR_CIPHER_ALGO);
1170       disable_cipher_algo( *(int*)buffer );
1171       break;
1172
1173     case 61:  /* Disable weak key detection (private).  */
1174       if (h->spec->set_extra_info)
1175         rc = h->spec->set_extra_info
1176           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1177       else
1178         rc = GPG_ERR_NOT_SUPPORTED;
1179       break;
1180
1181     case 62: /* Return current input vector (private).  */
1182       /* This is the input block as used in CFB and OFB mode which has
1183          initially been set as IV.  The returned format is:
1184            1 byte  Actual length of the block in bytes.
1185            n byte  The block.
1186          If the provided buffer is too short, an error is returned. */
1187       if (buflen < (1 + h->spec->blocksize))
1188         rc = GPG_ERR_TOO_SHORT;
1189       else
1190         {
1191           unsigned char *ivp;
1192           unsigned char *dst = buffer;
1193           int n = h->unused;
1194
1195           if (!n)
1196             n = h->spec->blocksize;
1197           gcry_assert (n <= h->spec->blocksize);
1198           *dst++ = n;
1199           ivp = h->u_iv.iv + h->spec->blocksize - n;
1200           while (n--)
1201             *dst++ = *ivp++;
1202         }
1203       break;
1204
1205     default:
1206       rc = GPG_ERR_INV_OP;
1207     }
1208
1209   return rc;
1210 }
1211
1212
1213 /* Return information about the cipher handle H.  CMD is the kind of
1214    information requested.  BUFFER and NBYTES are reserved for now.
1215
1216    There are no values for CMD yet defined.
1217
1218    The function always returns GPG_ERR_INV_OP.
1219
1220  */
1221 gcry_err_code_t
1222 _gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1223 {
1224   gcry_err_code_t rc = 0;
1225
1226   (void)h;
1227   (void)buffer;
1228   (void)nbytes;
1229
1230   switch (cmd)
1231     {
1232     default:
1233       rc = GPG_ERR_INV_OP;
1234     }
1235
1236   return rc;
1237 }
1238
1239 /* Return information about the given cipher algorithm ALGO.
1240
1241    WHAT select the kind of information returned:
1242
1243     GCRYCTL_GET_KEYLEN:
1244         Return the length of the key.  If the algorithm ALGO
1245         supports multiple key lengths, the maximum supported key length
1246         is returned.  The key length is returned as number of octets.
1247         BUFFER and NBYTES must be zero.
1248
1249     GCRYCTL_GET_BLKLEN:
1250         Return the blocklength of the algorithm ALGO counted in octets.
1251         BUFFER and NBYTES must be zero.
1252
1253     GCRYCTL_TEST_ALGO:
1254         Returns 0 if the specified algorithm ALGO is available for use.
1255         BUFFER and NBYTES must be zero.
1256
1257    Note: Because this function is in most cases used to return an
1258    integer value, we can make it easier for the caller to just look at
1259    the return value.  The caller will in all cases consult the value
1260    and thereby detecting whether a error occurred or not (i.e. while
1261    checking the block size)
1262  */
1263 gcry_err_code_t
1264 _gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1265 {
1266   gcry_err_code_t rc = 0;
1267   unsigned int ui;
1268
1269   switch (what)
1270     {
1271     case GCRYCTL_GET_KEYLEN:
1272       if (buffer || (! nbytes))
1273         rc = GPG_ERR_CIPHER_ALGO;
1274       else
1275         {
1276           ui = cipher_get_keylen (algo);
1277           if ((ui > 0) && (ui <= 512))
1278             *nbytes = (size_t) ui / 8;
1279           else
1280             /* The only reason for an error is an invalid algo.  */
1281             rc = GPG_ERR_CIPHER_ALGO;
1282         }
1283       break;
1284
1285     case GCRYCTL_GET_BLKLEN:
1286       if (buffer || (! nbytes))
1287         rc = GPG_ERR_CIPHER_ALGO;
1288       else
1289         {
1290           ui = cipher_get_blocksize (algo);
1291           if ((ui > 0) && (ui < 10000))
1292             *nbytes = ui;
1293           else
1294             {
1295               /* The only reason is an invalid algo or a strange
1296                  blocksize.  */
1297               rc = GPG_ERR_CIPHER_ALGO;
1298             }
1299         }
1300       break;
1301
1302     case GCRYCTL_TEST_ALGO:
1303       if (buffer || nbytes)
1304         rc = GPG_ERR_INV_ARG;
1305       else
1306         rc = check_cipher_algo (algo);
1307       break;
1308
1309       default:
1310         rc = GPG_ERR_INV_OP;
1311     }
1312
1313   return rc;
1314 }
1315
1316
1317 /* This function returns length of the key for algorithm ALGO.  If the
1318    algorithm supports multiple key lengths, the maximum supported key
1319    length is returned.  On error 0 is returned.  The key length is
1320    returned as number of octets.
1321
1322    This is a convenience functions which should be preferred over
1323    gcry_cipher_algo_info because it allows for proper type
1324    checking.  */
1325 size_t
1326 _gcry_cipher_get_algo_keylen (int algo)
1327 {
1328   size_t n;
1329
1330   if (_gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1331     n = 0;
1332   return n;
1333 }
1334
1335
1336 /* This functions returns the blocklength of the algorithm ALGO
1337    counted in octets.  On error 0 is returned.
1338
1339    This is a convenience functions which should be preferred over
1340    gcry_cipher_algo_info because it allows for proper type
1341    checking.  */
1342 size_t
1343 _gcry_cipher_get_algo_blklen (int algo)
1344 {
1345   size_t n;
1346
1347   if (_gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1348     n = 0;
1349   return n;
1350 }
1351
1352
1353 /* Explicitly initialize this module.  */
1354 gcry_err_code_t
1355 _gcry_cipher_init (void)
1356 {
1357   return 0;
1358 }
1359
1360
1361 /* Run the selftests for cipher algorithm ALGO with optional reporting
1362    function REPORT.  */
1363 gpg_error_t
1364 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
1365 {
1366   gcry_err_code_t ec = 0;
1367   gcry_cipher_spec_t *spec;
1368
1369   spec = spec_from_algo (algo);
1370   if (spec && !spec->flags.disabled && spec->selftest)
1371     ec = spec->selftest (algo, extended, report);
1372   else
1373     {
1374       ec = GPG_ERR_CIPHER_ALGO;
1375       if (report)
1376         report ("cipher", algo, "module",
1377                 (spec && !spec->flags.disabled)?
1378                 "no selftest available" :
1379                 spec? "algorithm disabled" : "algorithm not found");
1380     }
1381
1382   return gpg_error (ec);
1383 }