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