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