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