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