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