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