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