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