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