SipHash: add separate setter for the hash size

[openssl.git] / test / siphash_internal_test.c

diff --git a/test/siphash_internal_test.c b/test/siphash_internal_test.c
index eee4736285c5e002d6bf6b1802a46b77bee5d1b6..dfdce48d1306757fbba1aacd64cf4ba2b012069b 100644 (file)
--- a/test/siphash_internal_test.c
+++ b/test/siphash_internal_test.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright 2016-2017 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.

  *
  * Licensed under the OpenSSL license (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
  *
  * Licensed under the OpenSSL license (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy


@@ -14,13 +14,9 @@
 
 #include <openssl/bio.h>
 #include "testutil.h"
 
 #include <openssl/bio.h>
 #include "testutil.h"

-#include "test_main_custom.h"

 #include "internal/siphash.h"
 #include "../crypto/siphash/siphash_local.h"
 #include "internal/siphash.h"
 #include "../crypto/siphash/siphash_local.h"

-#include "e_os.h"
-
-static BIO* b_stderr = NULL;
-static BIO* b_stdout = NULL;
+#include "internal/nelem.h"

 
 typedef struct {
     size_t size;
 
 typedef struct {
     size_t size;


@@ -38,47 +34,6 @@ typedef struct {
  *
  ***/
 
  *
  ***/
 

-static int benchmark_siphash(void)
-{
-# ifdef OPENSSL_CPUID_OBJ
-    SIPHASH siphash;
-    unsigned char key[SIPHASH_KEY_SIZE];
-    unsigned char buf[8192];
-    unsigned long long stopwatch;
-    unsigned long long OPENSSL_rdtsc();
-    unsigned int i;
-
-    memset (buf,0x55,sizeof(buf));
-    memset (key,0xAA,sizeof(key));
-
-    (void)SipHash_Init(&siphash, key, 0, 0, 0);
-
-    for (i=0;i<100000;i++)
-        SipHash_Update(&siphash, buf, sizeof(buf));
-
-    stopwatch = OPENSSL_rdtsc();
-    for (i=0;i<10000;i++)
-        SipHash_Update(&siphash, buf, sizeof(buf));
-    stopwatch = OPENSSL_rdtsc() - stopwatch;
-
-    BIO_printf(b_stdout, "%g\n",stopwatch/(double)(i*sizeof(buf)));
-
-    stopwatch = OPENSSL_rdtsc();
-    for (i=0;i<10000;i++) {
-        (void)SipHash_Init(&siphash, key, 0, 0, 0);
-        SipHash_Update(&siphash, buf, 16);
-        (void)SipHash_Final(&siphash, buf, SIPHASH_MAX_DIGEST_SIZE);
-    }
-    stopwatch = OPENSSL_rdtsc() - stopwatch;
-
-    BIO_printf(b_stdout, "%g\n",stopwatch/(double)(i));
-# else
-    BIO_printf(b_stderr,
-               "Benchmarking of siphash isn't available on this platform\n");
-# endif
-    return 1;
-}
-

 /* From C reference: https://131002.net/siphash/ */
 
 static TESTDATA tests[] = {
 /* From C reference: https://131002.net/siphash/ */
 
 static TESTDATA tests[] = {


@@ -212,18 +167,6 @@ static TESTDATA tests[] = {
     { 63, { 16, { 0x51, 0x50, 0xd1, 0x77, 0x2f, 0x50, 0x83, 0x4a, 0x50, 0x3e, 0x06, 0x9a, 0x97, 0x3f, 0xbd, 0x7c, } } }
 };
 
     { 63, { 16, { 0x51, 0x50, 0xd1, 0x77, 0x2f, 0x50, 0x83, 0x4a, 0x50, 0x3e, 0x06, 0x9a, 0x97, 0x3f, 0xbd, 0x7c, } } }
 };
 

-static void hex_out(BIO *b, char *prefix, int width, unsigned char* data, size_t n)
-{
-    /*
-     * this could be modified to handle multiple lines, but as it is
-     * used here, this only displays up to 16 bytes
-     */
-    BIO_printf(b, "%s", prefix);
-    BIO_hex_string(b, 0, width, data, n);
-    BIO_printf(b, "\n");
-}
-
-

 static int test_siphash(int idx)
 {
     SIPHASH siphash;
 static int test_siphash(int idx)
 {
     SIPHASH siphash;


@@ -237,52 +180,41 @@ static int test_siphash(int idx)
     size_t i;
 
     if (expectedlen != SIPHASH_MIN_DIGEST_SIZE &&
     size_t i;
 
     if (expectedlen != SIPHASH_MIN_DIGEST_SIZE &&

-        expectedlen != SIPHASH_MAX_DIGEST_SIZE)
+        expectedlen != SIPHASH_MAX_DIGEST_SIZE) {
+        TEST_info("size %zu vs %d and %d", expectedlen,
+                  SIPHASH_MIN_DIGEST_SIZE, SIPHASH_MAX_DIGEST_SIZE);

         return 0;
         return 0;

+    }

 
 

-    if (inlen > sizeof(in))
+    if (!TEST_int_le(inlen, sizeof(in)))

         return 0;
 
     /* key and in data are 00 01 02 ... */
     for (i = 0; i < sizeof(key); i++)
         return 0;
 
     /* key and in data are 00 01 02 ... */
     for (i = 0; i < sizeof(key); i++)

-        key[i] = i;
+        key[i] = (unsigned char)i;

 
     for (i = 0; i < inlen; i++)
 
     for (i = 0; i < inlen; i++)

-        in[i] = i;
+        in[i] = (unsigned char)i;

 
 

-    if (!SipHash_Init(&siphash, key, expectedlen, 0, 0)) {
-        BIO_printf(b_stderr, "SipHash_Init failed\n");
+    if (!TEST_true(SipHash_set_hash_size(&siphash, expectedlen))
+        || !TEST_true(SipHash_Init(&siphash, key, 0, 0)))

         return 0;
         return 0;

-    }

     SipHash_Update(&siphash, in, inlen);
     SipHash_Update(&siphash, in, inlen);

-    if (!SipHash_Final(&siphash, out, expectedlen)) {
-        BIO_printf(b_stderr, "SipHash_Final failed\n");
+    if (!TEST_true(SipHash_Final(&siphash, out, expectedlen))
+        || !TEST_mem_eq(out, expectedlen, expected, expectedlen))

         return 0;
         return 0;

-    }
-
-    if (memcmp(out, expected, expectedlen) != 0) {
-        BIO_printf(b_stderr, "SipHash test #%d failed.\n", idx);
-        hex_out(b_stderr, "got:      ", 16, out, expectedlen);
-        hex_out(b_stderr, "expected: ", 16, expected, expectedlen);
-        return 0;
-    }

 
     if (inlen > 16) {
 
     if (inlen > 16) {

-        if (!SipHash_Init(&siphash, key, expectedlen, 0, 0)) {
-            BIO_printf(b_stderr, "SipHash_Init failed\n");
+        if (!TEST_true(SipHash_set_hash_size(&siphash, expectedlen))
+            || !TEST_true(SipHash_Init(&siphash, key, 0, 0)))

             return 0;
             return 0;

-        }

         SipHash_Update(&siphash, in, 1);
         SipHash_Update(&siphash, in+1, inlen-1);
         SipHash_Update(&siphash, in, 1);
         SipHash_Update(&siphash, in+1, inlen-1);

-        if (!SipHash_Final(&siphash, out, expectedlen)) {
-            BIO_printf(b_stderr, "SipHash_Final failed\n");
+        if (!TEST_true(SipHash_Final(&siphash, out, expectedlen)))

             return 0;
             return 0;

-        }

 
 

-        if (memcmp(out, expected, expectedlen) != 0) {
-            BIO_printf(b_stderr, "SipHash test #%d/1+(N-1) failed.\n", idx);
-            hex_out(b_stderr, "got:      ", 16, out, expectedlen);
-            hex_out(b_stderr, "expected: ", 16, expected, expectedlen);
+        if (!TEST_mem_eq(out, expectedlen, expected, expectedlen)) {
+            TEST_info("SipHash test #%d/1+(N-1) failed.", idx);

             return 0;
         }
     }
             return 0;
         }
     }


@@ -290,41 +222,31 @@ static int test_siphash(int idx)
     if (inlen > 32) {
         size_t half = inlen / 2;
 
     if (inlen > 32) {
         size_t half = inlen / 2;
 

-        if (!SipHash_Init(&siphash, key, expectedlen, 0, 0)) {
-            BIO_printf(b_stderr, "SipHash_Init failed\n");
+        if (!TEST_true(SipHash_set_hash_size(&siphash, expectedlen))
+            || !TEST_true(SipHash_Init(&siphash, key, 0, 0)))

             return 0;
             return 0;

-        }

         SipHash_Update(&siphash, in, half);
         SipHash_Update(&siphash, in+half, inlen-half);
         SipHash_Update(&siphash, in, half);
         SipHash_Update(&siphash, in+half, inlen-half);

-        if (!SipHash_Final(&siphash, out, expectedlen)) {
-            BIO_printf(b_stderr, "SipHash_Final failed\n");
+        if (!TEST_true(SipHash_Final(&siphash, out, expectedlen)))

             return 0;
             return 0;

-        }

 
 

-        if (memcmp(out, expected, expectedlen) != 0) {
-            BIO_printf(b_stderr, "SipHash test #%d/2 failed.\n", idx);
-            hex_out(b_stderr, "got:      ", 16, out, expectedlen);
-            hex_out(b_stderr, "expected: ", 16, expected, expectedlen);
+        if (!TEST_mem_eq(out, expectedlen, expected, expectedlen)) {
+            TEST_info("SipHash test #%d/2 failed.", idx);

             return 0;
         }
 
         for (half = 16; half < inlen; half += 16) {
             return 0;
         }
 
         for (half = 16; half < inlen; half += 16) {

-            if (!SipHash_Init(&siphash, key, expectedlen, 0, 0)) {
-                BIO_printf(b_stderr, "SipHash_Init failed\n");
+            if (!TEST_true(SipHash_set_hash_size(&siphash, expectedlen))
+                || !TEST_true(SipHash_Init(&siphash, key, 0, 0)))

                 return 0;
                 return 0;

-            }

             SipHash_Update(&siphash, in, half);
             SipHash_Update(&siphash, in+half, inlen-half);
             SipHash_Update(&siphash, in, half);
             SipHash_Update(&siphash, in+half, inlen-half);

-            if (!SipHash_Final(&siphash, out, expectedlen)) {
-                BIO_printf(b_stderr, "SipHash_Final failed\n");
+            if (!TEST_true(SipHash_Final(&siphash, out, expectedlen)))

                 return 0;
                 return 0;

-            }

 
 

-            if (memcmp(out, expected, expectedlen) != 0) {
-                BIO_printf(b_stderr, "SipHash test #%d/%zu+%zu failed.\n",
-                       idx, half, inlen-half);
-                hex_out(b_stderr, "got:      ", 16, out, expectedlen);
-                hex_out(b_stderr, "expected: ", 16, expected, expectedlen);
+            if (!TEST_mem_eq(out, expectedlen, expected, expectedlen)) {
+                TEST_info("SipHash test #%d/%zu+%zu failed.",
+                          idx, half, inlen-half);

                 return 0;
             }
         }
                 return 0;
             }
         }


@@ -340,92 +262,29 @@ static int test_siphash_basic(void)
     unsigned char output[SIPHASH_MAX_DIGEST_SIZE];
 
     /* Use invalid hash size */
     unsigned char output[SIPHASH_MAX_DIGEST_SIZE];
 
     /* Use invalid hash size */

-    if (SipHash_Init(&siphash, key, 4, 0, 0)) {
-        BIO_printf(b_stderr, "SipHash_Init(output size = 4) should have failed\n");
-        return 0;
-    }
-
-    /* Use hash size = 8 */
-    if (!SipHash_Init(&siphash, key, 8, 0, 0)) {
-        BIO_printf(b_stderr, "SipHash_Init(output size = 8) should have succeeded\n");
-        return 0;
-    }
-    if (!SipHash_Final(&siphash, output, 8)) {
-        BIO_printf(b_stderr, "SipHash_Final(output size = 8) should have succeeded\n");
-        return 0;
-    }
-    if (SipHash_Final(&siphash, output, 16)) {
-        BIO_printf(b_stderr, "SipHash_Final(output size = 16) should have failed\n");
-        return 0;
-    }
-
-    /* Use hash size = 16 */
-    if (!SipHash_Init(&siphash, key, 16, 0, 0)) {
-        BIO_printf(b_stderr, "SipHash_Init(output size = 16) should have succeeded\n");
-        return 0;
-    }
-    if (SipHash_Final(&siphash, output, 8)) {
-        BIO_printf(b_stderr, "SipHash_Final(output size = 8) should have failed\n");
-        return 0;
-    }
-    if (!SipHash_Final(&siphash, output, 16)) {
-        BIO_printf(b_stderr, "SipHash_Final(output size = 16) should have succeeded\n");
-        return 0;
-    }
-
-    /* Use hash size = 0 (default = 16) */
-    if (!SipHash_Init(&siphash, key, 0, 0, 0)) {
-        BIO_printf(b_stderr, "SipHash_Init(output size = 0) should have succeeded\n");
-        return 0;
-    }
-    if (SipHash_Final(&siphash, output, 8)) {
-        BIO_printf(b_stderr, "SipHash_Final(output size = 8) should have failed\n");
-        return 0;
-    }
-    if (!SipHash_Final(&siphash, output, 16)) {
-        BIO_printf(b_stderr, "SipHash_Final(output size = 16) should have succeeded\n");
-        return 0;
-    }
-    return 1;
+    return TEST_int_eq(SipHash_set_hash_size(&siphash, 4), 0)
+           /* Use hash size = 8 */
+           && TEST_true(SipHash_set_hash_size(&siphash, 8))
+           && TEST_true(SipHash_Init(&siphash, key, 0, 0))
+           && TEST_true(SipHash_Final(&siphash, output, 8))
+           && TEST_int_eq(SipHash_Final(&siphash, output, 16), 0)
+
+           /* Use hash size = 16 */
+           && TEST_true(SipHash_set_hash_size(&siphash, 16))
+           && TEST_true(SipHash_Init(&siphash, key, 0, 0))
+           && TEST_int_eq(SipHash_Final(&siphash, output, 8), 0)
+           && TEST_true(SipHash_Final(&siphash, output, 16))
+
+           /* Use hash size = 0 (default = 16) */
+           && TEST_true(SipHash_set_hash_size(&siphash, 0))
+           && TEST_true(SipHash_Init(&siphash, key, 0, 0))
+           && TEST_int_eq(SipHash_Final(&siphash, output, 8), 0)
+           && TEST_true(SipHash_Final(&siphash, output, 16));

 }
 
 }
 

-
-
-int test_main(int argc, char **argv)
+int setup_tests(void)

 {
 {

-    int result = 0;
-    int iter_argv;
-    int benchmark = 0;
-
-    b_stderr = BIO_new_fp(stderr, BIO_NOCLOSE | BIO_FP_TEXT);
-    b_stdout = BIO_new_fp(stdout, BIO_NOCLOSE | BIO_FP_TEXT);
-#ifdef OPENSSL_SYS_VMS
-    b_stderr = BIO_push(BIO_new(BIO_f_linebuffer()), b_stderr);
-    b_stdout = BIO_push(BIO_new(BIO_f_linebuffer()), b_stdout);
-#endif
-
-    for (iter_argv = 1; iter_argv < argc; iter_argv++) {
-        if (strcmp(argv[iter_argv], "-b") == 0)
-            benchmark = 1;
-        else if (strcmp(argv[iter_argv], "-h") == 0)
-            goto help;
-    }
-

     ADD_TEST(test_siphash_basic);
     ADD_ALL_TESTS(test_siphash, OSSL_NELEM(tests));
     ADD_TEST(test_siphash_basic);
     ADD_ALL_TESTS(test_siphash, OSSL_NELEM(tests));

-    if (benchmark)
-        ADD_TEST(benchmark_siphash);
-
-    result = run_tests(argv[0]);
-    goto out;
-
- help:
-    BIO_printf(b_stdout, "-h\tThis help\n");
-    BIO_printf(b_stdout, "-b\tBenchmark in addition to the tests\n");
-
- out:
-    BIO_free(b_stdout);
-    BIO_free(b_stderr);
-
-    return result;
+    return 1;

 }
 }