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