Fixed spurious warning about old-style prototype.

[BearSSL] / test / test_crypto.c

diff --git a/test/test_crypto.c b/test/test_crypto.c
index c45eca6..c6c534d 100644 (file)
--- a/test/test_crypto.c
+++ b/test/test_crypto.c
@@ -6783,7 +6783,7 @@ test_RSA_keygen(const char *name, br_rsa_keygen kg, br_rsa_compute_modulus cm,
                uint32_t mod[256];
                uint32_t cc;
                size_t u, v;
-               unsigned char sig[257], hv[32], hv2[sizeof hv];
+               unsigned char sig[257], hv[32], hv2[32];
                unsigned mask1, mask2;
                int j;
 
@@ -8316,7 +8316,7 @@ test_EC_inner(const char *sk, const char *sU,
 static void
 test_EC_P256_carry_inner(const br_ec_impl *impl, const char *sP, const char *sQ)
 {
-       unsigned char P[65], Q[sizeof P], k[1];
+       unsigned char P[65], Q[65], k[1];
        size_t plen, qlen;
 
        plen = hextobin(P, sP);
@@ -8569,8 +8569,42 @@ test_EC_p256_m31(void)
                (uint32_t)1 << BR_EC_secp256r1);
 }
 
+static void
+test_EC_p256_m62(void)
+{
+       const br_ec_impl *ec;
+
+       ec = br_ec_p256_m62_get();
+       if (ec != NULL) {
+               test_EC_KAT("EC_p256_m62", ec,
+                       (uint32_t)1 << BR_EC_secp256r1);
+               test_EC_keygen("EC_p256_m62", ec,
+                       (uint32_t)1 << BR_EC_secp256r1);
+       } else {
+               printf("Test EC_p256_m62: UNAVAILABLE\n");
+               printf("Test EC_p256_m62 keygen: UNAVAILABLE\n");
+       }
+}
+
+static void
+test_EC_p256_m64(void)
+{
+       const br_ec_impl *ec;
+
+       ec = br_ec_p256_m64_get();
+       if (ec != NULL) {
+               test_EC_KAT("EC_p256_m64", ec,
+                       (uint32_t)1 << BR_EC_secp256r1);
+               test_EC_keygen("EC_p256_m64", ec,
+                       (uint32_t)1 << BR_EC_secp256r1);
+       } else {
+               printf("Test EC_p256_m64: UNAVAILABLE\n");
+               printf("Test EC_p256_m64 keygen: UNAVAILABLE\n");
+       }
+}
+
 const struct {
-       const char *scalar;
+       const char *scalar_le;
        const char *u_in;
        const char *u_out;
 } C25519_KAT[] = {
@@ -8583,6 +8617,20 @@ const struct {
        { 0, 0, 0 }
 };
 
+static void
+revbytes(unsigned char *buf, size_t len)
+{
+       size_t u;
+
+       for (u = 0; u < (len >> 1); u ++) {
+               unsigned t;
+
+               t = buf[u];
+               buf[u] = buf[len - 1 - u];
+               buf[len - 1 - u] = t;
+       }
+}
+
 static void
 test_EC_c25519(const char *name, const br_ec_impl *iec)
 {
@@ -8592,8 +8640,9 @@ test_EC_c25519(const char *name, const br_ec_impl *iec)
 
        printf("Test %s: ", name);
        fflush(stdout);
-       for (v = 0; C25519_KAT[v].scalar; v ++) {
-               hextobin(bk, C25519_KAT[v].scalar);
+       for (v = 0; C25519_KAT[v].scalar_le; v ++) {
+               hextobin(bk, C25519_KAT[v].scalar_le);
+               revbytes(bk, sizeof bk);
                hextobin(bu, C25519_KAT[v].u_in);
                hextobin(br, C25519_KAT[v].u_out);
                if (!iec->mul(bu, sizeof bu, bk, sizeof bk, BR_EC_curve25519)) {
@@ -8614,11 +8663,13 @@ test_EC_c25519(const char *name, const br_ec_impl *iec)
        bu[0] = 0x09;
        memcpy(bk, bu, sizeof bu);
        for (i = 1; i <= 1000; i ++) {
+               revbytes(bk, sizeof bk);
                if (!iec->mul(bu, sizeof bu, bk, sizeof bk, BR_EC_curve25519)) {
                        fprintf(stderr, "Curve25519 multiplication failed"
                                " (iter=%d)\n", i);
                        exit(EXIT_FAILURE);
                }
+               revbytes(bk, sizeof bk);
                for (v = 0; v < sizeof bu; v ++) {
                        unsigned t;
 
@@ -8681,6 +8732,38 @@ test_EC_c25519_m31(void)
                (uint32_t)1 << BR_EC_curve25519);
 }
 
+static void
+test_EC_c25519_m62(void)
+{
+       const br_ec_impl *ec;
+
+       ec = br_ec_c25519_m62_get();
+       if (ec != NULL) {
+               test_EC_c25519("EC_c25519_m62", ec);
+               test_EC_keygen("EC_c25519_m62", ec,
+                       (uint32_t)1 << BR_EC_curve25519);
+       } else {
+               printf("Test EC_c25519_m62: UNAVAILABLE\n");
+               printf("Test EC_c25519_m62 keygen: UNAVAILABLE\n");
+       }
+}
+
+static void
+test_EC_c25519_m64(void)
+{
+       const br_ec_impl *ec;
+
+       ec = br_ec_c25519_m64_get();
+       if (ec != NULL) {
+               test_EC_c25519("EC_c25519_m64", ec);
+               test_EC_keygen("EC_c25519_m64", ec,
+                       (uint32_t)1 << BR_EC_curve25519);
+       } else {
+               printf("Test EC_c25519_m64: UNAVAILABLE\n");
+               printf("Test EC_c25519_m64 keygen: UNAVAILABLE\n");
+       }
+}
+
 static const unsigned char EC_P256_PUB_POINT[] = {
        0x04, 0x60, 0xFE, 0xD4, 0xBA, 0x25, 0x5A, 0x9D,
        0x31, 0xC9, 0x61, 0xEB, 0x74, 0xC6, 0x35, 0x6D,
@@ -9348,10 +9431,14 @@ static const struct {
        STU(EC_prime_i31),
        STU(EC_p256_m15),
        STU(EC_p256_m31),
+       STU(EC_p256_m62),
+       STU(EC_p256_m64),
        STU(EC_c25519_i15),
        STU(EC_c25519_i31),
        STU(EC_c25519_m15),
        STU(EC_c25519_m31),
+       STU(EC_c25519_m62),
+       STU(EC_c25519_m64),
        STU(ECDSA_i15),
        STU(ECDSA_i31),
        STU(modpow_i31),