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