md: Simplify the message digest dispatcher md.c.
[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   switch (cmd)
721     {
722     case GCRYCTL_FINALIZE:
723       md_final (hd);
724       break;
725     case GCRYCTL_SET_KEY:
726       rc = gcry_err_code (gcry_md_setkey (hd, buffer, buflen));
727       break;
728     case GCRYCTL_START_DUMP:
729       md_start_debug (hd, buffer);
730       break;
731     case GCRYCTL_STOP_DUMP:
732       md_stop_debug ( hd );
733       break;
734     default:
735       rc = GPG_ERR_INV_OP;
736     }
737   return gcry_error (rc);
738 }
739
740
741 gcry_error_t
742 gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
743 {
744   gcry_err_code_t rc;
745
746   if (!hd->ctx->macpads)
747     rc = GPG_ERR_CONFLICT;
748   else
749     {
750       rc = prepare_macpads (hd, key, keylen);
751       if (! rc)
752         gcry_md_reset (hd);
753     }
754
755   return gcry_error (rc);
756 }
757
758
759 /* The new debug interface.  If SUFFIX is a string it creates an debug
760    file for the context HD.  IF suffix is NULL, the file is closed and
761    debugging is stopped.  */
762 void
763 gcry_md_debug (gcry_md_hd_t hd, const char *suffix)
764 {
765   if (suffix)
766     md_start_debug (hd, suffix);
767   else
768     md_stop_debug (hd);
769 }
770
771
772 /****************
773  * If ALGO is null get the digest for the used algo (which should be
774  * only one)
775  */
776 static byte *
777 md_read( gcry_md_hd_t a, int algo )
778 {
779   GcryDigestEntry *r = a->ctx->list;
780
781   if (! algo)
782     {
783       /* Return the first algorithm */
784       if (r)
785         {
786           if (r->next)
787             log_debug ("more than one algorithm in md_read(0)\n");
788           return r->spec->read (&r->context.c);
789         }
790     }
791   else
792     {
793       for (r = a->ctx->list; r; r = r->next)
794         if (r->spec->algo == algo)
795           return r->spec->read (&r->context.c);
796     }
797   BUG();
798   return NULL;
799 }
800
801
802 /*
803  * Read out the complete digest, this function implictly finalizes
804  * the hash.
805  */
806 byte *
807 gcry_md_read (gcry_md_hd_t hd, int algo)
808 {
809   /* This function is expected to always return a digest, thus we
810      can't return an error which we actually should do in
811      non-operational state.  */
812   gcry_md_ctl (hd, GCRYCTL_FINALIZE, NULL, 0);
813   return md_read (hd, algo);
814 }
815
816
817 /*
818  * Read out an intermediate digest.  Not yet functional.
819  */
820 gcry_err_code_t
821 gcry_md_get (gcry_md_hd_t hd, int algo, byte *buffer, int buflen)
822 {
823   (void)hd;
824   (void)algo;
825   (void)buffer;
826   (void)buflen;
827
828   /*md_digest ... */
829   fips_signal_error ("unimplemented function called");
830   return GPG_ERR_INTERNAL;
831 }
832
833
834 /*
835  * Shortcut function to hash a buffer with a given algo. The only
836  * guaranteed supported algorithms are RIPE-MD160 and SHA-1. The
837  * supplied digest buffer must be large enough to store the resulting
838  * hash.  No error is returned, the function will abort on an invalid
839  * algo.  DISABLED_ALGOS are ignored here.  */
840 void
841 gcry_md_hash_buffer (int algo, void *digest,
842                      const void *buffer, size_t length)
843 {
844   if (algo == GCRY_MD_SHA1)
845     _gcry_sha1_hash_buffer (digest, buffer, length);
846   else if (algo == GCRY_MD_RMD160 && !fips_mode () )
847     _gcry_rmd160_hash_buffer (digest, buffer, length);
848   else
849     {
850       /* For the others we do not have a fast function, so we use the
851          normal functions. */
852       gcry_md_hd_t h;
853       gpg_err_code_t err;
854
855       if (algo == GCRY_MD_MD5 && fips_mode ())
856         {
857           _gcry_inactivate_fips_mode ("MD5 used");
858           if (_gcry_enforced_fips_mode () )
859             {
860               /* We should never get to here because we do not register
861                  MD5 in enforced fips mode.  */
862               _gcry_fips_noreturn ();
863             }
864         }
865
866       err = md_open (&h, algo, 0, 0);
867       if (err)
868         log_bug ("gcry_md_open failed for algo %d: %s",
869                  algo, gpg_strerror (gcry_error(err)));
870       md_write (h, (byte *) buffer, length);
871       md_final (h);
872       memcpy (digest, md_read (h, algo), md_digest_length (algo));
873       md_close (h);
874     }
875 }
876
877
878 /* Shortcut function to hash multiple buffers with a given algo.  In
879    contrast to gcry_md_hash_buffer, this function returns an error on
880    invalid arguments or on other problems; disabled algorithms are
881    _not_ ignored but flagged as an error.
882
883    The data to sign is taken from the array IOV which has IOVCNT items.
884
885    The only supported flag in FLAGS is GCRY_MD_FLAG_HMAC which turns
886    this function into a HMAC function; the first item in IOV is then
887    used as the key.
888
889    On success 0 is returned and resulting hash or HMAC is stored at
890    DIGEST which must have been provided by the caller with an
891    appropriate length.  */
892 gpg_err_code_t
893 gcry_md_hash_buffers (int algo, unsigned int flags, void *digest,
894                       const gcry_buffer_t *iov, int iovcnt)
895 {
896   int hmac;
897
898   if (!iov || iovcnt < 0)
899     return GPG_ERR_INV_ARG;
900   if (flags & ~(GCRY_MD_FLAG_HMAC))
901     return GPG_ERR_INV_ARG;
902
903   hmac = !!(flags & GCRY_MD_FLAG_HMAC);
904   if (hmac && iovcnt < 1)
905     return GPG_ERR_INV_ARG;
906
907   if (algo == GCRY_MD_SHA1 && !hmac)
908     _gcry_sha1_hash_buffers (digest, iov, iovcnt);
909   else
910     {
911       /* For the others we do not have a fast function, so we use the
912          normal functions. */
913       gcry_md_hd_t h;
914       gpg_err_code_t rc;
915
916       if (algo == GCRY_MD_MD5 && fips_mode ())
917         {
918           _gcry_inactivate_fips_mode ("MD5 used");
919           if (_gcry_enforced_fips_mode () )
920             {
921               /* We should never get to here because we do not register
922                  MD5 in enforced fips mode.  */
923               _gcry_fips_noreturn ();
924             }
925         }
926
927       rc = md_open (&h, algo, 0, hmac);
928       if (rc)
929         return rc;
930
931       if (hmac)
932         {
933           rc = gcry_err_code
934             (gcry_md_setkey (h, (const char*)iov[0].data + iov[0].off,
935                              iov[0].len));
936           if (rc)
937             {
938               md_close (h);
939               return rc;
940             }
941           iov++; iovcnt--;
942         }
943       for (;iovcnt; iov++, iovcnt--)
944         md_write (h, (const char*)iov[0].data + iov[0].off, iov[0].len);
945       md_final (h);
946       memcpy (digest, md_read (h, algo), md_digest_length (algo));
947       md_close (h);
948     }
949
950   return 0;
951 }
952
953
954 static int
955 md_get_algo (gcry_md_hd_t a)
956 {
957   GcryDigestEntry *r = a->ctx->list;
958
959   if (r && r->next)
960     {
961       fips_signal_error ("possible usage error");
962       log_error ("WARNING: more than one algorithm in md_get_algo()\n");
963     }
964   return r ? r->spec->algo : 0;
965 }
966
967
968 int
969 gcry_md_get_algo (gcry_md_hd_t hd)
970 {
971   return md_get_algo (hd);
972 }
973
974
975 /****************
976  * Return the length of the digest
977  */
978 static int
979 md_digest_length (int algorithm)
980 {
981   gcry_md_spec_t *spec;
982
983   spec = spec_from_algo (algorithm);
984   return spec? spec->mdlen : 0;
985 }
986
987
988 /****************
989  * Return the length of the digest in bytes.
990  * This function will return 0 in case of errors.
991  */
992 unsigned int
993 gcry_md_get_algo_dlen (int algorithm)
994 {
995   return md_digest_length (algorithm);
996 }
997
998
999 /* Hmmm: add a mode to enumerate the OIDs
1000  *      to make g10/sig-check.c more portable */
1001 static const byte *
1002 md_asn_oid (int algorithm, size_t *asnlen, size_t *mdlen)
1003 {
1004   gcry_md_spec_t *spec;
1005   const byte *asnoid = NULL;
1006
1007   spec = spec_from_algo (algorithm);
1008   if (spec)
1009     {
1010       if (asnlen)
1011         *asnlen = spec->asnlen;
1012       if (mdlen)
1013         *mdlen = spec->mdlen;
1014       asnoid = spec->asnoid;
1015     }
1016   else
1017     log_bug ("no ASN.1 OID for md algo %d\n", algorithm);
1018
1019   return asnoid;
1020 }
1021
1022
1023 /****************
1024  * Return information about the given cipher algorithm
1025  * WHAT select the kind of information returned:
1026  *  GCRYCTL_TEST_ALGO:
1027  *      Returns 0 when the specified algorithm is available for use.
1028  *      buffer and nbytes must be zero.
1029  *  GCRYCTL_GET_ASNOID:
1030  *      Return the ASNOID of the algorithm in buffer. if buffer is NULL, only
1031  *      the required length is returned.
1032  *
1033  * Note:  Because this function is in most cases used to return an
1034  * integer value, we can make it easier for the caller to just look at
1035  * the return value.  The caller will in all cases consult the value
1036  * and thereby detecting whether a error occurred or not (i.e. while checking
1037  * the block size)
1038  */
1039 gcry_error_t
1040 gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1041 {
1042   gcry_err_code_t err;
1043
1044   switch (what)
1045     {
1046     case GCRYCTL_TEST_ALGO:
1047       if (buffer || nbytes)
1048         err = GPG_ERR_INV_ARG;
1049       else
1050         err = check_digest_algo (algo);
1051       break;
1052
1053     case GCRYCTL_GET_ASNOID:
1054       /* We need to check that the algo is available because
1055          md_asn_oid would otherwise raise an assertion. */
1056       err = check_digest_algo (algo);
1057       if (!err)
1058         {
1059           const char unsigned *asn;
1060           size_t asnlen;
1061
1062           asn = md_asn_oid (algo, &asnlen, NULL);
1063           if (buffer && (*nbytes >= asnlen))
1064             {
1065               memcpy (buffer, asn, asnlen);
1066               *nbytes = asnlen;
1067             }
1068           else if (!buffer && nbytes)
1069             *nbytes = asnlen;
1070           else
1071             {
1072               if (buffer)
1073                 err = GPG_ERR_TOO_SHORT;
1074               else
1075                 err = GPG_ERR_INV_ARG;
1076             }
1077         }
1078       break;
1079
1080     default:
1081       err = GPG_ERR_INV_OP;
1082       break;
1083   }
1084
1085   return gcry_error (err);
1086 }
1087
1088
1089 static void
1090 md_start_debug ( gcry_md_hd_t md, const char *suffix )
1091 {
1092   static int idx=0;
1093   char buf[50];
1094
1095   if (fips_mode ())
1096     return;
1097
1098   if ( md->ctx->debug )
1099     {
1100       log_debug("Oops: md debug already started\n");
1101       return;
1102     }
1103   idx++;
1104   snprintf (buf, DIM(buf)-1, "dbgmd-%05d.%.10s", idx, suffix );
1105   md->ctx->debug = fopen(buf, "w");
1106   if ( !md->ctx->debug )
1107     log_debug("md debug: can't open %s\n", buf );
1108 }
1109
1110
1111 static void
1112 md_stop_debug( gcry_md_hd_t md )
1113 {
1114   if ( md->ctx->debug )
1115     {
1116       if ( md->bufpos )
1117         md_write ( md, NULL, 0 );
1118       fclose (md->ctx->debug);
1119       md->ctx->debug = NULL;
1120     }
1121
1122 #ifdef HAVE_U64_TYPEDEF
1123   {  /* a kludge to pull in the __muldi3 for Solaris */
1124     volatile u32 a = (u32)(ulong)md;
1125     volatile u64 b = 42;
1126     volatile u64 c;
1127     c = a * b;
1128     (void)c;
1129   }
1130 #endif
1131 }
1132
1133
1134
1135 /*
1136  * Return information about the digest handle.
1137  *  GCRYCTL_IS_SECURE:
1138  *      Returns 1 when the handle works on secured memory
1139  *      otherwise 0 is returned.  There is no error return.
1140  *  GCRYCTL_IS_ALGO_ENABLED:
1141  *     Returns 1 if the algo is enabled for that handle.
1142  *     The algo must be passed as the address of an int.
1143  */
1144 gcry_error_t
1145 gcry_md_info (gcry_md_hd_t h, int cmd, void *buffer, size_t *nbytes)
1146 {
1147   gcry_err_code_t err = 0;
1148
1149   switch (cmd)
1150     {
1151     case GCRYCTL_IS_SECURE:
1152       *nbytes = h->ctx->secure;
1153       break;
1154
1155     case GCRYCTL_IS_ALGO_ENABLED:
1156       {
1157         GcryDigestEntry *r;
1158         int algo;
1159
1160         if ( !buffer || (nbytes && (*nbytes != sizeof (int))))
1161           err = GPG_ERR_INV_ARG;
1162         else
1163           {
1164             algo = *(int*)buffer;
1165
1166             *nbytes = 0;
1167             for(r=h->ctx->list; r; r = r->next ) {
1168               if (r->spec->algo == algo)
1169                 {
1170                   *nbytes = 1;
1171                   break;
1172                 }
1173             }
1174           }
1175         break;
1176       }
1177
1178   default:
1179     err = GPG_ERR_INV_OP;
1180   }
1181
1182   return gcry_error (err);
1183 }
1184
1185
1186 /* Explicitly initialize this module.  */
1187 gcry_err_code_t
1188 _gcry_md_init (void)
1189 {
1190   return 0;
1191 }
1192
1193
1194 int
1195 gcry_md_is_secure (gcry_md_hd_t a)
1196 {
1197   size_t value;
1198
1199   if (gcry_md_info (a, GCRYCTL_IS_SECURE, NULL, &value))
1200     value = 1; /* It seems to be better to assume secure memory on
1201                   error. */
1202   return value;
1203 }
1204
1205
1206 int
1207 gcry_md_is_enabled (gcry_md_hd_t a, int algo)
1208 {
1209   size_t value;
1210
1211   value = sizeof algo;
1212   if (gcry_md_info (a, GCRYCTL_IS_ALGO_ENABLED, &algo, &value))
1213     value = 0;
1214   return value;
1215 }
1216
1217
1218 /* Run the selftests for digest algorithm ALGO with optional reporting
1219    function REPORT.  */
1220 gpg_error_t
1221 _gcry_md_selftest (int algo, int extended, selftest_report_func_t report)
1222 {
1223   gcry_err_code_t ec = 0;
1224   gcry_md_spec_t *spec;
1225
1226   spec = spec_from_algo (algo);
1227   if (spec && !spec->flags.disabled && spec->selftest)
1228     ec = spec->selftest (algo, extended, report);
1229   else
1230     {
1231       ec = GPG_ERR_DIGEST_ALGO;
1232       if (report)
1233         report ("digest", algo, "module",
1234                 (spec && !spec->flags.disabled)?
1235                 "no selftest available" :
1236                 spec? "algorithm disabled" : "algorithm not found");
1237     }
1238
1239   return gpg_error (ec);
1240 }