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