tests: Add a test for Curve25519.
[libgcrypt.git] / tests / t-cv25519.c
1 /* t-cv25519.c - Check the cv25519 crypto
2  * Copyright (C) 2016 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 "t-cv25519"
35 #define N_TESTS 6
36
37 #define my_isascii(c) (!((c) & 0x80))
38 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
39 #define hexdigitp(a) (digitp (a)                     \
40                       || (*(a) >= 'A' && *(a) <= 'F')  \
41                       || (*(a) >= 'a' && *(a) <= 'f'))
42 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
43                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
44 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
45 #define xmalloc(a)    gcry_xmalloc ((a))
46 #define xcalloc(a,b)  gcry_xcalloc ((a),(b))
47 #define xstrdup(a)    gcry_xstrdup ((a))
48 #define xfree(a)      gcry_free ((a))
49 #define pass()        do { ; } while (0)
50
51 static int verbose;
52 static int debug;
53 static int error_count;
54
55 static void
56 print_mpi (const char *text, gcry_mpi_t a)
57 {
58   gcry_error_t err;
59   char *buf;
60   void *bufaddr = &buf;
61
62   err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a);
63   if (err)
64     fprintf (stderr, "%s: [error printing number: %s]\n",
65              text, gpg_strerror (err));
66   else
67     {
68       fprintf (stderr, "%s: %s\n", text, buf);
69       gcry_free (buf);
70     }
71 }
72
73 static void
74 die (const char *format, ...)
75 {
76   va_list arg_ptr ;
77
78   fflush (stdout);
79   fprintf (stderr, "%s: ", PGM);
80   va_start( arg_ptr, format ) ;
81   vfprintf (stderr, format, arg_ptr );
82   va_end(arg_ptr);
83   if (*format && format[strlen(format)-1] != '\n')
84     putc ('\n', stderr);
85   exit (1);
86 }
87
88 static void
89 fail (const char *format, ...)
90 {
91   va_list arg_ptr;
92
93   fflush (stdout);
94   fprintf (stderr, "%s: ", PGM);
95   /* if (wherestr) */
96   /*   fprintf (stderr, "%s: ", wherestr); */
97   va_start (arg_ptr, format);
98   vfprintf (stderr, format, arg_ptr);
99   va_end (arg_ptr);
100   if (*format && format[strlen(format)-1] != '\n')
101     putc ('\n', stderr);
102   error_count++;
103   if (error_count >= 50)
104     die ("stopped after 50 errors.");
105 }
106
107 static void
108 show (const char *format, ...)
109 {
110   va_list arg_ptr;
111
112   if (!verbose)
113     return;
114   fprintf (stderr, "%s: ", PGM);
115   va_start (arg_ptr, format);
116   vfprintf (stderr, format, arg_ptr);
117   if (*format && format[strlen(format)-1] != '\n')
118     putc ('\n', stderr);
119   va_end (arg_ptr);
120 }
121
122
123 static void
124 show_note (const char *format, ...)
125 {
126   va_list arg_ptr;
127
128   if (!verbose && getenv ("srcdir"))
129     fputs ("      ", stderr);  /* To align above "PASS: ".  */
130   else
131     fprintf (stderr, "%s: ", PGM);
132   va_start (arg_ptr, format);
133   vfprintf (stderr, format, arg_ptr);
134   if (*format && format[strlen(format)-1] != '\n')
135     putc ('\n', stderr);
136   va_end (arg_ptr);
137 }
138
139
140 /* Convert STRING consisting of hex characters into its binary
141    representation and return it as an allocated buffer. The valid
142    length of the buffer is returned at R_LENGTH.  The string is
143    delimited by end of string.  The function returns NULL on
144    error.  */
145 static void *
146 hex2buffer (const char *string, size_t *r_length)
147 {
148   const char *s;
149   unsigned char *buffer;
150   size_t length;
151
152   buffer = xmalloc (strlen(string)/2+1);
153   length = 0;
154   for (s=string; *s; s +=2 )
155     {
156       if (!hexdigitp (s) || !hexdigitp (s+1))
157         return NULL;           /* Invalid hex digits. */
158       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
159     }
160   *r_length = length;
161   return buffer;
162 }
163
164 static void
165 reverse_buffer (unsigned char *buffer, unsigned int length)
166 {
167   unsigned int tmp, i;
168
169   for (i=0; i < length/2; i++)
170     {
171       tmp = buffer[i];
172       buffer[i] = buffer[length-1-i];
173       buffer[length-1-i] = tmp;
174     }
175 }
176
177
178 /*
179  * Test X25519 functionality through higher layer crypto routines.
180  *
181  * Input: K (as hex string), U (as hex string), R (as hex string)
182  *
183  * where R is expected result of X25519 (K, U).
184  *
185  * It calls gcry_pk_decrypt with Curve25519 private key and let
186  * it compute X25519.
187  */
188 static void
189 test_cv (int testno, const char *k_str, const char *u_str,
190          const char *result_str)
191 {
192   gpg_error_t err;
193   void *buffer = NULL;
194   size_t buflen;
195   unsigned char *p;
196   gcry_sexp_t s_sk = NULL;
197   gcry_sexp_t s_data = NULL;
198   gcry_sexp_t s_result = NULL;
199   gcry_sexp_t s_tmp = NULL;
200   unsigned char *res = NULL;
201   size_t res_len;
202
203   if (verbose > 1)
204     show ("Running test %d\n", testno);
205
206   if (!(buffer = hex2buffer (k_str, &buflen)) || buflen != 32)
207     {
208       fail ("error building s-exp for test %d, %s: %s",
209             testno, "k", "invalid hex string");
210       goto leave;
211     }
212
213   /*
214    * Do what decodeScalar25519 does.
215    */
216   p = (unsigned char *)buffer;
217   p[0] &= 248;
218   p[31] &= 127;
219   p[31] |= 64;
220   reverse_buffer (buffer, buflen);
221
222   if ((err = gcry_sexp_build (&s_sk, NULL,
223                               "(private-key"
224                               " (ecc"
225                               "  (curve \"Curve25519\")"
226                               "  (flags djb-tweak)"
227                               "  (d %b)))", (int)buflen, buffer)))
228     {
229       fail ("error building s-exp for test %d, %s: %s",
230             testno, "sk", gpg_strerror (err));
231       goto leave;
232     }
233
234   xfree (buffer);
235   if (!(buffer = hex2buffer (u_str, &buflen)))
236     {
237       fail ("error building s-exp for test %d, %s: %s",
238             testno, "u", "invalid hex string");
239       goto leave;
240     }
241
242   /*
243    * The procedure of decodeUCoordinate will be done internally
244    * by _gcry_ecc_mont_decodepoint.  So, we just put the little-endian
245    * binary to build S-exp.
246    *
247    * We could add the prefix 0x40, but libgcrypt also supports
248    * format with no prefix.  So, it is OK not to put the prefix.
249    */
250   if ((err = gcry_sexp_build (&s_data, NULL,
251                               "(enc-val"
252                               " (ecdh"
253                               "  (e %b)))", (int)buflen, buffer)))
254     {
255       fail ("error building s-exp for test %d, %s: %s",
256             testno, "data", gpg_strerror (err));
257       goto leave;
258     }
259
260   xfree (buffer);
261   buffer = NULL;
262
263   if ((err = gcry_pk_decrypt (&s_result, s_data, s_sk)))
264     fail ("gcry_pk_decrypt failed for test %d: %s", testno,
265           gpg_strerror (err));
266
267   s_tmp = gcry_sexp_find_token (s_result, "value", 0);
268   if (!s_tmp || !(res = gcry_sexp_nth_buffer (s_tmp, 1, &res_len)))
269     fail ("gcry_pk_decrypt failed for test %d: %s", testno, "missing value");
270   else
271     {
272       char *r, *r0;
273       int i;
274
275       /* To skip the prefix 0x40, for-loop start with i=1 */
276       r0 = r = xmalloc (2*(res_len)+1);
277       if (!r0)
278         {
279           fail ("memory allocation", testno);
280           goto leave;
281         }
282
283       for (i=1; i < res_len; i++, r += 2)
284         snprintf (r, 3, "%02x", res[i]);
285       if (strcmp (result_str, r0))
286         {
287           fail ("gcry_pk_decrypt failed for test %d: %s",
288                 testno, "wrong value returned");
289           show ("  expected: '%s'", result_str);
290           show ("       got: '%s'", r0);
291         }
292       xfree (r0);
293     }
294
295  leave:
296   xfree (res);
297   gcry_sexp_release (s_tmp);
298   gcry_sexp_release (s_result);
299   gcry_sexp_release (s_data);
300   gcry_sexp_release (s_sk);
301   xfree (buffer);
302 }
303
304 /*
305  * Test iterative X25519 computation through lower layer MPI routines.
306  *
307  * Input: K (as hex string), ITER, R (as hex string)
308  *
309  * where R is expected result of iterating X25519 by ITER times.
310  *
311  */
312 static void
313 test_it (int testno, const char *k_str, int iter, const char *result_str)
314 {
315   gcry_ctx_t ctx;
316   gpg_error_t err;
317   void *buffer = NULL;
318   size_t buflen;
319   gcry_mpi_t mpi_k = NULL;
320   gcry_mpi_t mpi_x = NULL;
321   gcry_mpi_point_t P = NULL;
322   gcry_mpi_point_t Q;
323   int i;
324   gcry_mpi_t mpi_kk = NULL;
325
326   if (verbose > 1)
327     show ("Running test %d: iteration=%d\n", testno, iter);
328
329   gcry_mpi_ec_new (&ctx, NULL, "Curve25519");
330   Q = gcry_mpi_point_new (0);
331
332   if (!(buffer = hex2buffer (k_str, &buflen)) || buflen != 32)
333     {
334       fail ("error scanning MPI for test %d, %s: %s",
335             testno, "k", "invalid hex string");
336       goto leave;
337     }
338   reverse_buffer (buffer, buflen);
339   if ((err = gcry_mpi_scan (&mpi_x, GCRYMPI_FMT_USG, buffer, buflen, NULL)))
340     {
341       fail ("error scanning MPI for test %d, %s: %s",
342             testno, "x", gpg_strerror (err));
343       goto leave;
344     }
345
346   xfree (buffer);
347   buffer = NULL;
348
349   P = gcry_mpi_point_set (NULL, mpi_x, NULL, GCRYMPI_CONST_ONE);
350
351   mpi_k = gcry_mpi_copy (mpi_x);
352   if (debug)
353     print_mpi ("k", mpi_k);
354
355   for (i = 0; i < iter; i++)
356     {
357       /*
358        * Another variant of decodeScalar25519 thing.
359        */
360       mpi_kk = gcry_mpi_set (mpi_kk, mpi_k);
361       gcry_mpi_set_bit (mpi_kk, 254);
362       gcry_mpi_clear_bit (mpi_kk, 255);
363       gcry_mpi_clear_bit (mpi_kk, 0);
364       gcry_mpi_clear_bit (mpi_kk, 1);
365       gcry_mpi_clear_bit (mpi_kk, 2);
366
367       gcry_mpi_ec_mul (Q, mpi_kk, P, ctx);
368
369       P = gcry_mpi_point_set (P, mpi_k, NULL, GCRYMPI_CONST_ONE);
370       gcry_mpi_ec_get_affine (mpi_k, NULL, Q, ctx);
371
372       if (debug)
373         print_mpi ("k", mpi_k);
374     }
375
376   {
377     unsigned char res[32];
378     char *r, *r0;
379
380     gcry_mpi_print (GCRYMPI_FMT_USG, res, 32, NULL, mpi_k);
381     reverse_buffer (res, 32);
382
383     r0 = r = xmalloc (65);
384     if (!r0)
385       {
386         fail ("memory allocation", testno);
387         goto leave;
388       }
389
390     for (i=0; i < 32; i++, r += 2)
391       snprintf (r, 3, "%02x", res[i]);
392
393     if (strcmp (result_str, r0))
394       {
395         fail ("curv25519 failed for test %d: %s",
396               testno, "wrong value returned");
397         show ("  expected: '%s'", result_str);
398         show ("       got: '%s'", r0);
399       }
400     xfree (r0);
401   }
402
403  leave:
404   gcry_mpi_release (mpi_kk);
405   gcry_mpi_release (mpi_k);
406   gcry_mpi_point_release (P);
407   gcry_mpi_release (mpi_x);
408   xfree (buffer);
409   gcry_mpi_point_release (Q);
410   gcry_ctx_release (ctx);
411 }
412
413 /*
414  * X-coordinate of generator of the Curve25519.
415  */
416 #define G_X "0900000000000000000000000000000000000000000000000000000000000000"
417
418 /*
419  * Test Diffie-Hellman in RFC-7748.
420  *
421  * Note that it's not like the ECDH of OpenPGP, where we use
422  * ephemeral public key.
423  */
424 static void
425 test_dh (int testno, const char *a_priv_str, const char *a_pub_str,
426           const char *b_priv_str, const char *b_pub_str,
427           const char *result_str)
428 {
429   /* Test A for private key corresponds to public key. */
430   test_cv (testno, a_priv_str, G_X, a_pub_str);
431   /* Test B for private key corresponds to public key. */
432   test_cv (testno, b_priv_str, G_X, b_pub_str);
433   /* Test DH with A's private key and B's public key. */
434   test_cv (testno, a_priv_str, b_pub_str, result_str);
435   /* Test DH with B's private key and A's public key. */
436   test_cv (testno, b_priv_str, a_pub_str, result_str);
437 }
438
439
440 static void
441 check_cv25519 (void)
442 {
443   int ntests;
444
445   show ("Checking Curve25519.\n");
446
447   ntests = 0;
448
449   /*
450    * Values are cited from RFC-7748: 5.2.  Test Vectors.
451    * Following two tests are for the first type test.
452    */
453   test_cv (1,
454            "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
455            "e6db6867583030db3594c1a424b15f7c726624ec26b3353b10a903a6d0ab1c4c",
456            "c3da55379de9c6908e94ea4df28d084f32eccf03491c71f754b4075577a28552");
457   ntests++;
458   test_cv (2,
459            "4b66e9d4d1b4673c5ad22691957d6af5c11b6421e0ea01d42ca4169e7918ba0d",
460            "e5210f12786811d3f4b7959d0538ae2c31dbe7106fc03c3efc4cd549c715a493",
461            "95cbde9476e8907d7aade45cb4b873f88b595a68799fa152e6f8f7647aac7957");
462   ntests++;
463
464   /*
465    * Additional test.  Value is from second type test.
466    */
467   test_cv (3,
468            G_X,
469            G_X,
470            "422c8e7a6227d7bca1350b3e2bb7279f7897b87bb6854b783c60e80311ae3079");
471   ntests++;
472
473   /*
474    * Following two tests are for the second type test,
475    * with one iteration and 1,000 iterations.  (1,000,000 iterations
476    * takes too long.)
477    */
478   test_it (4,
479            G_X,
480            1,
481            "422c8e7a6227d7bca1350b3e2bb7279f7897b87bb6854b783c60e80311ae3079");
482   ntests++;
483
484   test_it (5,
485            G_X,
486            1000,
487            "684cf59ba83309552800ef566f2f4d3c1c3887c49360e3875f2eb94d99532c51");
488   ntests++;
489
490   /*
491    * Last test is from: 6.  Diffie-Hellman, 6.1.  Curve25519
492    */
493   test_dh (6,
494            /* Alice's private key, a */
495            "77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a",
496            /* Alice's public key, X25519(a, 9) */
497            "8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a",
498            /* Bob's private key, b */
499            "5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb",
500            /* Bob's public key, X25519(b, 9) */
501            "de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f",
502            /* Their shared secret, K */
503            "4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742");
504   ntests++;
505
506   if (ntests != N_TESTS)
507     fail ("did %d tests but expected %d", ntests, N_TESTS);
508   else if ((ntests % 256))
509     show_note ("%d tests done\n", ntests);
510 }
511
512
513 int
514 main (int argc, char **argv)
515 {
516   int last_argc = -1;
517
518   if (argc)
519     { argc--; argv++; }
520
521   while (argc && last_argc != argc )
522     {
523       last_argc = argc;
524       if (!strcmp (*argv, "--"))
525         {
526           argc--; argv++;
527           break;
528         }
529       else if (!strcmp (*argv, "--help"))
530         {
531           fputs ("usage: " PGM " [options]\n"
532                  "Options:\n"
533                  "  --verbose       print timings etc.\n"
534                  "  --debug         flyswatter\n",
535                  stdout);
536           exit (0);
537         }
538       else if (!strcmp (*argv, "--verbose"))
539         {
540           verbose++;
541           argc--; argv++;
542         }
543       else if (!strcmp (*argv, "--debug"))
544         {
545           verbose += 2;
546           debug++;
547           argc--; argv++;
548         }
549       else if (!strncmp (*argv, "--", 2))
550         die ("unknown option '%s'", *argv);
551     }
552
553   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
554   if (!gcry_check_version (GCRYPT_VERSION))
555     die ("version mismatch\n");
556   if (debug)
557     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
558   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
559   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
560
561   start_timer ();
562   check_cv25519 ();
563   stop_timer ();
564
565   show ("All tests completed in %s.  Errors: %d\n",
566         elapsed_time (1), error_count);
567   return !!error_count;
568 }