tests: Check the result of all gcry_control operations.
[libgcrypt.git] / tests / t-cv25519.c
index 69aa005..8c4a53e 100644 (file)
 #include <string.h>
 #include <errno.h>
 
-#include "../src/gcrypt-int.h"
-
 #include "stopwatch.h"
 
 #define PGM "t-cv25519"
-#define N_TESTS 6
-
-#define my_isascii(c) (!((c) & 0x80))
-#define digitp(p)   (*(p) >= '0' && *(p) <= '9')
-#define hexdigitp(a) (digitp (a)                     \
-                      || (*(a) >= 'A' && *(a) <= 'F')  \
-                      || (*(a) >= 'a' && *(a) <= 'f'))
-#define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
-                     *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
-#define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
-#define xmalloc(a)    gcry_xmalloc ((a))
-#define xcalloc(a,b)  gcry_xcalloc ((a),(b))
-#define xstrdup(a)    gcry_xstrdup ((a))
-#define xfree(a)      gcry_free ((a))
-#define pass()        do { ; } while (0)
-
-static int verbose;
-static int debug;
-static int error_count;
+#include "t-common.h"
+#define N_TESTS 18
+
 
 static void
 print_mpi (const char *text, gcry_mpi_t a)
@@ -70,55 +52,6 @@ print_mpi (const char *text, gcry_mpi_t a)
     }
 }
 
-static void
-die (const char *format, ...)
-{
-  va_list arg_ptr ;
-
-  fflush (stdout);
-  fprintf (stderr, "%s: ", PGM);
-  va_start( arg_ptr, format ) ;
-  vfprintf (stderr, format, arg_ptr );
-  va_end(arg_ptr);
-  if (*format && format[strlen(format)-1] != '\n')
-    putc ('\n', stderr);
-  exit (1);
-}
-
-static void
-fail (const char *format, ...)
-{
-  va_list arg_ptr;
-
-  fflush (stdout);
-  fprintf (stderr, "%s: ", PGM);
-  /* if (wherestr) */
-  /*   fprintf (stderr, "%s: ", wherestr); */
-  va_start (arg_ptr, format);
-  vfprintf (stderr, format, arg_ptr);
-  va_end (arg_ptr);
-  if (*format && format[strlen(format)-1] != '\n')
-    putc ('\n', stderr);
-  error_count++;
-  if (error_count >= 50)
-    die ("stopped after 50 errors.");
-}
-
-static void
-show (const char *format, ...)
-{
-  va_list arg_ptr;
-
-  if (!verbose)
-    return;
-  fprintf (stderr, "%s: ", PGM);
-  va_start (arg_ptr, format);
-  vfprintf (stderr, format, arg_ptr);
-  if (*format && format[strlen(format)-1] != '\n')
-    putc ('\n', stderr);
-  va_end (arg_ptr);
-}
-
 
 static void
 show_note (const char *format, ...)
