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