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