Replace assert calls by a new gcry_assert at most places.
[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 },
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 () && !digest_table[i].fips_allowed )
180         continue;
181
182       err = _gcry_module_add (&digests_registered,
183                               digest_table[i].algorithm,
184                               (void *) digest_table[i].digest,
185                               (void *) digest_table[i].extraspec,
186                               NULL);
187     }
188
189   if (err)
190     BUG ();
191 }
192
193 /* Internal callback function.  */
194 static int
195 gcry_md_lookup_func_name (void *spec, void *data)
196 {
197   gcry_md_spec_t *digest = (gcry_md_spec_t *) spec;
198   char *name = (char *) data;
199
200   return (! stricmp (digest->name, name));
201 }
202
203 /* Internal callback function.  Used via _gcry_module_lookup.  */
204 static int
205 gcry_md_lookup_func_oid (void *spec, void *data)
206 {
207   gcry_md_spec_t *digest = (gcry_md_spec_t *) spec;
208   char *oid = (char *) data;
209   gcry_md_oid_spec_t *oid_specs = digest->oids;
210   int ret = 0, i;
211
212   if (oid_specs)
213     {
214       for (i = 0; oid_specs[i].oidstring && (! ret); i++)
215         if (! stricmp (oid, oid_specs[i].oidstring))
216           ret = 1;
217     }
218
219   return ret;
220 }
221
222 /* Internal function.  Lookup a digest entry by it's name.  */
223 static gcry_module_t 
224 gcry_md_lookup_name (const char *name)
225 {
226   gcry_module_t digest;
227
228   digest = _gcry_module_lookup (digests_registered, (void *) name,
229                                 gcry_md_lookup_func_name);
230
231   return digest;
232 }
233
234 /* Internal function.  Lookup a cipher entry by it's oid.  */
235 static gcry_module_t
236 gcry_md_lookup_oid (const char *oid)
237 {
238   gcry_module_t digest;
239
240   digest = _gcry_module_lookup (digests_registered, (void *) oid,
241                                 gcry_md_lookup_func_oid);
242
243   return digest;
244 }
245
246 /* Register a new digest module whose specification can be found in
247    DIGEST.  On success, a new algorithm ID is stored in ALGORITHM_ID
248    and a pointer representhing this module is stored in MODULE.  */
249 gcry_error_t
250 _gcry_md_register (gcry_md_spec_t *digest,
251                    md_extra_spec_t *extraspec,
252                    unsigned int *algorithm_id,
253                    gcry_module_t *module)
254 {
255   gcry_err_code_t err = 0;
256   gcry_module_t mod;
257
258   /* We do not support module loading in fips mode.  */
259   if (fips_mode ())
260     return gpg_error (GPG_ERR_NOT_SUPPORTED);
261
262   ath_mutex_lock (&digests_registered_lock);
263   err = _gcry_module_add (&digests_registered, 0,
264                           (void *) digest, 
265                           (void *)(extraspec? extraspec : &dummy_extra_spec), 
266                           &mod);
267   ath_mutex_unlock (&digests_registered_lock);
268   
269   if (! err)
270     {
271       *module = mod;
272       *algorithm_id = mod->mod_id;
273     }
274
275   return gcry_error (err);
276 }
277
278 /* Unregister the digest identified by ID, which must have been
279    registered with gcry_digest_register.  */
280 void
281 gcry_md_unregister (gcry_module_t module)
282 {
283   ath_mutex_lock (&digests_registered_lock);
284   _gcry_module_release (module);
285   ath_mutex_unlock (&digests_registered_lock);
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           if ( (GCRY_MD_SHA384 == algo) || (GCRY_MD_SHA512 == algo) ) {
472             ctx->macpads_Bsize = 128;
473             ctx->macpads = gcry_malloc_secure (2*(ctx->macpads_Bsize));
474           } else {
475             ctx->macpads_Bsize = 64;
476             ctx->macpads = gcry_malloc_secure (2*(ctx->macpads_Bsize));
477           }
478           if (! ctx->macpads)
479             {
480               err = gpg_err_code_from_errno (errno);
481               md_close (hd);
482             }
483         }
484     }
485
486   if (! err)
487     {
488       /* Hmmm, should we really do that? - yes [-wk] */
489       _gcry_fast_random_poll ();
490
491       if (algo)
492         {
493           err = md_enable (hd, algo);
494           if (err)
495             md_close (hd);
496         }
497     }
498
499   if (! err)
500     *h = hd;
501
502   return err;
503 }
504
505 /* Create a message digest object for algorithm ALGO.  FLAGS may be
506    given as an bitwise OR of the gcry_md_flags values.  ALGO may be
507    given as 0 if the algorithms to be used are later set using
508    gcry_md_enable. H is guaranteed to be a valid handle or NULL on
509    error.  */
510 gcry_error_t
511 gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
512 {
513   gcry_err_code_t err = GPG_ERR_NO_ERROR;
514   gcry_md_hd_t hd;
515
516   if ((flags & ~(GCRY_MD_FLAG_SECURE | GCRY_MD_FLAG_HMAC)))
517     err = GPG_ERR_INV_ARG;
518   else
519     {
520       err = md_open (&hd, algo, (flags & GCRY_MD_FLAG_SECURE),
521                      (flags & GCRY_MD_FLAG_HMAC));
522     }
523
524   *h = err? NULL : hd;
525   return gcry_error (err);
526 }
527
528
529
530 static gcry_err_code_t
531 md_enable (gcry_md_hd_t hd, int algorithm)
532 {
533   struct gcry_md_context *h = hd->ctx;
534   gcry_md_spec_t *digest = NULL;
535   GcryDigestEntry *entry;
536   gcry_module_t module;
537   gcry_err_code_t err = 0;
538
539   for (entry = h->list; entry; entry = entry->next)
540     if (entry->module->mod_id == algorithm)
541       return err; /* already enabled */
542
543   REGISTER_DEFAULT_DIGESTS;
544
545   ath_mutex_lock (&digests_registered_lock);
546   module = _gcry_module_lookup_id (digests_registered, algorithm);
547   ath_mutex_unlock (&digests_registered_lock);
548   if (! module)
549     {
550       log_debug ("md_enable: algorithm %d not available\n", algorithm);
551       err = GPG_ERR_DIGEST_ALGO;
552     }
553   else
554     digest = (gcry_md_spec_t *) module->spec;
555
556   if (! err)
557     {
558       size_t size = (sizeof (*entry)
559                      + digest->contextsize
560                      - sizeof (entry->context));
561
562       /* And allocate a new list entry. */
563       if (h->secure)
564         entry = gcry_malloc_secure (size);
565       else
566         entry = gcry_malloc (size);
567
568       if (! entry)
569         err = gpg_err_code_from_errno (errno);
570       else
571         {
572           entry->digest = digest;
573           entry->module = module;
574           entry->next = h->list;
575           entry->actual_struct_size = size;
576           h->list = entry;
577
578           /* And init this instance. */
579           entry->digest->init (&entry->context.c);
580         }
581     }
582
583   if (err)
584     {
585       if (module)
586         {
587            ath_mutex_lock (&digests_registered_lock);
588            _gcry_module_release (module);
589            ath_mutex_unlock (&digests_registered_lock);
590         }
591     }
592
593   return err;
594 }
595
596
597 gcry_error_t
598 gcry_md_enable (gcry_md_hd_t hd, int algorithm)
599 {
600   return gcry_error (md_enable (hd, algorithm));
601 }
602
603 static gcry_err_code_t
604 md_copy (gcry_md_hd_t ahd, gcry_md_hd_t *b_hd)
605 {
606   gcry_err_code_t err = GPG_ERR_NO_ERROR;
607   struct gcry_md_context *a = ahd->ctx;
608   struct gcry_md_context *b;
609   GcryDigestEntry *ar, *br;
610   gcry_md_hd_t bhd;
611   size_t n;
612   
613   if (ahd->bufpos)
614     md_write (ahd, NULL, 0);
615
616   n = (char *) ahd->ctx - (char *) ahd;
617   if (a->secure)
618     bhd = gcry_malloc_secure (n + sizeof (struct gcry_md_context));
619   else
620     bhd = gcry_malloc (n + sizeof (struct gcry_md_context));
621
622   if (! bhd)
623     err = gpg_err_code_from_errno (errno);
624
625   if (! err)
626     {
627       bhd->ctx = b = (struct gcry_md_context *) ((char *) bhd + n);
628       /* No need to copy the buffer due to the write above. */
629       gcry_assert (ahd->bufsize == (n - sizeof (struct gcry_md_handle) + 1));
630       bhd->bufsize = ahd->bufsize;
631       bhd->bufpos = 0;
632       gcry_assert (! ahd->bufpos);
633       memcpy (b, a, sizeof *a);
634       b->list = NULL;
635       b->debug = NULL;
636       if (a->macpads)
637         {
638           b->macpads = gcry_malloc_secure (2*(a->macpads_Bsize));
639           if (! b->macpads)
640             {
641               err = gpg_err_code_from_errno (errno);
642               md_close (bhd);
643             }
644           else
645             memcpy (b->macpads, a->macpads, (2*(a->macpads_Bsize)));
646         }
647     }
648
649   /* Copy the complete list of algorithms.  The copied list is
650      reversed, but that doesn't matter. */
651   if (!err)
652     {
653       for (ar = a->list; ar; ar = ar->next)
654         {
655           if (a->secure)
656             br = gcry_malloc_secure (sizeof *br
657                                      + ar->digest->contextsize
658                                      - sizeof(ar->context));
659           else
660             br = gcry_malloc (sizeof *br
661                               + ar->digest->contextsize
662                               - sizeof (ar->context));
663           if (!br)
664             {
665               err = gpg_err_code_from_errno (errno);
666               md_close (bhd);
667               break;
668             }
669
670           memcpy (br, ar, (sizeof (*br) + ar->digest->contextsize
671                            - sizeof (ar->context)));
672           br->next = b->list;
673           b->list = br;
674           
675           /* Add a reference to the module.  */
676           ath_mutex_lock (&digests_registered_lock);
677           _gcry_module_use (br->module);
678           ath_mutex_unlock (&digests_registered_lock);
679         }
680     }
681
682   if (a->debug && !err)
683     md_start_debug (bhd, "unknown");
684
685   if (!err)
686     *b_hd = bhd;
687
688   return err;
689 }
690
691 gcry_error_t
692 gcry_md_copy (gcry_md_hd_t *handle, gcry_md_hd_t hd)
693 {
694   gcry_err_code_t err;
695
696   err = md_copy (hd, handle);
697   if (err)
698     *handle = NULL;
699   return gcry_error (err);
700 }
701
702 /*
703  * Reset all contexts and discard any buffered stuff.  This may be used
704  * instead of a md_close(); md_open().
705  */
706 void
707 gcry_md_reset (gcry_md_hd_t a)
708 {
709   GcryDigestEntry *r;
710
711   /* Note: We allow this even in fips non operational mode.  */
712
713   a->bufpos = a->ctx->finalized = 0;
714
715   for (r = a->ctx->list; r; r = r->next)
716     {
717       memset (r->context.c, 0, r->digest->contextsize);
718       (*r->digest->init) (&r->context.c);
719     }
720   if (a->ctx->macpads)
721     md_write (a, a->ctx->macpads, a->ctx->macpads_Bsize); /* inner pad */
722 }
723
724 static void
725 md_close (gcry_md_hd_t a)
726 {
727   GcryDigestEntry *r, *r2;
728
729   if (! a)
730     return;
731   if (a->ctx->debug)
732     md_stop_debug (a);
733   for (r = a->ctx->list; r; r = r2)
734     {
735       r2 = r->next;
736       ath_mutex_lock (&digests_registered_lock);
737       _gcry_module_release (r->module);
738       ath_mutex_unlock (&digests_registered_lock);
739       wipememory (r, r->actual_struct_size);
740       gcry_free (r);
741     }
742
743   if (a->ctx->macpads)
744     {
745       wipememory (a->ctx->macpads, 2*(a->ctx->macpads_Bsize));
746       gcry_free(a->ctx->macpads);
747     }
748
749   wipememory (a, a->ctx->actual_handle_size);
750   gcry_free(a);
751 }
752
753 void
754 gcry_md_close (gcry_md_hd_t hd)
755 {
756   /* Note: We allow this even in fips non operational mode.  */
757   md_close (hd);
758 }
759
760 static void
761 md_write (gcry_md_hd_t a, const void *inbuf, size_t inlen)
762 {
763   GcryDigestEntry *r;
764   
765   if (a->ctx->debug)
766     {
767       if (a->bufpos && fwrite (a->buf, a->bufpos, 1, a->ctx->debug) != 1)
768         BUG();
769       if (inlen && fwrite (inbuf, inlen, 1, a->ctx->debug) != 1)
770         BUG();
771     }
772
773   for (r = a->ctx->list; r; r = r->next)
774     {
775       if (a->bufpos)
776         (*r->digest->write) (&r->context.c, a->buf, a->bufpos);
777       (*r->digest->write) (&r->context.c, inbuf, inlen);
778     }
779   a->bufpos = 0;
780 }
781
782 void
783 gcry_md_write (gcry_md_hd_t hd, const void *inbuf, size_t inlen)
784 {
785   md_write (hd, inbuf, inlen);
786 }
787
788 static void
789 md_final (gcry_md_hd_t a)
790 {
791   GcryDigestEntry *r;
792
793   if (a->ctx->finalized)
794     return;
795
796   if (a->bufpos)
797     md_write (a, NULL, 0);
798
799   for (r = a->ctx->list; r; r = r->next)
800     (*r->digest->final) (&r->context.c);
801
802   a->ctx->finalized = 1;
803
804   if (a->ctx->macpads)
805     {
806       /* Finish the hmac. */
807       int algo = md_get_algo (a);
808       byte *p = md_read (a, algo);
809       size_t dlen = md_digest_length (algo);
810       gcry_md_hd_t om;
811       gcry_err_code_t err = md_open (&om, algo, a->ctx->secure, 0);
812
813       if (err)
814         _gcry_fatal_error (err, NULL);
815       md_write (om, 
816                 (a->ctx->macpads)+(a->ctx->macpads_Bsize), 
817                 a->ctx->macpads_Bsize);
818       md_write (om, p, dlen);
819       md_final (om);
820       /* Replace our digest with the mac (they have the same size). */
821       memcpy (p, md_read (om, algo), dlen);
822       md_close (om);
823     }
824 }
825
826 static gcry_err_code_t
827 prepare_macpads( gcry_md_hd_t hd, const byte *key, size_t keylen)
828 {
829   int i;
830   int algo = md_get_algo( hd );
831   byte *helpkey = NULL;
832   byte *ipad, *opad;
833
834   if ( !algo )
835     return GPG_ERR_DIGEST_ALGO; /* i.e. no algo enabled */
836
837   if ( keylen > 64 ) 
838     {
839       helpkey = gcry_malloc_secure ( md_digest_length( algo ) );
840       if ( !helpkey )
841         return gpg_err_code_from_errno (errno);
842       gcry_md_hash_buffer ( algo, helpkey, key, keylen );
843       key = helpkey;
844       keylen = md_digest_length( algo );
845       gcry_assert ( keylen <= 64 );
846     }
847
848   memset ( hd->ctx->macpads, 0, 2*(hd->ctx->macpads_Bsize) );
849   ipad = hd->ctx->macpads;
850   opad = (hd->ctx->macpads)+(hd->ctx->macpads_Bsize);
851   memcpy ( ipad, key, keylen );
852   memcpy ( opad, key, keylen );
853   for (i=0; i < (hd->ctx->macpads_Bsize); i++ ) 
854     {
855       ipad[i] ^= 0x36;
856       opad[i] ^= 0x5c;
857     }
858   gcry_free( helpkey );
859
860   return GPG_ERR_NO_ERROR;
861 }
862
863 gcry_error_t
864 gcry_md_ctl (gcry_md_hd_t hd, int cmd, void *buffer, size_t buflen)
865 {
866   gcry_err_code_t rc = 0;
867   
868   switch (cmd)
869     {
870     case GCRYCTL_FINALIZE:
871       md_final (hd);
872       break;
873     case GCRYCTL_SET_KEY:
874       rc = gcry_err_code (gcry_md_setkey (hd, buffer, buflen));
875       break;
876     case GCRYCTL_START_DUMP:
877       md_start_debug (hd, buffer);
878       break;
879     case GCRYCTL_STOP_DUMP:
880       md_stop_debug ( hd );
881       break;
882     default:
883       rc = GPG_ERR_INV_OP;
884     }
885   return gcry_error (rc);
886 }
887
888 gcry_error_t
889 gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
890 {
891   gcry_err_code_t rc = GPG_ERR_NO_ERROR;
892
893   if (!hd->ctx->macpads)
894     rc = GPG_ERR_CONFLICT;
895   else
896     {
897       rc = prepare_macpads (hd, key, keylen);
898       if (! rc)
899         gcry_md_reset (hd);
900     }
901
902   return gcry_error (rc);
903 }
904
905 /* The new debug interface.  If SUFFIX is a string it creates an debug
906    file for the context HD.  IF suffix is NULL, the file is closed and
907    debugging is stopped.  */
908 void
909 gcry_md_debug (gcry_md_hd_t hd, const char *suffix)
910 {
911   if (suffix)
912     md_start_debug (hd, suffix);
913   else
914     md_stop_debug (hd);
915 }
916
917
918
919 /****************
920  * if ALGO is null get the digest for the used algo (which should be only one)
921  */
922 static byte *
923 md_read( gcry_md_hd_t a, int algo )
924 {
925   GcryDigestEntry *r = a->ctx->list;
926
927   if (! algo)
928     {
929       /* return the first algorithm */
930       if (r && r->next)
931         log_debug ("more than one algorithm in md_read(0)\n");
932       return r->digest->read( &r->context.c );
933     }
934   else
935     {
936       for (r = a->ctx->list; r; r = r->next)
937         if (r->module->mod_id == algo)
938           return r->digest->read (&r->context.c);
939     }
940   BUG();
941   return NULL;
942 }
943
944 /*
945  * Read out the complete digest, this function implictly finalizes
946  * the hash.
947  */
948 byte *
949 gcry_md_read (gcry_md_hd_t hd, int algo)
950 {
951   /* This function is expected to always return a digest, thus we
952      can't return an error which we actually should do in
953      non-operational state.  */
954   gcry_md_ctl (hd, GCRYCTL_FINALIZE, NULL, 0);
955   return md_read (hd, algo);
956 }
957
958
959 /*
960  * Read out an intermediate digest.  Not yet functional.
961  */
962 gcry_err_code_t
963 gcry_md_get (gcry_md_hd_t hd, int algo, byte *buffer, int buflen)
964 {
965   (void)hd;
966   (void)algo;
967   (void)buffer;
968   (void)buflen;
969
970   /*md_digest ... */
971   fips_signal_error ("unimplemented function called");
972   return GPG_ERR_INTERNAL;
973 }
974
975
976 /*
977  * Shortcut function to hash a buffer with a given algo. The only
978  * guaranteed supported algorithms are RIPE-MD160 and SHA-1. The
979  * supplied digest buffer must be large enough to store the resulting
980  * hash.  No error is returned, the function will abort on an invalid
981  * algo.  DISABLED_ALGOS are ignored here.  */
982 void
983 gcry_md_hash_buffer (int algo, void *digest,
984                      const void *buffer, size_t length)
985 {
986   if (algo == GCRY_MD_SHA1)
987     _gcry_sha1_hash_buffer (digest, buffer, length);
988   else if (algo == GCRY_MD_RMD160 && !fips_mode () )
989     _gcry_rmd160_hash_buffer (digest, buffer, length);
990   else
991     {
992       /* For the others we do not have a fast function, so we use the
993          normal functions. */
994       gcry_md_hd_t h;
995       gpg_err_code_t err = md_open (&h, algo, 0, 0);
996       if (err)
997         log_bug ("gcry_md_open failed for algo %d: %s",
998                  algo, gpg_strerror (gcry_error(err)));
999       md_write (h, (byte *) buffer, length);
1000       md_final (h);
1001       memcpy (digest, md_read (h, algo), md_digest_length (algo));
1002       md_close (h);
1003     }
1004 }
1005
1006 static int
1007 md_get_algo (gcry_md_hd_t a)
1008 {
1009   GcryDigestEntry *r = a->ctx->list;
1010
1011   if (r && r->next)
1012     {
1013       fips_signal_error ("possible usage error");
1014       log_error ("WARNING: more than algorithm in md_get_algo()\n");
1015     }
1016   return r ? r->module->mod_id : 0;
1017 }
1018
1019 int
1020 gcry_md_get_algo (gcry_md_hd_t hd)
1021 {
1022   return md_get_algo (hd);
1023 }
1024
1025
1026 /****************
1027  * Return the length of the digest
1028  */
1029 static int
1030 md_digest_length (int algorithm)
1031 {
1032   gcry_module_t digest;
1033   int mdlen = 0;
1034
1035   REGISTER_DEFAULT_DIGESTS;
1036
1037   ath_mutex_lock (&digests_registered_lock);
1038   digest = _gcry_module_lookup_id (digests_registered, algorithm);
1039   if (digest)
1040     {
1041       mdlen = ((gcry_md_spec_t *) digest->spec)->mdlen;
1042       _gcry_module_release (digest);
1043     }
1044   ath_mutex_unlock (&digests_registered_lock);
1045
1046   return mdlen;
1047 }
1048
1049 /****************
1050  * Return the length of the digest in bytes.
1051  * This function will return 0 in case of errors.
1052  */
1053 unsigned int
1054 gcry_md_get_algo_dlen (int algorithm)
1055 {
1056   return md_digest_length (algorithm);
1057 }
1058
1059
1060 /* Hmmm: add a mode to enumerate the OIDs
1061  *      to make g10/sig-check.c more portable */
1062 static const byte *
1063 md_asn_oid (int algorithm, size_t *asnlen, size_t *mdlen)
1064 {
1065   const byte *asnoid = NULL;
1066   gcry_module_t digest;
1067
1068   REGISTER_DEFAULT_DIGESTS;
1069
1070   ath_mutex_lock (&digests_registered_lock);
1071   digest = _gcry_module_lookup_id (digests_registered, algorithm);
1072   if (digest)
1073     {
1074       if (asnlen)
1075         *asnlen = ((gcry_md_spec_t *) digest->spec)->asnlen;
1076       if (mdlen)
1077         *mdlen = ((gcry_md_spec_t *) digest->spec)->mdlen;
1078       asnoid = ((gcry_md_spec_t *) digest->spec)->asnoid;
1079       _gcry_module_release (digest);
1080     }
1081   else
1082     log_bug ("no ASN.1 OID for md algo %d\n", algorithm);
1083   ath_mutex_unlock (&digests_registered_lock);
1084
1085   return asnoid;
1086 }
1087
1088
1089
1090 /****************
1091  * Return information about the given cipher algorithm
1092  * WHAT select the kind of information returned:
1093  *  GCRYCTL_TEST_ALGO:
1094  *      Returns 0 when the specified algorithm is available for use.
1095  *      buffer and nbytes must be zero.
1096  *  GCRYCTL_GET_ASNOID:
1097  *      Return the ASNOID of the algorithm in buffer. if buffer is NULL, only
1098  *      the required length is returned.
1099  *
1100  * Note:  Because this function is in most cases used to return an
1101  * integer value, we can make it easier for the caller to just look at
1102  * the return value.  The caller will in all cases consult the value
1103  * and thereby detecting whether a error occured or not (i.e. while checking
1104  * the block size)
1105  */
1106 gcry_error_t
1107 gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1108 {
1109   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1110
1111   switch (what)
1112     {
1113     case GCRYCTL_TEST_ALGO:
1114       if (buffer || nbytes)
1115         err = GPG_ERR_INV_ARG;
1116       else
1117         err = check_digest_algo (algo);
1118       break;
1119
1120     case GCRYCTL_GET_ASNOID:
1121       /* We need to check that the algo is available because
1122          md_asn_oid would otherwise raise an assertion. */
1123       err = check_digest_algo (algo);
1124       if (!err)
1125         {
1126           const char unsigned *asn;
1127           size_t asnlen;
1128           
1129           asn = md_asn_oid (algo, &asnlen, NULL);
1130           if (buffer && (*nbytes >= asnlen))
1131           {
1132             memcpy (buffer, asn, asnlen);
1133             *nbytes = asnlen;
1134           }
1135           else if (!buffer && nbytes)
1136             *nbytes = asnlen;
1137           else
1138             {
1139               if (buffer)
1140                 err = GPG_ERR_TOO_SHORT;
1141               else
1142                 err = GPG_ERR_INV_ARG;
1143             }
1144         }
1145       break;
1146
1147   default:
1148     err = GPG_ERR_INV_OP;
1149   }
1150
1151   return gcry_error (err);
1152 }
1153
1154
1155 static void
1156 md_start_debug ( gcry_md_hd_t md, const char *suffix )
1157 {
1158   static int idx=0;
1159   char buf[50];
1160
1161   if (fips_mode ())
1162     return;
1163   
1164   if ( md->ctx->debug )
1165     {
1166       log_debug("Oops: md debug already started\n");
1167       return;
1168     }
1169   idx++;
1170   snprintf (buf, DIM(buf)-1, "dbgmd-%05d.%.10s", idx, suffix );
1171   md->ctx->debug = fopen(buf, "w");
1172   if ( !md->ctx->debug )
1173     log_debug("md debug: can't open %s\n", buf );
1174 }
1175
1176 static void
1177 md_stop_debug( gcry_md_hd_t md )
1178 {
1179   if ( md->ctx->debug )
1180     {
1181       if ( md->bufpos )
1182         md_write ( md, NULL, 0 );
1183       fclose (md->ctx->debug);
1184       md->ctx->debug = NULL;
1185     }
1186
1187 #ifdef HAVE_U64_TYPEDEF
1188   {  /* a kludge to pull in the __muldi3 for Solaris */
1189     volatile u32 a = (u32)(ulong)md;
1190     volatile u64 b = 42;
1191     volatile u64 c;
1192     c = a * b;
1193   }
1194 #endif
1195 }
1196
1197
1198
1199 /*
1200  * Return information about the digest handle.
1201  *  GCRYCTL_IS_SECURE:
1202  *      Returns 1 when the handle works on secured memory
1203  *      otherwise 0 is returned.  There is no error return.
1204  *  GCRYCTL_IS_ALGO_ENABLED:
1205  *     Returns 1 if the algo is enabled for that handle.
1206  *     The algo must be passed as the address of an int.
1207  */
1208 gcry_error_t
1209 gcry_md_info (gcry_md_hd_t h, int cmd, void *buffer, size_t *nbytes)
1210 {
1211   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1212
1213   switch (cmd)
1214     {
1215     case GCRYCTL_IS_SECURE:
1216       *nbytes = h->ctx->secure;
1217       break;
1218
1219     case GCRYCTL_IS_ALGO_ENABLED:
1220       {
1221         GcryDigestEntry *r;
1222         int algo;
1223
1224         if ( !buffer || (nbytes && (*nbytes != sizeof (int))))
1225           err = GPG_ERR_INV_ARG;
1226         else
1227           {
1228             algo = *(int*)buffer;
1229             
1230             *nbytes = 0;
1231             for(r=h->ctx->list; r; r = r->next ) {
1232               if (r->module->mod_id == algo)
1233                 {
1234                   *nbytes = 1;
1235                   break;
1236                 }
1237             }
1238           }
1239         break;
1240       }
1241
1242   default:
1243     err = GPG_ERR_INV_OP;
1244   }
1245
1246   return gcry_error (err);
1247 }
1248
1249
1250 /* Explicitly initialize this module.  */
1251 gcry_err_code_t
1252 _gcry_md_init (void)
1253 {
1254   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1255
1256   REGISTER_DEFAULT_DIGESTS;
1257
1258   return err;
1259 }
1260
1261
1262 int
1263 gcry_md_is_secure (gcry_md_hd_t a) 
1264 {
1265   size_t value;
1266
1267   if (gcry_md_info (a, GCRYCTL_IS_SECURE, NULL, &value))
1268     value = 1; /* It seems to be better to assume secure memory on
1269                   error. */
1270   return value;
1271 }
1272
1273
1274 int
1275 gcry_md_is_enabled (gcry_md_hd_t a, int algo) 
1276 {
1277   size_t value;
1278
1279   value = sizeof algo;
1280   if (gcry_md_info (a, GCRYCTL_IS_ALGO_ENABLED, &algo, &value))
1281     value = 0;
1282   return value;
1283 }
1284
1285 /* Get a list consisting of the IDs of the loaded message digest
1286    modules.  If LIST is zero, write the number of loaded message
1287    digest modules to LIST_LENGTH and return.  If LIST is non-zero, the
1288    first *LIST_LENGTH algorithm IDs are stored in LIST, which must be
1289    of according size.  In case there are less message digest modules
1290    than *LIST_LENGTH, *LIST_LENGTH is updated to the correct
1291    number.  */
1292 gcry_error_t
1293 gcry_md_list (int *list, int *list_length)
1294 {
1295   gcry_err_code_t err = GPG_ERR_NO_ERROR;
1296
1297   ath_mutex_lock (&digests_registered_lock);
1298   err = _gcry_module_list (digests_registered, list, list_length);
1299   ath_mutex_unlock (&digests_registered_lock);
1300
1301   return err;
1302 }
1303
1304
1305 /* Run the selftests for digest algorithm ALGO with optional reporting
1306    function REPORT.  */
1307 gpg_error_t
1308 _gcry_md_selftest (int algo, selftest_report_func_t report)
1309 {
1310   gcry_module_t module = NULL;
1311   cipher_extra_spec_t *extraspec = NULL;
1312   gcry_err_code_t ec = 0;
1313
1314   REGISTER_DEFAULT_DIGESTS;
1315
1316   ath_mutex_lock (&digests_registered_lock);
1317   module = _gcry_module_lookup_id (digests_registered, algo);
1318   if (module && !(module->flags & FLAG_MODULE_DISABLED))
1319     extraspec = module->extraspec;
1320   ath_mutex_unlock (&digests_registered_lock);
1321   if (extraspec && extraspec->selftest)
1322     ec = extraspec->selftest (algo, report);
1323   else
1324     {
1325       ec = GPG_ERR_DIGEST_ALGO;
1326       if (report)
1327         report ("digest", algo, "module", 
1328                 module && !(module->flags & FLAG_MODULE_DISABLED)?
1329                 "no selftest available" :
1330                 module? "algorithm disabled" : "algorithm not found");
1331     }
1332
1333   if (module)
1334     {
1335       ath_mutex_lock (&digests_registered_lock);
1336       _gcry_module_release (module);
1337       ath_mutex_unlock (&digests_registered_lock);
1338     }
1339   return gpg_error (ec);
1340 }