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