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