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