Add hash_buffer and hash_buffers pointers to message digest spec
[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   gcry_md_spec_t *spec;
1178
1179   spec = spec_from_algo (algo);
1180   if (!spec)
1181     {
1182       log_debug ("md_hash_buffer: algorithm %d not available\n", algo);
1183       return;
1184     }
1185
1186   if (algo == GCRY_MD_MD5 && fips_mode ())
1187     {
1188       _gcry_inactivate_fips_mode ("MD5 used");
1189       if (_gcry_enforced_fips_mode () )
1190         {
1191           /* We should never get to here because we do not register
1192              MD5 in enforced fips mode.  */
1193           _gcry_fips_noreturn ();
1194         }
1195     }
1196
1197   if (spec->hash_buffer != NULL)
1198     {
1199       spec->hash_buffer (digest, buffer, length);
1200     }
1201   else if (spec->hash_buffers != NULL)
1202     {
1203       gcry_buffer_t iov;
1204
1205       iov.size = 0;
1206       iov.data = (void *)buffer;
1207       iov.off = 0;
1208       iov.len = length;
1209
1210       spec->hash_buffers (digest, &iov, 1);
1211     }
1212   else
1213     {
1214       /* For the others we do not have a fast function, so we use the
1215          normal functions. */
1216       gcry_md_hd_t h;
1217       gpg_err_code_t err;
1218
1219       err = md_open (&h, algo, 0);
1220       if (err)
1221         log_bug ("gcry_md_open failed for algo %d: %s",
1222                 algo, gpg_strerror (gcry_error(err)));
1223       md_write (h, (byte *) buffer, length);
1224       md_final (h);
1225       memcpy (digest, md_read (h, algo), md_digest_length (algo));
1226       md_close (h);
1227     }
1228 }
1229
1230
1231 /* Shortcut function to hash multiple buffers with a given algo.  In
1232    contrast to gcry_md_hash_buffer, this function returns an error on
1233    invalid arguments or on other problems; disabled algorithms are
1234    _not_ ignored but flagged as an error.
1235
1236    The data to sign is taken from the array IOV which has IOVCNT items.
1237
1238    The only supported flag in FLAGS is GCRY_MD_FLAG_HMAC which turns
1239    this function into a HMAC function; the first item in IOV is then
1240    used as the key.
1241
1242    On success 0 is returned and resulting hash or HMAC is stored at
1243    DIGEST which must have been provided by the caller with an
1244    appropriate length.  */
1245 gpg_err_code_t
1246 _gcry_md_hash_buffers (int algo, unsigned int flags, void *digest,
1247                        const gcry_buffer_t *iov, int iovcnt)
1248 {
1249   gcry_md_spec_t *spec;
1250   int hmac;
1251
1252   if (!iov || iovcnt < 0)
1253     return GPG_ERR_INV_ARG;
1254   if (flags & ~(GCRY_MD_FLAG_HMAC))
1255     return GPG_ERR_INV_ARG;
1256
1257   hmac = !!(flags & GCRY_MD_FLAG_HMAC);
1258   if (hmac && iovcnt < 1)
1259     return GPG_ERR_INV_ARG;
1260
1261   spec = spec_from_algo (algo);
1262   if (!spec)
1263     {
1264       log_debug ("md_hash_buffers: algorithm %d not available\n", algo);
1265       return GPG_ERR_DIGEST_ALGO;
1266     }
1267
1268   if (algo == GCRY_MD_MD5 && fips_mode ())
1269     {
1270       _gcry_inactivate_fips_mode ("MD5 used");
1271       if (_gcry_enforced_fips_mode () )
1272         {
1273           /* We should never get to here because we do not register
1274              MD5 in enforced fips mode.  */
1275           _gcry_fips_noreturn ();
1276         }
1277     }
1278
1279   if (!hmac && spec->hash_buffers)
1280     {
1281       spec->hash_buffers (digest, iov, iovcnt);
1282     }
1283   else
1284     {
1285       /* For the others we do not have a fast function, so we use the
1286          normal functions.  */
1287       gcry_md_hd_t h;
1288       gpg_err_code_t rc;
1289       int dlen;
1290
1291       /* Detect SHAKE128 like algorithms which we can't use because
1292        * our API does not allow for a variable length digest.  */
1293       dlen = md_digest_length (algo);
1294       if (!dlen)
1295         return GPG_ERR_DIGEST_ALGO;
1296
1297       rc = md_open (&h, algo, (hmac? GCRY_MD_FLAG_HMAC:0));
1298       if (rc)
1299         return rc;
1300
1301       if (hmac)
1302         {
1303           rc = _gcry_md_setkey (h,
1304                                 (const char*)iov[0].data + iov[0].off,
1305                                 iov[0].len);
1306           if (rc)
1307             {
1308               md_close (h);
1309               return rc;
1310             }
1311           iov++; iovcnt--;
1312         }
1313       for (;iovcnt; iov++, iovcnt--)
1314         md_write (h, (const char*)iov[0].data + iov[0].off, iov[0].len);
1315       md_final (h);
1316       memcpy (digest, md_read (h, algo), dlen);
1317       md_close (h);
1318     }
1319
1320   return 0;
1321 }
1322
1323
1324 static int
1325 md_get_algo (gcry_md_hd_t a)
1326 {
1327   GcryDigestEntry *r = a->ctx->list;
1328
1329   if (r && r->next)
1330     {
1331       fips_signal_error ("possible usage error");
1332       log_error ("WARNING: more than one algorithm in md_get_algo()\n");
1333     }
1334   return r ? r->spec->algo : 0;
1335 }
1336
1337
1338 int
1339 _gcry_md_get_algo (gcry_md_hd_t hd)
1340 {
1341   return md_get_algo (hd);
1342 }
1343
1344
1345 /****************
1346  * Return the length of the digest
1347  */
1348 static int
1349 md_digest_length (int algorithm)
1350 {
1351   gcry_md_spec_t *spec;
1352
1353   spec = spec_from_algo (algorithm);
1354   return spec? spec->mdlen : 0;
1355 }
1356
1357
1358 /****************
1359  * Return the length of the digest in bytes.
1360  * This function will return 0 in case of errors.
1361  */
1362 unsigned int
1363 _gcry_md_get_algo_dlen (int algorithm)
1364 {
1365   return md_digest_length (algorithm);
1366 }
1367
1368
1369 /* Hmmm: add a mode to enumerate the OIDs
1370  *      to make g10/sig-check.c more portable */
1371 static const byte *
1372 md_asn_oid (int algorithm, size_t *asnlen, size_t *mdlen)
1373 {
1374   gcry_md_spec_t *spec;
1375   const byte *asnoid = NULL;
1376
1377   spec = spec_from_algo (algorithm);
1378   if (spec)
1379     {
1380       if (asnlen)
1381         *asnlen = spec->asnlen;
1382       if (mdlen)
1383         *mdlen = spec->mdlen;
1384       asnoid = spec->asnoid;
1385     }
1386   else
1387     log_bug ("no ASN.1 OID for md algo %d\n", algorithm);
1388
1389   return asnoid;
1390 }
1391
1392
1393 /****************
1394  * Return information about the given cipher algorithm
1395  * WHAT select the kind of information returned:
1396  *  GCRYCTL_TEST_ALGO:
1397  *      Returns 0 when the specified algorithm is available for use.
1398  *      buffer and nbytes must be zero.
1399  *  GCRYCTL_GET_ASNOID:
1400  *      Return the ASNOID of the algorithm in buffer. if buffer is NULL, only
1401  *      the required length is returned.
1402  *  GCRYCTL_SELFTEST
1403  *      Helper for the regression tests - shall not be used by applications.
1404  *
1405  * Note:  Because this function is in most cases used to return an
1406  * integer value, we can make it easier for the caller to just look at
1407  * the return value.  The caller will in all cases consult the value
1408  * and thereby detecting whether a error occurred or not (i.e. while checking
1409  * the block size)
1410  */
1411 gcry_err_code_t
1412 _gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1413 {
1414   gcry_err_code_t rc;
1415
1416   switch (what)
1417     {
1418     case GCRYCTL_TEST_ALGO:
1419       if (buffer || nbytes)
1420         rc = GPG_ERR_INV_ARG;
1421       else
1422         rc = check_digest_algo (algo);
1423       break;
1424
1425     case GCRYCTL_GET_ASNOID:
1426       /* We need to check that the algo is available because
1427          md_asn_oid would otherwise raise an assertion. */
1428       rc = check_digest_algo (algo);
1429       if (!rc)
1430         {
1431           const char unsigned *asn;
1432           size_t asnlen;
1433
1434           asn = md_asn_oid (algo, &asnlen, NULL);
1435           if (buffer && (*nbytes >= asnlen))
1436             {
1437               memcpy (buffer, asn, asnlen);
1438               *nbytes = asnlen;
1439             }
1440           else if (!buffer && nbytes)
1441             *nbytes = asnlen;
1442           else
1443             {
1444               if (buffer)
1445                 rc = GPG_ERR_TOO_SHORT;
1446               else
1447                 rc = GPG_ERR_INV_ARG;
1448             }
1449         }
1450       break;
1451
1452     case GCRYCTL_SELFTEST:
1453       /* Helper function for the regression tests.  */
1454       rc = gpg_err_code (_gcry_md_selftest (algo, nbytes? (int)*nbytes : 0,
1455                                              NULL));
1456       break;
1457
1458     default:
1459       rc = GPG_ERR_INV_OP;
1460       break;
1461   }
1462
1463   return rc;
1464 }
1465
1466
1467 static void
1468 md_start_debug ( gcry_md_hd_t md, const char *suffix )
1469 {
1470   static int idx=0;
1471   char buf[50];
1472
1473   if (fips_mode ())
1474     return;
1475
1476   if ( md->ctx->debug )
1477     {
1478       log_debug("Oops: md debug already started\n");
1479       return;
1480     }
1481   idx++;
1482   snprintf (buf, DIM(buf)-1, "dbgmd-%05d.%.10s", idx, suffix );
1483   md->ctx->debug = fopen(buf, "w");
1484   if ( !md->ctx->debug )
1485     log_debug("md debug: can't open %s\n", buf );
1486 }
1487
1488
1489 static void
1490 md_stop_debug( gcry_md_hd_t md )
1491 {
1492   if ( md->ctx->debug )
1493     {
1494       if ( md->bufpos )
1495         md_write ( md, NULL, 0 );
1496       fclose (md->ctx->debug);
1497       md->ctx->debug = NULL;
1498     }
1499
1500   {  /* a kludge to pull in the __muldi3 for Solaris */
1501     volatile u32 a = (u32)(uintptr_t)md;
1502     volatile u64 b = 42;
1503     volatile u64 c;
1504     c = a * b;
1505     (void)c;
1506   }
1507 }
1508
1509
1510
1511 /*
1512  * Return information about the digest handle.
1513  *  GCRYCTL_IS_SECURE:
1514  *      Returns 1 when the handle works on secured memory
1515  *      otherwise 0 is returned.  There is no error return.
1516  *  GCRYCTL_IS_ALGO_ENABLED:
1517  *     Returns 1 if the algo is enabled for that handle.
1518  *     The algo must be passed as the address of an int.
1519  */
1520 gcry_err_code_t
1521 _gcry_md_info (gcry_md_hd_t h, int cmd, void *buffer, size_t *nbytes)
1522 {
1523   gcry_err_code_t rc = 0;
1524
1525   switch (cmd)
1526     {
1527     case GCRYCTL_IS_SECURE:
1528       *nbytes = h->ctx->flags.secure;
1529       break;
1530
1531     case GCRYCTL_IS_ALGO_ENABLED:
1532       {
1533         GcryDigestEntry *r;
1534         int algo;
1535
1536         if ( !buffer || !nbytes || *nbytes != sizeof (int))
1537           rc = GPG_ERR_INV_ARG;
1538         else
1539           {
1540             algo = *(int*)buffer;
1541
1542             *nbytes = 0;
1543             for(r=h->ctx->list; r; r = r->next ) {
1544               if (r->spec->algo == algo)
1545                 {
1546                   *nbytes = 1;
1547                   break;
1548                 }
1549             }
1550           }
1551         break;
1552       }
1553
1554   default:
1555     rc = GPG_ERR_INV_OP;
1556   }
1557
1558   return rc;
1559 }
1560
1561
1562 /* Explicitly initialize this module.  */
1563 gcry_err_code_t
1564 _gcry_md_init (void)
1565 {
1566   if (fips_mode())
1567     {
1568       /* disable algorithms that are disallowed in fips */
1569       int idx;
1570       gcry_md_spec_t *spec;
1571
1572       for (idx = 0; (spec = digest_list[idx]); idx++)
1573         if (!spec->flags.fips)
1574           spec->flags.disabled = 1;
1575     }
1576
1577   return 0;
1578 }
1579
1580
1581 int
1582 _gcry_md_is_secure (gcry_md_hd_t a)
1583 {
1584   size_t value;
1585
1586   if (_gcry_md_info (a, GCRYCTL_IS_SECURE, NULL, &value))
1587     value = 1; /* It seems to be better to assume secure memory on
1588                   error. */
1589   return value;
1590 }
1591
1592
1593 int
1594 _gcry_md_is_enabled (gcry_md_hd_t a, int algo)
1595 {
1596   size_t value;
1597
1598   value = sizeof algo;
1599   if (_gcry_md_info (a, GCRYCTL_IS_ALGO_ENABLED, &algo, &value))
1600     value = 0;
1601   return value;
1602 }
1603
1604
1605 /* Run the selftests for digest algorithm ALGO with optional reporting
1606    function REPORT.  */
1607 gpg_error_t
1608 _gcry_md_selftest (int algo, int extended, selftest_report_func_t report)
1609 {
1610   gcry_err_code_t ec = 0;
1611   gcry_md_spec_t *spec;
1612
1613   spec = spec_from_algo (algo);
1614   if (spec && !spec->flags.disabled && spec->selftest)
1615     ec = spec->selftest (algo, extended, report);
1616   else
1617     {
1618       ec = (spec && spec->selftest) ? GPG_ERR_DIGEST_ALGO
1619         /* */                       : GPG_ERR_NOT_IMPLEMENTED;
1620       if (report)
1621         report ("digest", algo, "module",
1622                 (spec && !spec->flags.disabled)?
1623                 "no selftest available" :
1624                 spec? "algorithm disabled" : "algorithm not found");
1625     }
1626
1627   return gpg_error (ec);
1628 }