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