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