GCM: Use counter mode code for speed-up
[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_error_t
344 gcry_cipher_open (gcry_cipher_hd_t *handle,
345                   int algo, int mode, unsigned int flags)
346 {
347   gcry_err_code_t err;
348   gcry_cipher_hd_t h = NULL;
349
350   if (mode >= GCRY_CIPHER_MODE_INTERNAL)
351     err = GPG_ERR_INV_CIPHER_MODE;
352   else
353     err = _gcry_cipher_open_internal (&h, algo, mode, flags);
354
355   *handle = err ? NULL : h;
356
357   return gcry_error (err);
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_error_t
578 cipher_setkey (gcry_cipher_hd_t c, byte *key, size_t keylen)
579 {
580   gcry_err_code_t ret;
581
582   ret = c->spec->setkey (&c->context.c, key, keylen);
583   if (!ret)
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         default:
597           break;
598         };
599     }
600   else
601     c->marks.key = 0;
602
603   return gcry_error (ret);
604 }
605
606
607 /* Set the IV to be used for the encryption context C to IV with
608    length IVLEN.  The length should match the required length. */
609 static gcry_err_code_t
610 cipher_setiv (gcry_cipher_hd_t c, const byte *iv, size_t ivlen)
611 {
612   /* GCM has its own IV handler */
613   if (c->mode == GCRY_CIPHER_MODE_GCM)
614     return _gcry_cipher_gcm_setiv (c, iv, ivlen);
615
616   /* If the cipher has its own IV handler, we use only this one.  This
617      is currently used for stream ciphers requiring a nonce.  */
618   if (c->spec->setiv)
619     {
620       c->spec->setiv (&c->context.c, iv, ivlen);
621       return 0;
622     }
623
624   memset (c->u_iv.iv, 0, c->spec->blocksize);
625   if (iv)
626     {
627       if (ivlen != c->spec->blocksize)
628         {
629           log_info ("WARNING: cipher_setiv: ivlen=%u blklen=%u\n",
630                     (unsigned int)ivlen, (unsigned int)c->spec->blocksize);
631           fips_signal_error ("IV length does not match blocklength");
632         }
633       if (ivlen > c->spec->blocksize)
634         ivlen = c->spec->blocksize;
635       memcpy (c->u_iv.iv, iv, ivlen);
636       c->marks.iv = 1;
637     }
638   else
639       c->marks.iv = 0;
640   c->unused = 0;
641
642   return 0;
643 }
644
645
646 /* Reset the cipher context to the initial context.  This is basically
647    the same as an release followed by a new. */
648 static void
649 cipher_reset (gcry_cipher_hd_t c)
650 {
651   unsigned int marks_key;
652
653   marks_key = c->marks.key;
654
655   memcpy (&c->context.c,
656           (char *) &c->context.c + c->spec->contextsize,
657           c->spec->contextsize);
658   memset (&c->marks, 0, sizeof c->marks);
659   memset (c->u_iv.iv, 0, c->spec->blocksize);
660   memset (c->lastiv, 0, c->spec->blocksize);
661   memset (c->u_ctr.ctr, 0, c->spec->blocksize);
662   c->unused = 0;
663
664   c->marks.key = marks_key;
665
666   switch (c->mode)
667     {
668     case GCRY_CIPHER_MODE_CMAC:
669       /* Only clear 'tag' for cmac, keep subkeys. */
670       c->u_mode.cmac.tag = 0;
671       break;
672
673     default:
674       memset (&c->u_mode, 0, sizeof c->u_mode);
675       break;
676     }
677 }
678
679
680 \f
681 static gcry_err_code_t
682 do_ecb_crypt (gcry_cipher_hd_t c,
683               unsigned char *outbuf, size_t outbuflen,
684               const unsigned char *inbuf, size_t inbuflen,
685               gcry_cipher_encrypt_t crypt_fn)
686 {
687   unsigned int blocksize = c->spec->blocksize;
688   size_t n, nblocks;
689   unsigned int burn, nburn;
690
691   if (outbuflen < inbuflen)
692     return GPG_ERR_BUFFER_TOO_SHORT;
693   if ((inbuflen % blocksize))
694     return GPG_ERR_INV_LENGTH;
695
696   nblocks = inbuflen / blocksize;
697   burn = 0;
698
699   for (n=0; n < nblocks; n++ )
700     {
701       nburn = crypt_fn (&c->context.c, outbuf, inbuf);
702       burn = nburn > burn ? nburn : burn;
703       inbuf  += blocksize;
704       outbuf += blocksize;
705     }
706
707   if (burn > 0)
708     _gcry_burn_stack (burn + 4 * sizeof(void *));
709
710   return 0;
711 }
712
713 static gcry_err_code_t
714 do_ecb_encrypt (gcry_cipher_hd_t c,
715                 unsigned char *outbuf, size_t outbuflen,
716                 const unsigned char *inbuf, size_t inbuflen)
717 {
718   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->encrypt);
719 }
720
721 static gcry_err_code_t
722 do_ecb_decrypt (gcry_cipher_hd_t c,
723                 unsigned char *outbuf, size_t outbuflen,
724                 const unsigned char *inbuf, size_t inbuflen)
725 {
726   return do_ecb_crypt (c, outbuf, outbuflen, inbuf, inbuflen, c->spec->decrypt);
727 }
728
729
730 /****************
731  * Encrypt INBUF to OUTBUF with the mode selected at open.
732  * inbuf and outbuf may overlap or be the same.
733  * Depending on the mode some constraints apply to INBUFLEN.
734  */
735 static gcry_err_code_t
736 cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
737                 const byte *inbuf, size_t inbuflen)
738 {
739   gcry_err_code_t rc;
740
741   switch (c->mode)
742     {
743     case GCRY_CIPHER_MODE_ECB:
744       rc = do_ecb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
745       break;
746
747     case GCRY_CIPHER_MODE_CBC:
748       rc = _gcry_cipher_cbc_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
749       break;
750
751     case GCRY_CIPHER_MODE_CFB:
752       rc = _gcry_cipher_cfb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
753       break;
754
755     case GCRY_CIPHER_MODE_OFB:
756       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
757       break;
758
759     case GCRY_CIPHER_MODE_CTR:
760       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
761       break;
762
763     case GCRY_CIPHER_MODE_AESWRAP:
764       rc = _gcry_cipher_aeswrap_encrypt (c, outbuf, outbuflen,
765                                          inbuf, inbuflen);
766       break;
767
768     case GCRY_CIPHER_MODE_CCM:
769       rc = _gcry_cipher_ccm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
770       break;
771
772     case GCRY_CIPHER_MODE_CMAC:
773       rc = GPG_ERR_INV_CIPHER_MODE;
774       break;
775
776     case GCRY_CIPHER_MODE_GCM:
777       rc = _gcry_cipher_gcm_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
778       break;
779
780     case GCRY_CIPHER_MODE_STREAM:
781       c->spec->stencrypt (&c->context.c,
782                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
783       rc = 0;
784       break;
785
786     case GCRY_CIPHER_MODE_NONE:
787       if (fips_mode () || !_gcry_get_debug_flag (0))
788         {
789           fips_signal_error ("cipher mode NONE used");
790           rc = GPG_ERR_INV_CIPHER_MODE;
791         }
792       else
793         {
794           if (inbuf != outbuf)
795             memmove (outbuf, inbuf, inbuflen);
796           rc = 0;
797         }
798       break;
799
800     default:
801       log_fatal ("cipher_encrypt: invalid mode %d\n", c->mode );
802       rc = GPG_ERR_INV_CIPHER_MODE;
803       break;
804     }
805
806   return rc;
807 }
808
809
810 /****************
811  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
812  * been requested.
813  */
814 gcry_error_t
815 gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
816                      const void *in, size_t inlen)
817 {
818   gcry_err_code_t err;
819
820   if (!in)  /* Caller requested in-place encryption.  */
821     {
822       in = out;
823       inlen = outsize;
824     }
825
826   err = cipher_encrypt (h, out, outsize, in, inlen);
827
828   /* Failsafe: Make sure that the plaintext will never make it into
829      OUT if the encryption returned an error.  */
830   if (err && out)
831     memset (out, 0x42, outsize);
832
833   return gcry_error (err);
834 }
835
836
837
838 /****************
839  * Decrypt INBUF to OUTBUF with the mode selected at open.
840  * inbuf and outbuf may overlap or be the same.
841  * Depending on the mode some some contraints apply to INBUFLEN.
842  */
843 static gcry_err_code_t
844 cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
845                 const byte *inbuf, size_t inbuflen)
846 {
847   gcry_err_code_t rc;
848
849   switch (c->mode)
850     {
851     case GCRY_CIPHER_MODE_ECB:
852       rc = do_ecb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
853       break;
854
855     case GCRY_CIPHER_MODE_CBC:
856       rc = _gcry_cipher_cbc_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
857       break;
858
859     case GCRY_CIPHER_MODE_CFB:
860       rc = _gcry_cipher_cfb_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
861       break;
862
863     case GCRY_CIPHER_MODE_OFB:
864       rc = _gcry_cipher_ofb_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
865       break;
866
867     case GCRY_CIPHER_MODE_CTR:
868       rc = _gcry_cipher_ctr_encrypt (c, outbuf, outbuflen, inbuf, inbuflen);
869       break;
870
871     case GCRY_CIPHER_MODE_AESWRAP:
872       rc = _gcry_cipher_aeswrap_decrypt (c, outbuf, outbuflen,
873                                          inbuf, inbuflen);
874       break;
875
876     case GCRY_CIPHER_MODE_CCM:
877       rc = _gcry_cipher_ccm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
878       break;
879
880     case GCRY_CIPHER_MODE_CMAC:
881       rc = GPG_ERR_INV_CIPHER_MODE;
882       break;
883
884     case GCRY_CIPHER_MODE_GCM:
885       rc = _gcry_cipher_gcm_decrypt (c, outbuf, outbuflen, inbuf, inbuflen);
886       break;
887
888     case GCRY_CIPHER_MODE_STREAM:
889       c->spec->stdecrypt (&c->context.c,
890                           outbuf, (byte*)/*arggg*/inbuf, inbuflen);
891       rc = 0;
892       break;
893
894     case GCRY_CIPHER_MODE_NONE:
895       if (fips_mode () || !_gcry_get_debug_flag (0))
896         {
897           fips_signal_error ("cipher mode NONE used");
898           rc = GPG_ERR_INV_CIPHER_MODE;
899         }
900       else
901         {
902           if (inbuf != outbuf)
903             memmove (outbuf, inbuf, inbuflen);
904           rc = 0;
905         }
906       break;
907
908     default:
909       log_fatal ("cipher_decrypt: invalid mode %d\n", c->mode );
910       rc = GPG_ERR_INV_CIPHER_MODE;
911       break;
912     }
913
914   return rc;
915 }
916
917
918 gcry_error_t
919 gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
920                      const void *in, size_t inlen)
921 {
922   gcry_err_code_t err;
923
924   if (!in) /* Caller requested in-place encryption. */
925     {
926       in = out;
927       inlen = outsize;
928     }
929
930   err = cipher_decrypt (h, out, outsize, in, inlen);
931
932   return gcry_error (err);
933 }
934
935
936
937 /****************
938  * Used for PGP's somewhat strange CFB mode. Only works if
939  * the corresponding flag is set.
940  */
941 static void
942 cipher_sync (gcry_cipher_hd_t c)
943 {
944   if ((c->flags & GCRY_CIPHER_ENABLE_SYNC) && c->unused)
945     {
946       memmove (c->u_iv.iv + c->unused,
947                c->u_iv.iv, c->spec->blocksize - c->unused);
948       memcpy (c->u_iv.iv,
949               c->lastiv + c->spec->blocksize - c->unused, c->unused);
950       c->unused = 0;
951     }
952 }
953
954
955 gcry_error_t
956 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
957 {
958   return cipher_setkey (hd, (void*)key, keylen);
959 }
960
961
962 gcry_error_t
963 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
964 {
965   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
966
967   switch (hd->mode)
968     {
969       case GCRY_CIPHER_MODE_CCM:
970         rc = _gcry_cipher_ccm_set_nonce (hd, iv, ivlen);
971         break;
972
973       default:
974         rc = cipher_setiv (hd, iv, ivlen);
975         break;
976     }
977   return gpg_error (rc);
978 }
979
980 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
981    block size length, or (NULL,0) to set the CTR to the all-zero
982    block. */
983 gpg_error_t
984 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
985 {
986   if (ctr && ctrlen == hd->spec->blocksize)
987     {
988       memcpy (hd->u_ctr.ctr, ctr, hd->spec->blocksize);
989       hd->unused = 0;
990     }
991   else if (!ctr || !ctrlen)
992     {
993       memset (hd->u_ctr.ctr, 0, hd->spec->blocksize);
994       hd->unused = 0;
995     }
996   else
997     return gpg_error (GPG_ERR_INV_ARG);
998   return 0;
999 }
1000
1001 gcry_error_t
1002 _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
1003                            size_t abuflen)
1004 {
1005   gcry_err_code_t rc;
1006
1007   switch (hd->mode)
1008     {
1009     case GCRY_CIPHER_MODE_CCM:
1010       rc = _gcry_cipher_ccm_authenticate (hd, abuf, abuflen);
1011       break;
1012
1013     case GCRY_CIPHER_MODE_CMAC:
1014       rc = _gcry_cipher_cmac_authenticate (hd, abuf, abuflen);
1015       break;
1016
1017     case GCRY_CIPHER_MODE_GCM:
1018       rc = _gcry_cipher_gcm_authenticate (hd, abuf, abuflen);
1019       break;
1020
1021     default:
1022       log_error ("gcry_cipher_authenticate: invalid mode %d\n", hd->mode);
1023       rc = GPG_ERR_INV_CIPHER_MODE;
1024       break;
1025     }
1026
1027   return gpg_error (rc);
1028 }
1029
1030 gcry_error_t
1031 _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
1032 {
1033   gcry_err_code_t rc;
1034
1035   switch (hd->mode)
1036     {
1037     case GCRY_CIPHER_MODE_CCM:
1038       rc = _gcry_cipher_ccm_get_tag (hd, outtag, taglen);
1039       break;
1040
1041     case GCRY_CIPHER_MODE_CMAC:
1042       rc = _gcry_cipher_cmac_get_tag (hd, outtag, taglen);
1043       break;
1044
1045     case GCRY_CIPHER_MODE_GCM:
1046       rc = _gcry_cipher_gcm_get_tag (hd, outtag, taglen);
1047       break;
1048
1049     default:
1050       log_error ("gcry_cipher_gettag: invalid mode %d\n", hd->mode);
1051       rc = GPG_ERR_INV_CIPHER_MODE;
1052       break;
1053     }
1054
1055   return gpg_error (rc);
1056 }
1057
1058 gcry_error_t
1059 _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
1060 {
1061   gcry_err_code_t rc;
1062
1063   switch (hd->mode)
1064     {
1065     case GCRY_CIPHER_MODE_CCM:
1066       rc = _gcry_cipher_ccm_check_tag (hd, intag, taglen);
1067       break;
1068
1069     case GCRY_CIPHER_MODE_CMAC:
1070       rc = _gcry_cipher_cmac_check_tag (hd, intag, taglen);
1071       break;
1072
1073     case GCRY_CIPHER_MODE_GCM:
1074       rc = _gcry_cipher_gcm_check_tag (hd, intag, taglen);
1075       break;
1076
1077     default:
1078       log_error ("gcry_cipher_checktag: invalid mode %d\n", hd->mode);
1079       rc = GPG_ERR_INV_CIPHER_MODE;
1080       break;
1081     }
1082
1083   return gpg_error (rc);
1084 }
1085
1086
1087 gcry_error_t
1088 gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
1089 {
1090   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
1091
1092   switch (cmd)
1093     {
1094     case GCRYCTL_RESET:
1095       cipher_reset (h);
1096       break;
1097
1098     case GCRYCTL_CFB_SYNC:
1099       cipher_sync( h );
1100       break;
1101
1102     case GCRYCTL_SET_CBC_CTS:
1103       if (buflen)
1104         if (h->flags & GCRY_CIPHER_CBC_MAC)
1105           rc = GPG_ERR_INV_FLAG;
1106         else
1107           h->flags |= GCRY_CIPHER_CBC_CTS;
1108       else
1109         h->flags &= ~GCRY_CIPHER_CBC_CTS;
1110       break;
1111
1112     case GCRYCTL_SET_CBC_MAC:
1113       if (buflen)
1114         if (h->flags & GCRY_CIPHER_CBC_CTS)
1115           rc = GPG_ERR_INV_FLAG;
1116         else
1117           h->flags |= GCRY_CIPHER_CBC_MAC;
1118       else
1119         h->flags &= ~GCRY_CIPHER_CBC_MAC;
1120       break;
1121
1122     case GCRYCTL_SET_CCM_LENGTHS:
1123       {
1124         size_t params[3];
1125         size_t encryptedlen;
1126         size_t aadlen;
1127         size_t authtaglen;
1128
1129         if (h->mode != GCRY_CIPHER_MODE_CCM)
1130           return gcry_error (GPG_ERR_INV_CIPHER_MODE);
1131
1132         if (!buffer || buflen != 3 * sizeof(size_t))
1133           return gcry_error (GPG_ERR_INV_ARG);
1134
1135         /* This command is used to pass additional length parameters needed
1136            by CCM mode to initialize CBC-MAC.  */
1137         memcpy (params, buffer, sizeof(params));
1138         encryptedlen = params[0];
1139         aadlen = params[1];
1140         authtaglen = params[2];
1141
1142         rc = _gcry_cipher_ccm_set_lengths (h, encryptedlen, aadlen, authtaglen);
1143       }
1144       break;
1145
1146     case GCRYCTL_DISABLE_ALGO:
1147       /* This command expects NULL for H and BUFFER to point to an
1148          integer with the algo number.  */
1149       if( h || !buffer || buflen != sizeof(int) )
1150         return gcry_error (GPG_ERR_CIPHER_ALGO);
1151       disable_cipher_algo( *(int*)buffer );
1152       break;
1153
1154     case 61:  /* Disable weak key detection (private).  */
1155       if (h->spec->set_extra_info)
1156         rc = h->spec->set_extra_info
1157           (&h->context.c, CIPHER_INFO_NO_WEAK_KEY, NULL, 0);
1158       else
1159         rc = GPG_ERR_NOT_SUPPORTED;
1160       break;
1161
1162     case 62: /* Return current input vector (private).  */
1163       /* This is the input block as used in CFB and OFB mode which has
1164          initially been set as IV.  The returned format is:
1165            1 byte  Actual length of the block in bytes.
1166            n byte  The block.
1167          If the provided buffer is too short, an error is returned. */
1168       if (buflen < (1 + h->spec->blocksize))
1169         rc = GPG_ERR_TOO_SHORT;
1170       else
1171         {
1172           unsigned char *ivp;
1173           unsigned char *dst = buffer;
1174           int n = h->unused;
1175
1176           if (!n)
1177             n = h->spec->blocksize;
1178           gcry_assert (n <= h->spec->blocksize);
1179           *dst++ = n;
1180           ivp = h->u_iv.iv + h->spec->blocksize - n;
1181           while (n--)
1182             *dst++ = *ivp++;
1183         }
1184       break;
1185
1186     default:
1187       rc = GPG_ERR_INV_OP;
1188     }
1189
1190   return gcry_error (rc);
1191 }
1192
1193
1194 /* Return information about the cipher handle H.  CMD is the kind of
1195    information requested.  BUFFER and NBYTES are reserved for now.
1196
1197    There are no values for CMD yet defined.
1198
1199    The function always returns GPG_ERR_INV_OP.
1200
1201  */
1202 gcry_error_t
1203 gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
1204 {
1205   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1206
1207   (void)h;
1208   (void)buffer;
1209   (void)nbytes;
1210
1211   switch (cmd)
1212     {
1213     default:
1214       err = GPG_ERR_INV_OP;
1215     }
1216
1217   return gcry_error (err);
1218 }
1219
1220 /* Return information about the given cipher algorithm ALGO.
1221
1222    WHAT select the kind of information returned:
1223
1224     GCRYCTL_GET_KEYLEN:
1225         Return the length of the key.  If the algorithm ALGO
1226         supports multiple key lengths, the maximum supported key length
1227         is returned.  The key length is returned as number of octets.
1228         BUFFER and NBYTES must be zero.
1229
1230     GCRYCTL_GET_BLKLEN:
1231         Return the blocklength of the algorithm ALGO counted in octets.
1232         BUFFER and NBYTES must be zero.
1233
1234     GCRYCTL_TEST_ALGO:
1235         Returns 0 if the specified algorithm ALGO is available for use.
1236         BUFFER and NBYTES must be zero.
1237
1238    Note: Because this function is in most cases used to return an
1239    integer value, we can make it easier for the caller to just look at
1240    the return value.  The caller will in all cases consult the value
1241    and thereby detecting whether a error occurred or not (i.e. while
1242    checking the block size)
1243  */
1244 gcry_error_t
1245 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1246 {
1247   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1248   unsigned int ui;
1249
1250   switch (what)
1251     {
1252     case GCRYCTL_GET_KEYLEN:
1253       if (buffer || (! nbytes))
1254         err = GPG_ERR_CIPHER_ALGO;
1255       else
1256         {
1257           ui = cipher_get_keylen (algo);
1258           if ((ui > 0) && (ui <= 512))
1259             *nbytes = (size_t) ui / 8;
1260           else
1261             /* The only reason for an error is an invalid algo.  */
1262             err = GPG_ERR_CIPHER_ALGO;
1263         }
1264       break;
1265
1266     case GCRYCTL_GET_BLKLEN:
1267       if (buffer || (! nbytes))
1268         err = GPG_ERR_CIPHER_ALGO;
1269       else
1270         {
1271           ui = cipher_get_blocksize (algo);
1272           if ((ui > 0) && (ui < 10000))
1273             *nbytes = ui;
1274           else
1275             /* The only reason is an invalid algo or a strange
1276                blocksize.  */
1277             err = GPG_ERR_CIPHER_ALGO;
1278         }
1279       break;
1280
1281     case GCRYCTL_TEST_ALGO:
1282       if (buffer || nbytes)
1283         err = GPG_ERR_INV_ARG;
1284       else
1285         err = check_cipher_algo (algo);
1286       break;
1287
1288       default:
1289         err = GPG_ERR_INV_OP;
1290     }
1291
1292   return gcry_error (err);
1293 }
1294
1295
1296 /* This function returns length of the key for algorithm ALGO.  If the
1297    algorithm supports multiple key lengths, the maximum supported key
1298    length is returned.  On error 0 is returned.  The key length is
1299    returned as number of octets.
1300
1301    This is a convenience functions which should be preferred over
1302    gcry_cipher_algo_info because it allows for proper type
1303    checking.  */
1304 size_t
1305 gcry_cipher_get_algo_keylen (int algo)
1306 {
1307   size_t n;
1308
1309   if (gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
1310     n = 0;
1311   return n;
1312 }
1313
1314 /* This functions returns the blocklength of the algorithm ALGO
1315    counted in octets.  On error 0 is returned.
1316
1317    This is a convenience functions which should be preferred over
1318    gcry_cipher_algo_info because it allows for proper type
1319    checking.  */
1320 size_t
1321 gcry_cipher_get_algo_blklen (int algo)
1322 {
1323   size_t n;
1324
1325   if (gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
1326     n = 0;
1327   return n;
1328 }
1329
1330 /* Explicitly initialize this module.  */
1331 gcry_err_code_t
1332 _gcry_cipher_init (void)
1333 {
1334   return 0;
1335 }
1336
1337
1338 /* Run the selftests for cipher algorithm ALGO with optional reporting
1339    function REPORT.  */
1340 gpg_error_t
1341 _gcry_cipher_selftest (int algo, int extended, selftest_report_func_t report)
1342 {
1343   gcry_err_code_t ec = 0;
1344   gcry_cipher_spec_t *spec;
1345
1346   spec = spec_from_algo (algo);
1347   if (spec && !spec->flags.disabled && spec->selftest)
1348     ec = spec->selftest (algo, extended, report);
1349   else
1350     {
1351       ec = GPG_ERR_CIPHER_ALGO;
1352       if (report)
1353         report ("cipher", algo, "module",
1354                 (spec && !spec->flags.disabled)?
1355                 "no selftest available" :
1356                 spec? "algorithm disabled" : "algorithm not found");
1357     }
1358
1359   return gpg_error (ec);
1360 }