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