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