pkgconfig: Fix libgcrypt.pc.
[libgcrypt.git] / cipher / md.c
1 /* md.c  -  message digest dispatcher
2  * Copyright (C) 1998, 1999, 2002, 2003, 2006,
3  *               2008 Free Software Foundation, Inc.
4  * Copyright (C) 2013, 2014 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
31
32 /* This is the list of the digest implementations included in
33    libgcrypt.  */
34 static gcry_md_spec_t * const digest_list[] =
35   {
36 #if USE_CRC
37      &_gcry_digest_spec_crc32,
38      &_gcry_digest_spec_crc32_rfc1510,
39      &_gcry_digest_spec_crc24_rfc2440,
40 #endif
41 #if USE_SHA1
42      &_gcry_digest_spec_sha1,
43 #endif
44 #if USE_SHA256
45      &_gcry_digest_spec_sha256,
46      &_gcry_digest_spec_sha224,
47 #endif
48 #if USE_SHA512
49      &_gcry_digest_spec_sha512,
50      &_gcry_digest_spec_sha384,
51      &_gcry_digest_spec_sha512_256,
52      &_gcry_digest_spec_sha512_224,
53 #endif
54 #if USE_SHA3
55      &_gcry_digest_spec_sha3_224,
56      &_gcry_digest_spec_sha3_256,
57      &_gcry_digest_spec_sha3_384,
58      &_gcry_digest_spec_sha3_512,
59      &_gcry_digest_spec_shake128,
60      &_gcry_digest_spec_shake256,
61 #endif
62 #if USE_GOST_R_3411_94
63      &_gcry_digest_spec_gost3411_94,
64      &_gcry_digest_spec_gost3411_cp,
65 #endif
66 #if USE_GOST_R_3411_12
67      &_gcry_digest_spec_stribog_256,
68      &_gcry_digest_spec_stribog_512,
69 #endif
70 #if USE_WHIRLPOOL
71      &_gcry_digest_spec_whirlpool,
72 #endif
73 #if USE_RMD160
74      &_gcry_digest_spec_rmd160,
75 #endif
76 #if USE_TIGER
77      &_gcry_digest_spec_tiger,
78      &_gcry_digest_spec_tiger1,
79      &_gcry_digest_spec_tiger2,
80 #endif
81 #if USE_MD5
82      &_gcry_digest_spec_md5,
83 #endif
84 #if USE_MD4
85      &_gcry_digest_spec_md4,
86 #endif
87 #if USE_MD2
88      &_gcry_digest_spec_md2,
89 #endif
90 #if USE_BLAKE2
91      &_gcry_digest_spec_blake2b_512,
92      &_gcry_digest_spec_blake2b_384,
93      &_gcry_digest_spec_blake2b_256,
94      &_gcry_digest_spec_blake2b_160,
95      &_gcry_digest_spec_blake2s_256,
96      &_gcry_digest_spec_blake2s_224,
97      &_gcry_digest_spec_blake2s_160,
98      &_gcry_digest_spec_blake2s_128,
99 #endif
100 #if USE_SM3
101      &_gcry_digest_spec_sm3,
102 #endif
103      NULL
104   };
105
106 /* Digest implementations starting with index 0 (enum gcry_md_algos) */
107 static gcry_md_spec_t * const digest_list_algo0[] =
108   {
109     NULL, /* GCRY_MD_NONE */
110 #if USE_MD5
111     &_gcry_digest_spec_md5,
112 #else
113     NULL,
114 #endif
115 #if USE_SHA1
116     &_gcry_digest_spec_sha1,
117 #else
118     NULL,
119 #endif
120 #if USE_RMD160
121     &_gcry_digest_spec_rmd160,
122 #else
123     NULL,
124 #endif
125     NULL, /* Unused index 4 */
126 #if USE_MD2
127     &_gcry_digest_spec_md2,
128 #else
129     NULL,
130 #endif
131 #if USE_TIGER
132     &_gcry_digest_spec_tiger,
133 #else
134     NULL,
135 #endif
136     NULL, /* GCRY_MD_HAVAL */
137 #if USE_SHA256
138     &_gcry_digest_spec_sha256,
139 #else
140     NULL,
141 #endif
142 #if USE_SHA512
143     &_gcry_digest_spec_sha384,
144     &_gcry_digest_spec_sha512,
145 #else
146     NULL,
147     NULL,
148 #endif
149 #if USE_SHA256
150     &_gcry_digest_spec_sha224
151 #else
152     NULL
153 #endif
154   };
155
156 /* Digest implementations starting with index 301 (enum gcry_md_algos) */
157 static gcry_md_spec_t * const digest_list_algo301[] =
158   {
159 #if USE_MD4
160     &_gcry_digest_spec_md4,
161 #else
162     NULL,
163 #endif
164 #if USE_CRC
165     &_gcry_digest_spec_crc32,
166     &_gcry_digest_spec_crc32_rfc1510,
167     &_gcry_digest_spec_crc24_rfc2440,
168 #else
169     NULL,
170     NULL,
171     NULL,
172 #endif
173 #if USE_WHIRLPOOL
174     &_gcry_digest_spec_whirlpool,
175 #else
176     NULL,
177 #endif
178 #if USE_TIGER
179     &_gcry_digest_spec_tiger1,
180     &_gcry_digest_spec_tiger2,
181 #else
182     NULL,
183     NULL,
184 #endif
185 #if USE_GOST_R_3411_94
186     &_gcry_digest_spec_gost3411_94,
187 #else
188     NULL,
189 #endif
190 #if USE_GOST_R_3411_12
191     &_gcry_digest_spec_stribog_256,
192     &_gcry_digest_spec_stribog_512,
193 #else
194     NULL,
195     NULL,
196 #endif
197 #if USE_GOST_R_3411_94
198     &_gcry_digest_spec_gost3411_cp,
199 #else
200     NULL,
201 #endif
202 #if USE_SHA3
203     &_gcry_digest_spec_sha3_224,
204     &_gcry_digest_spec_sha3_256,
205     &_gcry_digest_spec_sha3_384,
206     &_gcry_digest_spec_sha3_512,
207     &_gcry_digest_spec_shake128,
208     &_gcry_digest_spec_shake256,
209 #else
210     NULL,
211     NULL,
212     NULL,
213     NULL,
214     NULL,
215     NULL,
216 #endif
217 #if USE_BLAKE2
218     &_gcry_digest_spec_blake2b_512,
219     &_gcry_digest_spec_blake2b_384,
220     &_gcry_digest_spec_blake2b_256,
221     &_gcry_digest_spec_blake2b_160,
222     &_gcry_digest_spec_blake2s_256,
223     &_gcry_digest_spec_blake2s_224,
224     &_gcry_digest_spec_blake2s_160,
225     &_gcry_digest_spec_blake2s_128,
226 #else
227     NULL,
228     NULL,
229     NULL,
230     NULL,
231     NULL,
232     NULL,
233     NULL,
234     NULL,
235 #endif
236 #if USE_SM3
237     &_gcry_digest_spec_sm3,
238 #else
239     NULL,
240 #endif
241 #if USE_SHA512
242     &_gcry_digest_spec_sha512_256,
243     &_gcry_digest_spec_sha512_224,
244 #else
245     NULL,
246     NULL,
247 #endif
248   };
249
250
251 typedef struct gcry_md_list
252 {
253   gcry_md_spec_t *spec;
254   struct gcry_md_list *next;
255   size_t actual_struct_size;     /* Allocated size of this structure. */
256   PROPERLY_ALIGNED_TYPE context[1];
257 } GcryDigestEntry;
258
259 /* This structure is put right after the gcry_md_hd_t buffer, so that
260  * only one memory block is needed. */
261 struct gcry_md_context
262 {
263   int  magic;
264   size_t actual_handle_size;     /* Allocated size of this handle. */
265   FILE  *debug;
266   struct {
267     unsigned int secure:1;
268     unsigned int finalized:1;
269     unsigned int bugemu1:1;
270     unsigned int hmac:1;
271   } flags;
272   GcryDigestEntry *list;
273 };
274
275
276 #define CTX_MAGIC_NORMAL 0x11071961
277 #define CTX_MAGIC_SECURE 0x16917011
278
279 static gcry_err_code_t md_enable (gcry_md_hd_t hd, int algo);
280 static void md_close (gcry_md_hd_t a);
281 static void md_write (gcry_md_hd_t a, const void *inbuf, size_t inlen);
282 static byte *md_read( gcry_md_hd_t a, int algo );
283 static int md_get_algo( gcry_md_hd_t a );
284 static int md_digest_length( int algo );
285 static void md_start_debug ( gcry_md_hd_t a, const char *suffix );
286 static void md_stop_debug ( gcry_md_hd_t a );
287
288
289 \f
290 static int
291 map_algo (int algo)
292 {
293   return algo;
294 }
295
296
297 /* Return the spec structure for the hash algorithm ALGO.  For an
298    unknown algorithm NULL is returned.  */
299 static gcry_md_spec_t *
300 spec_from_algo (int algo)
301 {
302   gcry_md_spec_t *spec = NULL;
303
304   algo = map_algo (algo);
305
306   if (algo >= 0 && algo < DIM(digest_list_algo0))
307     spec = digest_list_algo0[algo];
308   else if (algo >= 301 && algo < 301 + DIM(digest_list_algo301))
309     spec = digest_list_algo301[algo - 301];
310
311   if (spec)
312     gcry_assert (spec->algo == algo);
313
314   return spec;
315 }
316
317
318 /* Lookup a hash's spec by its name.  */
319 static gcry_md_spec_t *
320 spec_from_name (const char *name)
321 {
322   gcry_md_spec_t *spec;
323   int idx;
324
325   for (idx=0; (spec = digest_list[idx]); idx++)
326     {
327       if (!stricmp (name, spec->name))
328         return spec;
329     }
330
331   return NULL;
332 }
333
334
335 /* Lookup a hash's spec by its OID.  */
336 static gcry_md_spec_t *
337 spec_from_oid (const char *oid)
338 {
339   gcry_md_spec_t *spec;
340   gcry_md_oid_spec_t *oid_specs;
341   int idx, j;
342
343   for (idx=0; (spec = digest_list[idx]); idx++)
344     {
345       oid_specs = spec->oids;
346       if (oid_specs)
347         {
348           for (j = 0; oid_specs[j].oidstring; j++)
349             if (!stricmp (oid, oid_specs[j].oidstring))
350               return spec;
351         }
352     }
353
354   return NULL;
355 }
356
357
358 static gcry_md_spec_t *
359 search_oid (const char *oid, gcry_md_oid_spec_t *oid_spec)
360 {
361   gcry_md_spec_t *spec;
362   int i;
363
364   if (!oid)
365     return NULL;
366
367   if (!strncmp (oid, "oid.", 4) || !strncmp (oid, "OID.", 4))
368     oid += 4;
369
370   spec = spec_from_oid (oid);
371   if (spec && spec->oids)
372     {
373       for (i = 0; spec->oids[i].oidstring; i++)
374         if (!stricmp (oid, spec->oids[i].oidstring))
375           {
376             if (oid_spec)
377               *oid_spec = spec->oids[i];
378             return spec;
379           }
380     }
381
382   return NULL;
383 }
384
385
386 /****************
387  * Map a string to the digest algo
388  */
389 int
390 _gcry_md_map_name (const char *string)
391 {
392   gcry_md_spec_t *spec;
393
394   if (!string)
395     return 0;
396
397   /* If the string starts with a digit (optionally prefixed with
398      either "OID." or "oid."), we first look into our table of ASN.1
399      object identifiers to figure out the algorithm */
400   spec = search_oid (string, NULL);
401   if (spec)
402     return spec->algo;
403
404   /* Not found, search a matching digest name.  */
405   spec = spec_from_name (string);
406   if (spec)
407     return spec->algo;
408
409   return 0;
410 }
411
412
413 /****************
414  * This function simply returns the name of the algorithm or some constant
415  * string when there is no algo.  It will never return NULL.
416  * Use  the macro gcry_md_test_algo() to check whether the algorithm
417  * is valid.
418  */
419 const char *
420 _gcry_md_algo_name (int algorithm)
421 {
422   gcry_md_spec_t *spec;
423
424   spec = spec_from_algo (algorithm);
425   return spec ? spec->name : "?";
426 }
427
428
429 static gcry_err_code_t
430 check_digest_algo (int algorithm)
431 {
432   gcry_md_spec_t *spec;
433
434   spec = spec_from_algo (algorithm);
435   if (spec && !spec->flags.disabled)
436     return 0;
437
438   return GPG_ERR_DIGEST_ALGO;
439
440 }
441
442
443 /****************
444  * Open a message digest handle for use with algorithm ALGO.
445  * More algorithms may be added by md_enable(). The initial algorithm
446  * may be 0.
447  */
448 static gcry_err_code_t
449 md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
450 {
451   gcry_err_code_t err = 0;
452   int secure = !!(flags & GCRY_MD_FLAG_SECURE);
453   int hmac =   !!(flags & GCRY_MD_FLAG_HMAC);
454   int bufsize = secure ? 512 : 1024;
455   struct gcry_md_context *ctx;
456   gcry_md_hd_t hd;
457   size_t n;
458
459   /* Allocate a memory area to hold the caller visible buffer with it's
460    * control information and the data required by this module. Set the
461    * context pointer at the beginning to this area.
462    * We have to use this strange scheme because we want to hide the
463    * internal data but have a variable sized buffer.
464    *
465    *    +---+------+---........------+-------------+
466    *    !ctx! bctl !  buffer         ! private     !
467    *    +---+------+---........------+-------------+
468    *      !                           ^
469    *      !---------------------------!
470    *
471    * We have to make sure that private is well aligned.
472    */
473   n = sizeof (struct gcry_md_handle) + bufsize;
474   n = ((n + sizeof (PROPERLY_ALIGNED_TYPE) - 1)
475        / sizeof (PROPERLY_ALIGNED_TYPE)) * sizeof (PROPERLY_ALIGNED_TYPE);
476
477   /* Allocate and set the Context pointer to the private data */
478   if (secure)
479     hd = xtrymalloc_secure (n + sizeof (struct gcry_md_context));
480   else
481     hd = xtrymalloc (n + sizeof (struct gcry_md_context));
482
483   if (! hd)
484     err = gpg_err_code_from_errno (errno);
485
486   if (! err)
487     {
488       hd->ctx = ctx = (void *) ((char *) hd + n);
489       /* Setup the globally visible data (bctl in the diagram).*/
490       hd->bufsize = n - sizeof (struct gcry_md_handle) + 1;
491       hd->bufpos = 0;
492
493       /* Initialize the private data. */
494       memset (hd->ctx, 0, sizeof *hd->ctx);
495       ctx->magic = secure ? CTX_MAGIC_SECURE : CTX_MAGIC_NORMAL;
496       ctx->actual_handle_size = n + sizeof (struct gcry_md_context);
497       ctx->flags.secure = secure;
498       ctx->flags.hmac = hmac;
499       ctx->flags.bugemu1 = !!(flags & GCRY_MD_FLAG_BUGEMU1);
500     }
501
502   if (! err)
503     {
504       /* Hmmm, should we really do that? - yes [-wk] */
505       _gcry_fast_random_poll ();
506
507       if (algo)
508         {
509           err = md_enable (hd, algo);
510           if (err)
511             md_close (hd);
512         }
513     }
514
515   if (! err)
516     *h = hd;
517
518   return err;
519 }
520
521 /* Create a message digest object for algorithm ALGO.  FLAGS may be
522    given as an bitwise OR of the gcry_md_flags values.  ALGO may be
523    given as 0 if the algorithms to be used are later set using
524    gcry_md_enable. H is guaranteed to be a valid handle or NULL on
525    error.  */
526 gcry_err_code_t
527 _gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
528 {
529   gcry_err_code_t rc;
530   gcry_md_hd_t hd;
531
532   if ((flags & ~(GCRY_MD_FLAG_SECURE
533                  | GCRY_MD_FLAG_HMAC
534                  | GCRY_MD_FLAG_BUGEMU1)))
535     rc = GPG_ERR_INV_ARG;
536   else
537     rc = md_open (&hd, algo, flags);
538
539   *h = rc? NULL : hd;
540   return rc;
541 }
542
543
544
545 static gcry_err_code_t
546 md_enable (gcry_md_hd_t hd, int algorithm)
547 {
548   struct gcry_md_context *h = hd->ctx;
549   gcry_md_spec_t *spec;
550   GcryDigestEntry *entry;
551   gcry_err_code_t err = 0;
552
553   for (entry = h->list; entry; entry = entry->next)
554     if (entry->spec->algo == algorithm)
555       return 0; /* Already enabled */
556
557   spec = spec_from_algo (algorithm);
558   if (!spec)
559     {
560       log_debug ("md_enable: algorithm %d not available\n", algorithm);
561       err = GPG_ERR_DIGEST_ALGO;
562     }
563
564
565   if (!err && algorithm == GCRY_MD_MD5 && fips_mode ())
566     {
567       _gcry_inactivate_fips_mode ("MD5 used");
568       if (_gcry_enforced_fips_mode () )
569         {
570           /* We should never get to here because we do not register
571              MD5 in enforced fips mode. But better throw an error.  */
572           err = GPG_ERR_DIGEST_ALGO;
573         }
574     }
575
576   if (!err && h->flags.hmac && spec->read == NULL)
577     {
578       /* Expandable output function cannot act as part of HMAC. */
579       err = GPG_ERR_DIGEST_ALGO;
580     }
581
582   if (!err)
583     {
584       size_t size = (sizeof (*entry)
585                      + spec->contextsize * (h->flags.hmac? 3 : 1)
586                      - sizeof (entry->context));
587
588       /* And allocate a new list entry. */
589       if (h->flags.secure)
590         entry = xtrymalloc_secure (size);
591       else
592         entry = xtrymalloc (size);
593
594       if (! entry)
595         err = gpg_err_code_from_errno (errno);
596       else
597         {
598           entry->spec = spec;
599           entry->next = h->list;
600           entry->actual_struct_size = size;
601           h->list = entry;
602
603           /* And init this instance. */
604           entry->spec->init (entry->context,
605                              h->flags.bugemu1? GCRY_MD_FLAG_BUGEMU1:0);
606         }
607     }
608
609   return err;
610 }
611
612
613 gcry_err_code_t
614 _gcry_md_enable (gcry_md_hd_t hd, int algorithm)
615 {
616   return md_enable (hd, algorithm);
617 }
618
619
620 static gcry_err_code_t
621 md_copy (gcry_md_hd_t ahd, gcry_md_hd_t *b_hd)
622 {
623   gcry_err_code_t err = 0;
624   struct gcry_md_context *a = ahd->ctx;
625   struct gcry_md_context *b;
626   GcryDigestEntry *ar, *br;
627   gcry_md_hd_t bhd;
628   size_t n;
629
630   if (ahd->bufpos)
631     md_write (ahd, NULL, 0);
632
633   n = (char *) ahd->ctx - (char *) ahd;
634   if (a->flags.secure)
635     bhd = xtrymalloc_secure (n + sizeof (struct gcry_md_context));
636   else
637     bhd = xtrymalloc (n + sizeof (struct gcry_md_context));
638
639   if (!bhd)
640     {
641       err = gpg_err_code_from_syserror ();
642       goto leave;
643     }
644
645   bhd->ctx = b = (void *) ((char *) bhd + n);
646   /* No need to copy the buffer due to the write above. */
647   gcry_assert (ahd->bufsize == (n - sizeof (struct gcry_md_handle) + 1));
648   bhd->bufsize = ahd->bufsize;
649   bhd->bufpos = 0;
650   gcry_assert (! ahd->bufpos);
651   memcpy (b, a, sizeof *a);
652   b->list = NULL;
653   b->debug = NULL;
654
655   /* Copy the complete list of algorithms.  The copied list is
656      reversed, but that doesn't matter. */
657   for (ar = a->list; ar; ar = ar->next)
658     {
659       if (a->flags.secure)
660         br = xtrymalloc_secure (ar->actual_struct_size);
661       else
662         br = xtrymalloc (ar->actual_struct_size);
663       if (!br)
664         {
665           err = gpg_err_code_from_syserror ();
666           md_close (bhd);
667           goto leave;
668         }
669
670       memcpy (br, ar, ar->actual_struct_size);
671       br->next = b->list;
672       b->list = br;
673     }
674
675   if (a->debug)
676     md_start_debug (bhd, "unknown");
677
678   *b_hd = bhd;
679
680  leave:
681   return err;
682 }
683
684
685 gcry_err_code_t
686 _gcry_md_copy (gcry_md_hd_t *handle, gcry_md_hd_t hd)
687 {
688   gcry_err_code_t rc;
689
690   rc = md_copy (hd, handle);
691   if (rc)
692     *handle = NULL;
693   return rc;
694 }
695
696
697 /*
698  * Reset all contexts and discard any buffered stuff.  This may be used
699  * instead of a md_close(); md_open().
700  */
701 void
702 _gcry_md_reset (gcry_md_hd_t a)
703 {
704   GcryDigestEntry *r;
705
706   /* Note: We allow this even in fips non operational mode.  */
707
708   a->bufpos = a->ctx->flags.finalized = 0;
709
710   if (a->ctx->flags.hmac)
711     for (r = a->ctx->list; r; r = r->next)
712       {
713         memcpy (r->context, (char *)r->context + r->spec->contextsize,
714                 r->spec->contextsize);
715       }
716   else
717     for (r = a->ctx->list; r; r = r->next)
718       {
719         memset (r->context, 0, r->spec->contextsize);
720         (*r->spec->init) (r->context,
721                           a->ctx->flags.bugemu1? GCRY_MD_FLAG_BUGEMU1:0);
722       }
723 }
724
725
726 static void
727 md_close (gcry_md_hd_t a)
728 {
729   GcryDigestEntry *r, *r2;
730
731   if (! a)
732     return;
733   if (a->ctx->debug)
734     md_stop_debug (a);
735   for (r = a->ctx->list; r; r = r2)
736     {
737       r2 = r->next;
738       wipememory (r, r->actual_struct_size);
739       xfree (r);
740     }
741
742   wipememory (a, a->ctx->actual_handle_size);
743   xfree(a);
744 }
745
746
747 void
748 _gcry_md_close (gcry_md_hd_t hd)
749 {
750   /* Note: We allow this even in fips non operational mode.  */
751   md_close (hd);
752 }
753
754
755 static void
756 md_write (gcry_md_hd_t a, const void *inbuf, size_t inlen)
757 {
758   GcryDigestEntry *r;
759
760   if (a->ctx->debug)
761     {
762       if (a->bufpos && fwrite (a->buf, a->bufpos, 1, a->ctx->debug) != 1)
763         BUG();
764       if (inlen && fwrite (inbuf, inlen, 1, a->ctx->debug) != 1)
765         BUG();
766     }
767
768   for (r = a->ctx->list; r; r = r->next)
769     {
770       if (a->bufpos)
771         (*r->spec->write) (r->context, a->buf, a->bufpos);
772       (*r->spec->write) (r->context, inbuf, inlen);
773     }
774   a->bufpos = 0;
775 }
776
777
778 /* Note that this function may be used after finalize and read to keep
779    on writing to the transform function so to mitigate timing
780    attacks.  */
781 void
782 _gcry_md_write (gcry_md_hd_t hd, const void *inbuf, size_t inlen)
783 {
784   md_write (hd, inbuf, inlen);
785 }
786
787
788 static void
789 md_final (gcry_md_hd_t a)
790 {
791   GcryDigestEntry *r;
792
793   if (a->ctx->flags.finalized)
794     return;
795
796   if (a->bufpos)
797     md_write (a, NULL, 0);
798
799   for (r = a->ctx->list; r; r = r->next)
800     (*r->spec->final) (r->context);
801
802   a->ctx->flags.finalized = 1;
803
804   if (!a->ctx->flags.hmac)
805     return;
806
807   for (r = a->ctx->list; r; r = r->next)
808     {
809       byte *p;
810       size_t dlen = r->spec->mdlen;
811       byte *hash;
812       gcry_err_code_t err;
813
814       if (r->spec->read == NULL)
815         continue;
816
817       p = r->spec->read (r->context);
818
819       if (a->ctx->flags.secure)
820         hash = xtrymalloc_secure (dlen);
821       else
822         hash = xtrymalloc (dlen);
823       if (!hash)
824         {
825           err = gpg_err_code_from_errno (errno);
826           _gcry_fatal_error (err, NULL);
827         }
828
829       memcpy (hash, p, dlen);
830       memcpy (r->context, (char *)r->context + r->spec->contextsize * 2,
831               r->spec->contextsize);
832       (*r->spec->write) (r->context, hash, dlen);
833       (*r->spec->final) (r->context);
834       xfree (hash);
835     }
836 }
837
838
839 static gcry_err_code_t
840 md_setkey (gcry_md_hd_t h, const unsigned char *key, size_t keylen)
841 {
842   gcry_err_code_t rc = 0;
843   GcryDigestEntry *r;
844   int algo_had_setkey = 0;
845
846   if (!h->ctx->list)
847     return GPG_ERR_DIGEST_ALGO; /* Might happen if no algo is enabled.  */
848
849   if (h->ctx->flags.hmac)
850     return GPG_ERR_DIGEST_ALGO; /* Tried md_setkey for HMAC md. */
851
852   for (r = h->ctx->list; r; r = r->next)
853     {
854       switch (r->spec->algo)
855         {
856 #if USE_BLAKE2
857         /* TODO? add spec->init_with_key? */
858         case GCRY_MD_BLAKE2B_512:
859         case GCRY_MD_BLAKE2B_384:
860         case GCRY_MD_BLAKE2B_256:
861         case GCRY_MD_BLAKE2B_160:
862         case GCRY_MD_BLAKE2S_256:
863         case GCRY_MD_BLAKE2S_224:
864         case GCRY_MD_BLAKE2S_160:
865         case GCRY_MD_BLAKE2S_128:
866           algo_had_setkey = 1;
867           memset (r->context, 0, r->spec->contextsize);
868           rc = _gcry_blake2_init_with_key (r->context,
869                                            h->ctx->flags.bugemu1
870                                              ? GCRY_MD_FLAG_BUGEMU1:0,
871                                            key, keylen, r->spec->algo);
872           break;
873 #endif
874         default:
875           rc = GPG_ERR_DIGEST_ALGO;
876           break;
877         }
878
879       if (rc)
880         break;
881     }
882
883   if (rc && !algo_had_setkey)
884     {
885       /* None of algorithms had setkey implementation, so contexts were not
886        * modified. Just return error. */
887       return rc;
888     }
889   else if (rc && algo_had_setkey)
890     {
891       /* Some of the contexts have been modified, but got error. Reset
892        * all contexts. */
893       _gcry_md_reset (h);
894       return rc;
895     }
896
897   /* Successful md_setkey implies reset. */
898   h->bufpos = h->ctx->flags.finalized = 0;
899
900   return 0;
901 }
902
903
904 static gcry_err_code_t
905 prepare_macpads (gcry_md_hd_t a, const unsigned char *key, size_t keylen)
906 {
907   GcryDigestEntry *r;
908
909   if (!a->ctx->list)
910     return GPG_ERR_DIGEST_ALGO; /* Might happen if no algo is enabled.  */
911
912   if (!a->ctx->flags.hmac)
913     return GPG_ERR_DIGEST_ALGO; /* Tried prepare_macpads for non-HMAC md. */
914
915   for (r = a->ctx->list; r; r = r->next)
916     {
917       const unsigned char *k;
918       size_t k_len;
919       unsigned char *key_allocated = NULL;
920       int macpad_Bsize;
921       int i;
922
923       switch (r->spec->algo)
924         {
925         /* TODO: add spec->blocksize */
926         case GCRY_MD_SHA3_224:
927           macpad_Bsize = 1152 / 8;
928           break;
929         case GCRY_MD_SHA3_256:
930           macpad_Bsize = 1088 / 8;
931           break;
932         case GCRY_MD_SHA3_384:
933           macpad_Bsize = 832 / 8;
934           break;
935         case GCRY_MD_SHA3_512:
936           macpad_Bsize = 576 / 8;
937           break;
938         case GCRY_MD_SHA384:
939         case GCRY_MD_SHA512:
940         case GCRY_MD_SHA512_256:
941         case GCRY_MD_SHA512_224:
942         case GCRY_MD_BLAKE2B_512:
943         case GCRY_MD_BLAKE2B_384:
944         case GCRY_MD_BLAKE2B_256:
945         case GCRY_MD_BLAKE2B_160:
946           macpad_Bsize = 128;
947           break;
948         case GCRY_MD_GOSTR3411_94:
949         case GCRY_MD_GOSTR3411_CP:
950           macpad_Bsize = 32;
951           break;
952         default:
953           macpad_Bsize = 64;
954           break;
955         }
956
957       if ( keylen > macpad_Bsize )
958         {
959           k = key_allocated = xtrymalloc_secure (r->spec->mdlen);
960           if (!k)
961             return gpg_err_code_from_errno (errno);
962           _gcry_md_hash_buffer (r->spec->algo, key_allocated, key, keylen);
963           k_len = r->spec->mdlen;
964           gcry_assert ( k_len <= macpad_Bsize );
965         }
966       else
967         {
968           k = key;
969           k_len = keylen;
970         }
971
972       (*r->spec->init) (r->context,
973                         a->ctx->flags.bugemu1? GCRY_MD_FLAG_BUGEMU1:0);
974       a->bufpos = 0;
975       for (i=0; i < k_len; i++ )
976         _gcry_md_putc (a, k[i] ^ 0x36);
977       for (; i < macpad_Bsize; i++ )
978         _gcry_md_putc (a, 0x36);
979       (*r->spec->write) (r->context, a->buf, a->bufpos);
980       memcpy ((char *)r->context + r->spec->contextsize, r->context,
981               r->spec->contextsize);
982
983       (*r->spec->init) (r->context,
984                         a->ctx->flags.bugemu1? GCRY_MD_FLAG_BUGEMU1:0);
985       a->bufpos = 0;
986       for (i=0; i < k_len; i++ )
987         _gcry_md_putc (a, k[i] ^ 0x5c);
988       for (; i < macpad_Bsize; i++ )
989         _gcry_md_putc (a, 0x5c);
990       (*r->spec->write) (r->context, a->buf, a->bufpos);
991       memcpy ((char *)r->context + r->spec->contextsize*2, r->context,
992               r->spec->contextsize);
993
994       xfree (key_allocated);
995     }
996
997   a->bufpos = 0;
998   return 0;
999 }
1000
1001
1002 gcry_err_code_t
1003 _gcry_md_ctl (gcry_md_hd_t hd, int cmd, void *buffer, size_t buflen)
1004 {
1005   gcry_err_code_t rc = 0;
1006
1007   (void)buflen; /* Currently not used.  */
1008
1009   switch (cmd)
1010     {
1011     case GCRYCTL_FINALIZE:
1012       md_final (hd);
1013       break;
1014     case GCRYCTL_START_DUMP:
1015       md_start_debug (hd, buffer);
1016       break;
1017     case GCRYCTL_STOP_DUMP:
1018       md_stop_debug ( hd );
1019       break;
1020     default:
1021       rc = GPG_ERR_INV_OP;
1022     }
1023   return rc;
1024 }
1025
1026
1027 gcry_err_code_t
1028 _gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
1029 {
1030   gcry_err_code_t rc;
1031
1032   if (hd->ctx->flags.hmac)
1033     {
1034       rc = prepare_macpads (hd, key, keylen);
1035       if (!rc)
1036         _gcry_md_reset (hd);
1037     }
1038   else
1039     {
1040       rc = md_setkey (hd, key, keylen);
1041     }
1042
1043   return rc;
1044 }
1045
1046
1047 /* The new debug interface.  If SUFFIX is a string it creates an debug
1048    file for the context HD.  IF suffix is NULL, the file is closed and
1049    debugging is stopped.  */
1050 void
1051 _gcry_md_debug (gcry_md_hd_t hd, const char *suffix)
1052 {
1053   if (suffix)
1054     md_start_debug (hd, suffix);
1055   else
1056     md_stop_debug (hd);
1057 }
1058
1059
1060 /****************
1061  * If ALGO is null get the digest for the used algo (which should be
1062  * only one)
1063  */
1064 static byte *
1065 md_read( gcry_md_hd_t a, int algo )
1066 {
1067   GcryDigestEntry *r = a->ctx->list;
1068
1069   if (! algo)
1070     {
1071       /* Return the first algorithm */
1072       if (r)
1073         {
1074           if (r->next)
1075             log_debug ("more than one algorithm in md_read(0)\n");
1076           if (r->spec->read)
1077             return r->spec->read (r->context);
1078         }
1079     }
1080   else
1081     {
1082       for (r = a->ctx->list; r; r = r->next)
1083         if (r->spec->algo == algo)
1084           {
1085             if (r->spec->read)
1086               return r->spec->read (r->context);
1087             break;
1088           }
1089     }
1090
1091   if (r && !r->spec->read)
1092     _gcry_fatal_error (GPG_ERR_DIGEST_ALGO,
1093                        "requested algo has no fixed digest length");
1094   else
1095     _gcry_fatal_error (GPG_ERR_DIGEST_ALGO, "requested algo not in md context");
1096   return NULL;
1097 }
1098
1099
1100 /*
1101  * Read out the complete digest, this function implictly finalizes
1102  * the hash.
1103  */
1104 byte *
1105 _gcry_md_read (gcry_md_hd_t hd, int algo)
1106 {
1107   /* This function is expected to always return a digest, thus we
1108      can't return an error which we actually should do in
1109      non-operational state.  */
1110   _gcry_md_ctl (hd, GCRYCTL_FINALIZE, NULL, 0);
1111   return md_read (hd, algo);
1112 }
1113
1114
1115 /****************
1116  * If ALGO is null get the digest for the used algo (which should be
1117  * only one)
1118  */
1119 static gcry_err_code_t
1120 md_extract(gcry_md_hd_t a, int algo, void *out, size_t outlen)
1121 {
1122   GcryDigestEntry *r = a->ctx->list;
1123
1124   if (!algo)
1125     {
1126       /* Return the first algorithm */
1127       if (r && r->spec->extract)
1128         {
1129           if (r->next)
1130             log_debug ("more than one algorithm in md_extract(0)\n");
1131           r->spec->extract (r->context, out, outlen);
1132           return 0;
1133         }
1134     }
1135   else
1136     {
1137       for (r = a->ctx->list; r; r = r->next)
1138         if (r->spec->algo == algo && r->spec->extract)
1139           {
1140             r->spec->extract (r->context, out, outlen);
1141             return 0;
1142           }
1143     }
1144
1145   return GPG_ERR_DIGEST_ALGO;
1146 }
1147
1148
1149 /*
1150  * Expand the output from XOF class digest, this function implictly finalizes
1151  * the hash.
1152  */
1153 gcry_err_code_t
1154 _gcry_md_extract (gcry_md_hd_t hd, int algo, void *out, size_t outlen)
1155 {
1156   _gcry_md_ctl (hd, GCRYCTL_FINALIZE, NULL, 0);
1157   return md_extract (hd, algo, out, outlen);
1158 }
1159
1160
1161 /*
1162  * Read out an intermediate digest.  Not yet functional.
1163  */
1164 gcry_err_code_t
1165 _gcry_md_get (gcry_md_hd_t hd, int algo, byte *buffer, int buflen)
1166 {
1167   (void)hd;
1168   (void)algo;
1169   (void)buffer;
1170   (void)buflen;
1171
1172   /*md_digest ... */
1173   fips_signal_error ("unimplemented function called");
1174   return GPG_ERR_INTERNAL;
1175 }
1176
1177
1178 /*
1179  * Shortcut function to hash a buffer with a given algo. The only
1180  * guaranteed supported algorithms are RIPE-MD160 and SHA-1. The
1181  * supplied digest buffer must be large enough to store the resulting
1182  * hash.  No error is returned, the function will abort on an invalid
1183  * algo.  DISABLED_ALGOS are ignored here.  */
1184 void
1185 _gcry_md_hash_buffer (int algo, void *digest,
1186                       const void *buffer, size_t length)
1187 {
1188   gcry_md_spec_t *spec;
1189
1190   spec = spec_from_algo (algo);
1191   if (!spec)
1192     {
1193       log_debug ("md_hash_buffer: algorithm %d not available\n", algo);
1194       return;
1195     }
1196
1197   if (algo == GCRY_MD_MD5 && fips_mode ())
1198     {
1199       _gcry_inactivate_fips_mode ("MD5 used");
1200       if (_gcry_enforced_fips_mode () )
1201         {
1202           /* We should never get to here because we do not register
1203              MD5 in enforced fips mode.  */
1204           _gcry_fips_noreturn ();
1205         }
1206     }
1207
1208   if (spec->hash_buffer != NULL)
1209     {
1210       spec->hash_buffer (digest, buffer, length);
1211     }
1212   else if (spec->hash_buffers != NULL)
1213     {
1214       gcry_buffer_t iov;
1215
1216       iov.size = 0;
1217       iov.data = (void *)buffer;
1218       iov.off = 0;
1219       iov.len = length;
1220
1221       spec->hash_buffers (digest, &iov, 1);
1222     }
1223   else
1224     {
1225       /* For the others we do not have a fast function, so we use the
1226          normal functions. */
1227       gcry_md_hd_t h;
1228       gpg_err_code_t err;
1229
1230       err = md_open (&h, algo, 0);
1231       if (err)
1232         log_bug ("gcry_md_open failed for algo %d: %s",
1233                 algo, gpg_strerror (gcry_error(err)));
1234       md_write (h, (byte *) buffer, length);
1235       md_final (h);
1236       memcpy (digest, md_read (h, algo), md_digest_length (algo));
1237       md_close (h);
1238     }
1239 }
1240
1241
1242 /* Shortcut function to hash multiple buffers with a given algo.  In
1243    contrast to gcry_md_hash_buffer, this function returns an error on
1244    invalid arguments or on other problems; disabled algorithms are
1245    _not_ ignored but flagged as an error.
1246
1247    The data to sign is taken from the array IOV which has IOVCNT items.
1248
1249    The only supported flag in FLAGS is GCRY_MD_FLAG_HMAC which turns
1250    this function into a HMAC function; the first item in IOV is then
1251    used as the key.
1252
1253    On success 0 is returned and resulting hash or HMAC is stored at
1254    DIGEST which must have been provided by the caller with an
1255    appropriate length.  */
1256 gpg_err_code_t
1257 _gcry_md_hash_buffers (int algo, unsigned int flags, void *digest,
1258                        const gcry_buffer_t *iov, int iovcnt)
1259 {
1260   gcry_md_spec_t *spec;
1261   int hmac;
1262
1263   if (!iov || iovcnt < 0)
1264     return GPG_ERR_INV_ARG;
1265   if (flags & ~(GCRY_MD_FLAG_HMAC))
1266     return GPG_ERR_INV_ARG;
1267
1268   hmac = !!(flags & GCRY_MD_FLAG_HMAC);
1269   if (hmac && iovcnt < 1)
1270     return GPG_ERR_INV_ARG;
1271
1272   spec = spec_from_algo (algo);
1273   if (!spec)
1274     {
1275       log_debug ("md_hash_buffers: algorithm %d not available\n", algo);
1276       return GPG_ERR_DIGEST_ALGO;
1277     }
1278
1279   if (algo == GCRY_MD_MD5 && fips_mode ())
1280     {
1281       _gcry_inactivate_fips_mode ("MD5 used");
1282       if (_gcry_enforced_fips_mode () )
1283         {
1284           /* We should never get to here because we do not register
1285              MD5 in enforced fips mode.  */
1286           _gcry_fips_noreturn ();
1287         }
1288     }
1289
1290   if (!hmac && spec->hash_buffers)
1291     {
1292       spec->hash_buffers (digest, iov, iovcnt);
1293     }
1294   else
1295     {
1296       /* For the others we do not have a fast function, so we use the
1297          normal functions.  */
1298       gcry_md_hd_t h;
1299       gpg_err_code_t rc;
1300       int dlen;
1301
1302       /* Detect SHAKE128 like algorithms which we can't use because
1303        * our API does not allow for a variable length digest.  */
1304       dlen = md_digest_length (algo);
1305       if (!dlen)
1306         return GPG_ERR_DIGEST_ALGO;
1307
1308       rc = md_open (&h, algo, (hmac? GCRY_MD_FLAG_HMAC:0));
1309       if (rc)
1310         return rc;
1311
1312       if (hmac)
1313         {
1314           rc = _gcry_md_setkey (h,
1315                                 (const char*)iov[0].data + iov[0].off,
1316                                 iov[0].len);
1317           if (rc)
1318             {
1319               md_close (h);
1320               return rc;
1321             }
1322           iov++; iovcnt--;
1323         }
1324       for (;iovcnt; iov++, iovcnt--)
1325         md_write (h, (const char*)iov[0].data + iov[0].off, iov[0].len);
1326       md_final (h);
1327       memcpy (digest, md_read (h, algo), dlen);
1328       md_close (h);
1329     }
1330
1331   return 0;
1332 }
1333
1334
1335 static int
1336 md_get_algo (gcry_md_hd_t a)
1337 {
1338   GcryDigestEntry *r = a->ctx->list;
1339
1340   if (r && r->next)
1341     {
1342       fips_signal_error ("possible usage error");
1343       log_error ("WARNING: more than one algorithm in md_get_algo()\n");
1344     }
1345   return r ? r->spec->algo : 0;
1346 }
1347
1348
1349 int
1350 _gcry_md_get_algo (gcry_md_hd_t hd)
1351 {
1352   return md_get_algo (hd);
1353 }
1354
1355
1356 /****************
1357  * Return the length of the digest
1358  */
1359 static int
1360 md_digest_length (int algorithm)
1361 {
1362   gcry_md_spec_t *spec;
1363
1364   spec = spec_from_algo (algorithm);
1365   return spec? spec->mdlen : 0;
1366 }
1367
1368
1369 /****************
1370  * Return the length of the digest in bytes.
1371  * This function will return 0 in case of errors.
1372  */
1373 unsigned int
1374 _gcry_md_get_algo_dlen (int algorithm)
1375 {
1376   return md_digest_length (algorithm);
1377 }
1378
1379
1380 /* Hmmm: add a mode to enumerate the OIDs
1381  *      to make g10/sig-check.c more portable */
1382 static const byte *
1383 md_asn_oid (int algorithm, size_t *asnlen, size_t *mdlen)
1384 {
1385   gcry_md_spec_t *spec;
1386   const byte *asnoid = NULL;
1387
1388   spec = spec_from_algo (algorithm);
1389   if (spec)
1390     {
1391       if (asnlen)
1392         *asnlen = spec->asnlen;
1393       if (mdlen)
1394         *mdlen = spec->mdlen;
1395       asnoid = spec->asnoid;
1396     }
1397   else
1398     log_bug ("no ASN.1 OID for md algo %d\n", algorithm);
1399
1400   return asnoid;
1401 }
1402
1403
1404 /****************
1405  * Return information about the given cipher algorithm
1406  * WHAT select the kind of information returned:
1407  *  GCRYCTL_TEST_ALGO:
1408  *      Returns 0 when the specified algorithm is available for use.
1409  *      buffer and nbytes must be zero.
1410  *  GCRYCTL_GET_ASNOID:
1411  *      Return the ASNOID of the algorithm in buffer. if buffer is NULL, only
1412  *      the required length is returned.
1413  *  GCRYCTL_SELFTEST
1414  *      Helper for the regression tests - shall not be used by applications.
1415  *
1416  * Note:  Because this function is in most cases used to return an
1417  * integer value, we can make it easier for the caller to just look at
1418  * the return value.  The caller will in all cases consult the value
1419  * and thereby detecting whether a error occurred or not (i.e. while checking
1420  * the block size)
1421  */
1422 gcry_err_code_t
1423 _gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1424 {
1425   gcry_err_code_t rc;
1426
1427   switch (what)
1428     {
1429     case GCRYCTL_TEST_ALGO:
1430       if (buffer || nbytes)
1431         rc = GPG_ERR_INV_ARG;
1432       else
1433         rc = check_digest_algo (algo);
1434       break;
1435
1436     case GCRYCTL_GET_ASNOID:
1437       /* We need to check that the algo is available because
1438          md_asn_oid would otherwise raise an assertion. */
1439       rc = check_digest_algo (algo);
1440       if (!rc)
1441         {
1442           const char unsigned *asn;
1443           size_t asnlen;
1444
1445           asn = md_asn_oid (algo, &asnlen, NULL);
1446           if (buffer && (*nbytes >= asnlen))
1447             {
1448               memcpy (buffer, asn, asnlen);
1449               *nbytes = asnlen;
1450             }
1451           else if (!buffer && nbytes)
1452             *nbytes = asnlen;
1453           else
1454             {
1455               if (buffer)
1456                 rc = GPG_ERR_TOO_SHORT;
1457               else
1458                 rc = GPG_ERR_INV_ARG;
1459             }
1460         }
1461       break;
1462
1463     case GCRYCTL_SELFTEST:
1464       /* Helper function for the regression tests.  */
1465       rc = gpg_err_code (_gcry_md_selftest (algo, nbytes? (int)*nbytes : 0,
1466                                              NULL));
1467       break;
1468
1469     default:
1470       rc = GPG_ERR_INV_OP;
1471       break;
1472   }
1473
1474   return rc;
1475 }
1476
1477
1478 static void
1479 md_start_debug ( gcry_md_hd_t md, const char *suffix )
1480 {
1481   static int idx=0;
1482   char buf[50];
1483
1484   if (fips_mode ())
1485     return;
1486
1487   if ( md->ctx->debug )
1488     {
1489       log_debug("Oops: md debug already started\n");
1490       return;
1491     }
1492   idx++;
1493   snprintf (buf, DIM(buf)-1, "dbgmd-%05d.%.10s", idx, suffix );
1494   md->ctx->debug = fopen(buf, "w");
1495   if ( !md->ctx->debug )
1496     log_debug("md debug: can't open %s\n", buf );
1497 }
1498
1499
1500 static void
1501 md_stop_debug( gcry_md_hd_t md )
1502 {
1503   if ( md->ctx->debug )
1504     {
1505       if ( md->bufpos )
1506         md_write ( md, NULL, 0 );
1507       fclose (md->ctx->debug);
1508       md->ctx->debug = NULL;
1509     }
1510
1511   {  /* a kludge to pull in the __muldi3 for Solaris */
1512     volatile u32 a = (u32)(uintptr_t)md;
1513     volatile u64 b = 42;
1514     volatile u64 c;
1515     c = a * b;
1516     (void)c;
1517   }
1518 }
1519
1520
1521
1522 /*
1523  * Return information about the digest handle.
1524  *  GCRYCTL_IS_SECURE:
1525  *      Returns 1 when the handle works on secured memory
1526  *      otherwise 0 is returned.  There is no error return.
1527  *  GCRYCTL_IS_ALGO_ENABLED:
1528  *     Returns 1 if the algo is enabled for that handle.
1529  *     The algo must be passed as the address of an int.
1530  */
1531 gcry_err_code_t
1532 _gcry_md_info (gcry_md_hd_t h, int cmd, void *buffer, size_t *nbytes)
1533 {
1534   gcry_err_code_t rc = 0;
1535
1536   switch (cmd)
1537     {
1538     case GCRYCTL_IS_SECURE:
1539       *nbytes = h->ctx->flags.secure;
1540       break;
1541
1542     case GCRYCTL_IS_ALGO_ENABLED:
1543       {
1544         GcryDigestEntry *r;
1545         int algo;
1546
1547         if ( !buffer || !nbytes || *nbytes != sizeof (int))
1548           rc = GPG_ERR_INV_ARG;
1549         else
1550           {
1551             algo = *(int*)buffer;
1552
1553             *nbytes = 0;
1554             for(r=h->ctx->list; r; r = r->next ) {
1555               if (r->spec->algo == algo)
1556                 {
1557                   *nbytes = 1;
1558                   break;
1559                 }
1560             }
1561           }
1562         break;
1563       }
1564
1565   default:
1566     rc = GPG_ERR_INV_OP;
1567   }
1568
1569   return rc;
1570 }
1571
1572
1573 /* Explicitly initialize this module.  */
1574 gcry_err_code_t
1575 _gcry_md_init (void)
1576 {
1577   if (fips_mode())
1578     {
1579       /* disable algorithms that are disallowed in fips */
1580       int idx;
1581       gcry_md_spec_t *spec;
1582
1583       for (idx = 0; (spec = digest_list[idx]); idx++)
1584         if (!spec->flags.fips)
1585           spec->flags.disabled = 1;
1586     }
1587
1588   return 0;
1589 }
1590
1591
1592 int
1593 _gcry_md_is_secure (gcry_md_hd_t a)
1594 {
1595   size_t value;
1596
1597   if (_gcry_md_info (a, GCRYCTL_IS_SECURE, NULL, &value))
1598     value = 1; /* It seems to be better to assume secure memory on
1599                   error. */
1600   return value;
1601 }
1602
1603
1604 int
1605 _gcry_md_is_enabled (gcry_md_hd_t a, int algo)
1606 {
1607   size_t value;
1608
1609   value = sizeof algo;
1610   if (_gcry_md_info (a, GCRYCTL_IS_ALGO_ENABLED, &algo, &value))
1611     value = 0;
1612   return value;
1613 }
1614
1615
1616 /* Run the selftests for digest algorithm ALGO with optional reporting
1617    function REPORT.  */
1618 gpg_error_t
1619 _gcry_md_selftest (int algo, int extended, selftest_report_func_t report)
1620 {
1621   gcry_err_code_t ec = 0;
1622   gcry_md_spec_t *spec;
1623
1624   spec = spec_from_algo (algo);
1625   if (spec && !spec->flags.disabled && spec->selftest)
1626     ec = spec->selftest (algo, extended, report);
1627   else
1628     {
1629       ec = (spec && spec->selftest) ? GPG_ERR_DIGEST_ALGO
1630         /* */                       : GPG_ERR_NOT_IMPLEMENTED;
1631       if (report)
1632         report ("digest", algo, "module",
1633                 (spec && !spec->flags.disabled)?
1634                 "no selftest available" :
1635                 spec? "algorithm disabled" : "algorithm not found");
1636     }
1637
1638   return gpg_error (ec);
1639 }