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