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