ecc: Use constant time point operation for Twisted Edwards.
[libgcrypt.git] / tests / hashtest.c
1 /* hashtest.c - Check the hash fucntions
2  * Copyright (C) 2013 g10 Code GmbH
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23 #include <stdarg.h>
24 #include <stdio.h>
25 #include <ctype.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <errno.h>
29
30 #include "../src/gcrypt-int.h"
31
32 #include "stopwatch.h"
33
34 #define PGM "hashtest"
35
36 #define my_isascii(c) (!((c) & 0x80))
37 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
38 #define hexdigitp(a) (digitp (a)                     \
39                       || (*(a) >= 'A' && *(a) <= 'F')  \
40                       || (*(a) >= 'a' && *(a) <= 'f'))
41 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
42                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
43 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
44 #define xmalloc(a)    gcry_xmalloc ((a))
45 #define xcalloc(a,b)  gcry_xcalloc ((a),(b))
46 #define xstrdup(a)    gcry_xstrdup ((a))
47 #define xfree(a)      gcry_free ((a))
48 #define pass()        do { ; } while (0)
49
50 static int verbose;
51 static int debug;
52 static int error_count;
53 static int missing_test_vectors;
54
55 static struct {
56   int algo;
57   int gigs;
58   int bytes;
59   const char *hex;
60 } testvectors[] = {
61   { GCRY_MD_SHA1, 256, -64, "92fc51850c7b750e6e774b75f294f6979d4059f0" },
62   { GCRY_MD_SHA1, 256,  -1, "4bddeeb4c08683f02d4944d93dbcb02ebab50134" },
63   { GCRY_MD_SHA1, 256,  -0, "71b923afde1c8c040884c723a2e3335b333e64c6" },
64   { GCRY_MD_SHA1, 256,   1, "2d99f9b5b86e9c9c937104f4242bd6b8bc0927ef" },
65   { GCRY_MD_SHA1, 256,  64, "a60dabe8d749f798b7ec3a684cc3eab487451482" },
66   { GCRY_MD_SHA224, 256, -64,
67     "b5672b54d2480a5688a2dc727a1ad4db7a81ef31ce8999e0bbaeffdc" },
68   { GCRY_MD_SHA224, 256,  -1,
69     "814ea7159473e6ffc1c64b90026a542e13ac6980f7f3ca3c4582a9b8" },
70   { GCRY_MD_SHA224, 256,   0,
71     "9ec0e1829455db8650ec7a8b06912196f97a7358bc3a73c79911cd4e" },
72   { GCRY_MD_SHA224, 256,   1,
73     "e578d5d523320876565bbbc892511a485427caee6dd754d57e3e58c2" },
74   { GCRY_MD_SHA224, 256,  64,
75     "ff0464df248cd298b63765bc4f87f21e25c93c657fdf3656d3c878e5" },
76   { GCRY_MD_SHA256, 256, -64,
77     "87a9828d3de78d55d252341db2a622908c4e0ceaee9961ecf9768700fc799ec8" },
78   { GCRY_MD_SHA256, 256,  -1,
79     "823bf95f64ef04a4a77579c38760b1d401b56bf3a8e664bdf56ca15afb468a03" },
80   { GCRY_MD_SHA256, 256,   0,
81     "2d0723878cb2c3d5c59dfad910cdb857f4430a6ba2a7d687938d7a20e63dde47" },
82   { GCRY_MD_SHA256, 256,   1,
83     "5a2e21b1e79cd866acf53a2a18ca76bd4e02c4b01bf4627354171824c812d95f" },
84   { GCRY_MD_SHA256, 256,  64,
85     "34444808af8e9d995e67f9e155ed94bf55f195a51dc1d8a989e6bcf95511c8a2" },
86   { 0 }
87 };
88
89
90
91
92
93 static void
94 die (const char *format, ...)
95 {
96   va_list arg_ptr ;
97
98   fflush (stdout);
99   fprintf (stderr, "%s: ", PGM);
100   va_start( arg_ptr, format ) ;
101   vfprintf (stderr, format, arg_ptr );
102   va_end(arg_ptr);
103   if (*format && format[strlen(format)-1] != '\n')
104     putc ('\n', stderr);
105   exit (1);
106 }
107
108 static void
109 fail (const char *format, ...)
110 {
111   va_list arg_ptr;
112
113   fflush (stdout);
114   fprintf (stderr, "%s: ", PGM);
115   /* if (wherestr) */
116   /*   fprintf (stderr, "%s: ", wherestr); */
117   va_start (arg_ptr, format);
118   vfprintf (stderr, format, arg_ptr);
119   va_end (arg_ptr);
120   if (*format && format[strlen(format)-1] != '\n')
121     putc ('\n', stderr);
122   error_count++;
123   if (error_count >= 50)
124     die ("stopped after 50 errors.");
125 }
126
127 static void
128 show (const char *format, ...)
129 {
130   va_list arg_ptr;
131
132   fprintf (stderr, "%s: ", PGM);
133   va_start (arg_ptr, format);
134   vfprintf (stderr, format, arg_ptr);
135   if (*format && format[strlen(format)-1] != '\n')
136     putc ('\n', stderr);
137   va_end (arg_ptr);
138 }
139
140
141 static void
142 showhex (const void *buffer, size_t buflen, const char *format, ...)
143 {
144   va_list arg_ptr;
145   const unsigned char *s;
146
147   fprintf (stderr, "%s: ", PGM);
148   va_start (arg_ptr, format);
149   vfprintf (stderr, format, arg_ptr);
150   va_end (arg_ptr);
151
152   for (s=buffer; buflen; buflen--, s++)
153     fprintf (stderr, "%02x", *s);
154   putc ('\n', stderr);
155 }
156
157
158 static void
159 show_note (const char *format, ...)
160 {
161   va_list arg_ptr;
162
163   if (!verbose && getenv ("srcdir"))
164     fputs ("      ", stderr);  /* To align above "PASS: ".  */
165   else
166     fprintf (stderr, "%s: ", PGM);
167   va_start (arg_ptr, format);
168   vfprintf (stderr, format, arg_ptr);
169   if (*format && format[strlen(format)-1] != '\n')
170     putc ('\n', stderr);
171   va_end (arg_ptr);
172 }
173
174 /* Convert STRING consisting of hex characters into its binary
175    representation and return it as an allocated buffer. The valid
176    length of the buffer is returned at R_LENGTH.  The string is
177    delimited by end of string.  The function returns NULL on
178    error.  */
179 static void *
180 hex2buffer (const char *string, size_t *r_length)
181 {
182   const char *s;
183   unsigned char *buffer;
184   size_t length;
185
186   buffer = xmalloc (strlen(string)/2+1);
187   length = 0;
188   for (s=string; *s; s +=2 )
189     {
190       if (!hexdigitp (s) || !hexdigitp (s+1))
191         return NULL;           /* Invalid hex digits. */
192       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
193     }
194   *r_length = length;
195   return buffer;
196 }
197
198
199 static void
200 run_selftest (int algo)
201 {
202   gpg_error_t err;
203   size_t n;
204
205   n = 1;
206   err = gcry_md_algo_info (algo, GCRYCTL_SELFTEST, NULL, &n);
207   if (err && gpg_err_code (err) != GPG_ERR_NOT_IMPLEMENTED)
208     fail ("extended selftest for %s (%d) failed: %s",
209           gcry_md_algo_name (algo), algo, gpg_strerror (err));
210   else if (err && verbose)
211     show ("extended selftest for %s (%d) not implemented",
212           gcry_md_algo_name (algo), algo);
213   else if (verbose)
214     show ("extended selftest for %s (%d) passed",
215           gcry_md_algo_name (algo), algo);
216 }
217
218 /* Compare DIGEST of length DIGESTLEN generated using ALGO and GIGS
219    plus BYTES with the test vector and print an error message if the
220    don't match.  Return 0 on match.  */
221 static int
222 cmp_digest (const unsigned char *digest, size_t digestlen,
223             int algo, int gigs, int bytes)
224 {
225   int idx;
226   unsigned char *tv_digest;
227   size_t tv_digestlen = 0;
228
229   for (idx=0; testvectors[idx].algo; idx++)
230     {
231       if (testvectors[idx].algo == algo
232           && testvectors[idx].gigs == gigs
233           && testvectors[idx].bytes == bytes)
234         break;
235     }
236   if (!testvectors[idx].algo)
237     {
238       show ("%d GiB %+3d %-10s warning: %s",
239             gigs, bytes, gcry_md_algo_name (algo), "no test vector");
240       missing_test_vectors++;
241       return 1;
242     }
243
244   tv_digest = hex2buffer (testvectors[idx].hex, &tv_digestlen);
245   if (tv_digestlen != digestlen) /* Ooops.  */
246     {
247       fail ("%d GiB %+3d %-10s error: %s",
248             gigs, bytes, gcry_md_algo_name (algo), "digest length mismatch");
249       xfree (tv_digest);
250       return 1;
251     }
252   if (memcmp (tv_digest, digest, tv_digestlen))
253     {
254       fail ("%d GiB %+3d %-10s error: %s",
255             gigs, bytes, gcry_md_algo_name (algo), "mismatch");
256       xfree (tv_digest);
257       return 1;
258     }
259   xfree (tv_digest);
260
261   return 0;
262 }
263
264
265 static void
266 run_longtest (int algo, int gigs)
267 {
268   gpg_error_t err;
269   gcry_md_hd_t hd;
270   gcry_md_hd_t hd_pre = NULL;
271   gcry_md_hd_t hd_pre2 = NULL;
272   gcry_md_hd_t hd_post = NULL;
273   gcry_md_hd_t hd_post2 = NULL;
274   char pattern[1024];
275   int i, g;
276   const unsigned char *digest;
277   unsigned int digestlen;
278
279   memset (pattern, 'a', sizeof pattern);
280
281   err = gcry_md_open (&hd, algo, 0);
282   if (err)
283     {
284       fail ("gcry_md_open failed for %s (%d): %s",
285             gcry_md_algo_name (algo), algo, gpg_strerror (err));
286       return;
287     }
288
289   digestlen = gcry_md_get_algo_dlen (algo);
290
291
292   for (g=0; g < gigs; g++)
293     {
294       if (g == gigs - 1)
295         {
296           for (i = 0; i < 1024*1023; i++)
297             gcry_md_write (hd, pattern, sizeof pattern);
298           for (i = 0; i < 1023; i++)
299             gcry_md_write (hd, pattern, sizeof pattern);
300           err = gcry_md_copy (&hd_pre, hd);
301           if (!err)
302             err = gcry_md_copy (&hd_pre2, hd);
303           if (err)
304             die ("gcry_md_copy failed for %s (%d): %s",
305                  gcry_md_algo_name (algo), algo, gpg_strerror (err));
306           gcry_md_write (hd, pattern, sizeof pattern);
307         }
308       else
309         {
310           for (i = 0; i < 1024*1024; i++)
311             gcry_md_write (hd, pattern, sizeof pattern);
312         }
313       if (g && !(g % 16))
314         show_note ("%d GiB so far hashed with %s", g, gcry_md_algo_name (algo));
315     }
316   if (g >= 16)
317     show_note ("%d GiB hashed with %s", g, gcry_md_algo_name (algo));
318
319   err = gcry_md_copy (&hd_post, hd);
320   if (err)
321     die ("gcry_md_copy failed for %s (%d): %s",
322          gcry_md_algo_name (algo), algo, gpg_strerror (err));
323   err = gcry_md_copy (&hd_post2, hd);
324   if (err)
325     die ("gcry_md_copy failed for %s (%d): %s",
326          gcry_md_algo_name (algo), algo, gpg_strerror (err));
327
328   gcry_md_write (hd_pre2, pattern, sizeof pattern - 64);
329   gcry_md_write (hd_pre, pattern, sizeof pattern - 1);
330   gcry_md_write (hd_post, pattern, 1);
331   gcry_md_write (hd_post2, pattern, 64);
332
333   digest = gcry_md_read (hd_pre2, algo);
334   if (cmp_digest (digest, digestlen, algo, gigs, -64) || verbose)
335     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
336              gigs, -64, gcry_md_algo_name (algo));
337   digest = gcry_md_read (hd_pre, algo);
338   if (cmp_digest (digest, digestlen, algo, gigs, -1) || verbose)
339     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
340              gigs, -1, gcry_md_algo_name (algo));
341   digest = gcry_md_read (hd, algo);
342   if (cmp_digest (digest, digestlen, algo, gigs, 0) || verbose)
343     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
344              gigs, 0, gcry_md_algo_name (algo));
345   digest = gcry_md_read (hd_post, algo);
346   if (cmp_digest (digest, digestlen, algo, gigs, 1) || verbose)
347     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
348              gigs, 1, gcry_md_algo_name (algo));
349   digest = gcry_md_read (hd_post2, algo);
350   if (cmp_digest (digest, digestlen, algo, gigs, 64) || verbose)
351     showhex (digest, digestlen, "%d GiB %+3d %-10s ",
352              gigs, 64, gcry_md_algo_name (algo));
353
354   gcry_md_close (hd);
355   gcry_md_close (hd_pre);
356   gcry_md_close (hd_pre2);
357   gcry_md_close (hd_post);
358   gcry_md_close (hd_post2);
359 }
360
361
362 int
363 main (int argc, char **argv)
364 {
365   int last_argc = -1;
366   int gigs = 0;
367   int algo = 0;
368   int idx;
369
370   if (argc)
371     { argc--; argv++; }
372
373   while (argc && last_argc != argc )
374     {
375       last_argc = argc;
376       if (!strcmp (*argv, "--"))
377         {
378           argc--; argv++;
379           break;
380         }
381       else if (!strcmp (*argv, "--help"))
382         {
383           fputs ("usage: " PGM " [options] [algos]\n"
384                  "Options:\n"
385                  "  --verbose       print timings etc.\n"
386                  "  --debug         flyswatter\n"
387                  "  --gigs N        Run a test on N GiB\n",
388                  stdout);
389           exit (0);
390         }
391       else if (!strcmp (*argv, "--verbose"))
392         {
393           verbose++;
394           argc--; argv++;
395         }
396       else if (!strcmp (*argv, "--debug"))
397         {
398           verbose += 2;
399           debug++;
400           argc--; argv++;
401         }
402       else if (!strcmp (*argv, "--gigs"))
403         {
404           argc--; argv++;
405           if (argc)
406             {
407               gigs = atoi (*argv);
408               argc--; argv++;
409             }
410         }
411       else if (!strncmp (*argv, "--", 2))
412         die ("unknown option '%s'", *argv);
413     }
414
415   if (gigs < 0 || gigs > 1024*1024)
416     die ("value for --gigs must be in the range 0 to %d", 1024*1024);
417
418   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
419   if (!gcry_check_version (GCRYPT_VERSION))
420     die ("version mismatch\n");
421   if (debug)
422     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
423   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
424   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
425
426   /* A quick check that all given algorithms are valid.  */
427   for (idx=0; idx < argc; idx++)
428     {
429       algo = gcry_md_map_name (argv[idx]);
430       if (!algo)
431         fail ("invalid algorithm '%s'", argv[idx]);
432     }
433   if (error_count)
434     exit (1);
435
436   /* Start checking.  */
437   start_timer ();
438   if (!argc)
439     {
440       for (algo=1; algo < 400; algo++)
441         if (!gcry_md_test_algo (algo))
442           {
443             if (!gigs)
444               run_selftest (algo);
445             else
446               run_longtest (algo, gigs);
447           }
448      }
449   else
450     {
451       for (idx=0; idx < argc; idx++)
452         {
453           algo = gcry_md_map_name (argv[idx]);
454           if (!algo)
455             die ("invalid algorithm '%s'", argv[idx]);
456
457           if (!gigs)
458             run_selftest (algo);
459           else
460             run_longtest (algo, gigs);
461         }
462     }
463   stop_timer ();
464
465   if (missing_test_vectors)
466     fail ("Some test vectors are missing");
467
468   if (verbose)
469     show ("All tests completed in %s.  Errors: %d\n",
470           elapsed_time (), error_count);
471   return !!error_count;
472 }