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