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