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