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