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