@@ -192,8 +125,8 @@ test_cv (int testno, const char *k_str, const char *u_str,
   gpg_error_t err;
   void *buffer = NULL;
   size_t buflen;
-  unsigned char *p;
-  gcry_sexp_t s_sk = NULL;
+  gcry_sexp_t s_pk = NULL;
+  gcry_mpi_t mpi_k = NULL;
   gcry_sexp_t s_data = NULL;
   gcry_sexp_t s_result = NULL;
   gcry_sexp_t s_tmp = NULL;
@@ -201,7 +134,7 @@ test_cv (int testno, const char *k_str, const char *u_str,
   size_t res_len;
 
   if (verbose > 1)
-    show ("Running test %d\n", testno);
+    info ("Running test %d\n", testno);
 
   if (!(buffer = hex2buffer (k_str, &buflen)) || buflen != 32)
     {
@@ -210,29 +143,22 @@ test_cv (int testno, const char *k_str, const char *u_str,
       goto leave;
     }
 
-  /*
-   * Do what decodeScalar25519 does.
-   */
-  p = (unsigned char *)buffer;
-  p[0] &= 248;
-  p[31] &= 127;
-  p[31] |= 64;
   reverse_buffer (buffer, buflen);
+  if ((err = gcry_mpi_scan (&mpi_k, GCRYMPI_FMT_USG, buffer, buflen, NULL)))
+    {
+      fail ("error converting MPI for test %d: %s", testno, gpg_strerror (err));
+      goto leave;
+    }
 
-  if ((err = gcry_sexp_build (&s_sk, NULL,
-                              "(private-key"
-                              " (ecc"
-                              "  (curve \"Curve25519\")"
-                              "  (flags djb-tweak)"
-                              "  (d %b)))", (int)buflen, buffer)))
+  if ((err = gcry_sexp_build (&s_data, NULL, "%m", mpi_k)))
     {
       fail ("error building s-exp for test %d, %s: %s",
-            testno, "sk", gpg_strerror (err));
+            testno, "data", gpg_strerror (err));
       goto leave;
     }
 
   xfree (buffer);
-  if (!(buffer = hex2buffer (u_str, &buflen)))
+  if (!(buffer = hex2buffer (u_str, &buflen)) || buflen != 32)
     {
       fail ("error building s-exp for test %d, %s: %s",
             testno, "u", "invalid hex string");
@@ -247,26 +173,28 @@ test_cv (int testno, const char *k_str, const char *u_str,
    * We could add the prefix 0x40, but libgcrypt also supports
    * format with no prefix.  So, it is OK not to put the prefix.
    */
-  if ((err = gcry_sexp_build (&s_data, NULL,
-                              "(enc-val"
-                              " (ecdh"
-                              "  (e %b)))", (int)buflen, buffer)))
+  if ((err = gcry_sexp_build (&s_pk, NULL,
+                              "(public-key"
+                              " (ecc"
+                              "  (curve \"Curve25519\")"
+                              "  (flags djb-tweak)"
+                              "  (q%b)))", (int)buflen, buffer)))
     {
       fail ("error building s-exp for test %d, %s: %s",
-            testno, "data", gpg_strerror (err));
+            testno, "pk", gpg_strerror (err));
       goto leave;
     }
 
   xfree (buffer);
   buffer = NULL;
 
-  if ((err = gcry_pk_decrypt (&s_result, s_data, s_sk)))
-    fail ("gcry_pk_decrypt failed for test %d: %s", testno,
+  if ((err = gcry_pk_encrypt (&s_result, s_data, s_pk)))
+    fail ("gcry_pk_encrypt failed for test %d: %s", testno,
           gpg_strerror (err));
 
-  s_tmp = gcry_sexp_find_token (s_result, "value", 0);
+  s_tmp = gcry_sexp_find_token (s_result, "s", 0);
   if (!s_tmp || !(res = gcry_sexp_nth_buffer (s_tmp, 1, &res_len)))
-    fail ("gcry_pk_decrypt failed for test %d: %s", testno, "missing value");
+    fail ("gcry_pk_encrypt failed for test %d: %s", testno, "missing value");
   else
     {
       char *r, *r0;
@@ -275,29 +203,30 @@ test_cv (int testno, const char *k_str, const char *u_str,
       /* To skip the prefix 0x40, for-loop start with i=1 */
       r0 = r = xmalloc (2*(res_len)+1);
       if (!r0)
-       {
-         fail ("memory allocation", testno);
-         goto leave;
-       }
+        {
+          fail ("memory allocation for test %d", testno);
+          goto leave;
+        }
 
       for (i=1; i < res_len; i++, r += 2)
         snprintf (r, 3, "%02x", res[i]);
       if (strcmp (result_str, r0))
         {
-          fail ("gcry_pk_decrypt failed for test %d: %s",
+          fail ("gcry_pk_encrypt failed for test %d: %s",
                 testno, "wrong value returned");
-          show ("  expected: '%s'", result_str);
-          show ("       got: '%s'", r0);
+          info ("  expected: '%s'", result_str);
+          info ("       got: '%s'", r0);
         }
       xfree (r0);
     }
 
  leave:
   xfree (res);
+  gcry_mpi_release (mpi_k);
   gcry_sexp_release (s_tmp);
   gcry_sexp_release (s_result);
   gcry_sexp_release (s_data);
-  gcry_sexp_release (s_sk);
+  gcry_sexp_release (s_pk);
   xfree (buffer);
 }
 
@@ -324,7 +253,7 @@ test_it (int testno, const char *k_str, int iter, const char *result_str)
   gcry_mpi_t mpi_kk = NULL;
 
   if (verbose > 1)
-    show ("Running test %d: iteration=%d\n", testno, iter);
+    info ("Running test %d: iteration=%d\n", testno, iter);
 
   gcry_mpi_ec_new (&ctx, NULL, "Curve25519");
   Q = gcry_mpi_point_new (0);
@@ -370,7 +299,7 @@ test_it (int testno, const char *k_str, int iter, const char *result_str)
       gcry_mpi_ec_get_affine (mpi_k, NULL, Q, ctx);
 
       if (debug)
-       print_mpi ("k", mpi_k);
+        print_mpi ("k", mpi_k);
     }
 
   {
@@ -383,8 +312,8 @@ test_it (int testno, const char *k_str, int iter, const char *result_str)
     r0 = r = xmalloc (65);
     if (!r0)
       {
-       fail ("memory allocation", testno);
-       goto leave;
+        fail ("memory allocation for test %d", testno);
+        goto leave;
       }
 
     for (i=0; i < 32; i++, r += 2)
@@ -394,8 +323,8 @@ test_it (int testno, const char *k_str, int iter, const char *result_str)
       {
         fail ("curv25519 failed for test %d: %s",
               testno, "wrong value returned");
-        show ("  expected: '%s'", result_str);
-       show ("       got: '%s'", r0);
+        info ("  expected: '%s'", result_str);
+        info ("       got: '%s'", r0);
       }
     xfree (r0);
   }
@@ -442,7 +371,7 @@ check_cv25519 (void)
 {
   int ntests;
 
-  show ("Checking Curve25519.\n");
+  info ("Checking Curve25519.\n");
 
   ntests = 0;
 
@@ -503,6 +432,80 @@ check_cv25519 (void)
            "4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742");
   ntests++;
 
+  /* Seven tests which results 0. */
+  test_cv (7,
+           "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+           "0000000000000000000000000000000000000000000000000000000000000000",
+           "0000000000000000000000000000000000000000000000000000000000000000");
+  ntests++;
+
+  test_cv (8,
+           "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+           "0100000000000000000000000000000000000000000000000000000000000000",
+           "0000000000000000000000000000000000000000000000000000000000000000");
+  ntests++;
+
+  test_cv (9,
+           "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+           "e0eb7a7c3b41b8ae1656e3faf19fc46ada098deb9c32b1fd866205165f49b800",
+           "0000000000000000000000000000000000000000000000000000000000000000");
+  ntests++;
+
+  test_cv (10,
+           "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+           "5f9c95bca3508c24b1d0b1559c83ef5b04445cc4581c8e86d8224eddd09f1157",
+           "0000000000000000000000000000000000000000000000000000000000000000");
+  ntests++;
+
+  test_cv (11,
+           "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+           "ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+           "0000000000000000000000000000000000000000000000000000000000000000");
+  ntests++;
+
+  test_cv (12,
+           "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+           "edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+           "0000000000000000000000000000000000000000000000000000000000000000");
+  ntests++;
+
+  test_cv (13,
+           "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+           "eeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+           "0000000000000000000000000000000000000000000000000000000000000000");
+  ntests++;
+
+  /* Five tests which resulted 0 if decodeUCoordinate didn't change MSB. */
+  test_cv (14,
+           "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+           "cdeb7a7c3b41b8ae1656e3faf19fc46ada098deb9c32b1fd866205165f49b880",
+           "7ce548bc4919008436244d2da7a9906528fe3a6d278047654bd32d8acde9707b");
+  ntests++;
+
+  test_cv (15,
+           "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+           "4c9c95bca3508c24b1d0b1559c83ef5b04445cc4581c8e86d8224eddd09f11d7",
+           "e17902e989a034acdf7248260e2c94cdaf2fe1e72aaac7024a128058b6189939");
+  ntests++;
+
+  test_cv (16,
+           "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+           "d9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+           "ea6e6ddf0685c31e152d5818441ac9ac8db1a01f3d6cb5041b07443a901e7145");
+  ntests++;
+
+  test_cv (17,
+           "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+           "daffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+           "845ddce7b3a9b3ee01a2f1fd4282ad293310f7a232cbc5459fb35d94bccc9d05");
+  ntests++;
+
+  test_cv (18,
+           "a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+           "dbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+           "6989e2cb1cea159acf121b0af6bf77493189c9bd32c2dac71669b540f9488247");
+  ntests++;
+
   if (ntests != N_TESTS)
     fail ("did %d tests but expected %d", ntests, N_TESTS);
   else if ((ntests % 256))
@@ -550,19 +553,19 @@ main (int argc, char **argv)
         die ("unknown option '%s'", *argv);
     }
 
-  gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+  xgcry_control (GCRYCTL_DISABLE_SECMEM, 0);
   if (!gcry_check_version (GCRYPT_VERSION))
     die ("version mismatch\n");
   if (debug)
-    gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
-  gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
-  gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
+    xgcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
+  xgcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+  xgcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
 
   start_timer ();
   check_cv25519 ();
   stop_timer ();
 
-  show ("All tests completed in %s.  Errors: %d\n",
+  info ("All tests completed in %s.  Errors: %d\n",
         elapsed_time (1), error_count);
   return !!error_count;
 }