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