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