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