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