Finish porting dh_test.cc and ripemd_test.cc to GTest.
They're the only two half-finished ports left, so we may as well finish
that up and trim them down a little.
Change-Id: Ic058124a44086161ab5d2d6fa24448492c3ba219
Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/55506
Auto-Submit: David Benjamin <davidben@google.com>
Commit-Queue: Bob Beck <bbe@google.com>
Reviewed-by: Bob Beck <bbe@google.com>
diff --git a/crypto/dh_extra/dh_test.cc b/crypto/dh_extra/dh_test.cc
index b88702b..7a17070 100644
--- a/crypto/dh_extra/dh_test.cc
+++ b/crypto/dh_extra/dh_test.cc
@@ -75,126 +75,41 @@
#include "../test/test_util.h"
-static bool RunBasicTests();
-static bool TestBadY();
-static bool TestASN1();
-static bool TestRFC3526();
-
-// TODO(davidben): Convert this file to GTest properly.
-TEST(DHTest, AllTests) {
- if (!RunBasicTests() ||
- !TestBadY() ||
- !TestASN1() ||
- !TestRFC3526()) {
- ADD_FAILURE() << "Tests failed.";
- }
-}
-
-static int GenerateCallback(int p, int n, BN_GENCB *arg) {
- char c = '*';
-
- if (p == 0) {
- c = '.';
- } else if (p == 1) {
- c = '+';
- } else if (p == 2) {
- c = '*';
- } else if (p == 3) {
- c = '\n';
- }
- FILE *out = reinterpret_cast<FILE*>(arg->arg);
- fputc(c, out);
- fflush(out);
-
- return 1;
-}
-
-static bool RunBasicTests() {
- BN_GENCB cb;
- BN_GENCB_set(&cb, &GenerateCallback, stdout);
+TEST(DHTest, Basic) {
bssl::UniquePtr<DH> a(DH_new());
- if (!a || !DH_generate_parameters_ex(a.get(), 64, DH_GENERATOR_5, &cb)) {
- return false;
- }
+ ASSERT_TRUE(a);
+ ASSERT_TRUE(DH_generate_parameters_ex(a.get(), 64, DH_GENERATOR_5, nullptr));
int check_result;
- if (!DH_check(a.get(), &check_result)) {
- return false;
- }
- if (check_result & DH_CHECK_P_NOT_PRIME) {
- printf("p value is not prime\n");
- }
- if (check_result & DH_CHECK_P_NOT_SAFE_PRIME) {
- printf("p value is not a safe prime\n");
- }
- if (check_result & DH_CHECK_UNABLE_TO_CHECK_GENERATOR) {
- printf("unable to check the generator value\n");
- }
- if (check_result & DH_CHECK_NOT_SUITABLE_GENERATOR) {
- printf("the g value is not a generator\n");
- }
-
- printf("\np = ");
- BN_print_fp(stdout, DH_get0_p(a.get()));
- printf("\ng = ");
- BN_print_fp(stdout, DH_get0_g(a.get()));
- printf("\n");
+ ASSERT_TRUE(DH_check(a.get(), &check_result));
+ EXPECT_FALSE(check_result & DH_CHECK_P_NOT_PRIME);
+ EXPECT_FALSE(check_result & DH_CHECK_P_NOT_SAFE_PRIME);
+ EXPECT_FALSE(check_result & DH_CHECK_UNABLE_TO_CHECK_GENERATOR);
+ EXPECT_FALSE(check_result & DH_CHECK_NOT_SUITABLE_GENERATOR);
bssl::UniquePtr<DH> b(DHparams_dup(a.get()));
- if (!b) {
- return false;
- }
+ ASSERT_TRUE(b);
- if (!DH_generate_key(a.get())) {
- return false;
- }
- printf("pri1 = ");
- BN_print_fp(stdout, DH_get0_priv_key(a.get()));
- printf("\npub1 = ");
- BN_print_fp(stdout, DH_get0_pub_key(a.get()));
- printf("\n");
-
- if (!DH_generate_key(b.get())) {
- return false;
- }
- printf("pri2 = ");
- BN_print_fp(stdout, DH_get0_priv_key(b.get()));
- printf("\npub2 = ");
- BN_print_fp(stdout, DH_get0_pub_key(b.get()));
- printf("\n");
+ ASSERT_TRUE(DH_generate_key(a.get()));
+ ASSERT_TRUE(DH_generate_key(b.get()));
std::vector<uint8_t> key1(DH_size(a.get()));
int ret = DH_compute_key(key1.data(), DH_get0_pub_key(b.get()), a.get());
- if (ret < 0) {
- return false;
- }
+ ASSERT_GE(ret, 0);
key1.resize(ret);
- printf("key1 = ");
- for (size_t i = 0; i < key1.size(); i++) {
- printf("%02x", key1[i]);
- }
- printf("\n");
-
std::vector<uint8_t> key2(DH_size(b.get()));
ret = DH_compute_key(key2.data(), DH_get0_pub_key(a.get()), b.get());
- if (ret < 0) {
- return false;
- }
+ ASSERT_GE(ret, 0);
key2.resize(ret);
- printf("key2 = ");
- for (size_t i = 0; i < key2.size(); i++) {
- printf("%02x", key2[i]);
- }
- printf("\n");
+ EXPECT_EQ(Bytes(key1), Bytes(key2));
- if (key1.size() < 4 || key1 != key2) {
- fprintf(stderr, "Error in DH routines\n");
- return false;
- }
-
- return true;
+ // |DH_compute_key|, unlike |DH_compute_key_padded|, removes leading zeros
+ // from the output, so the key will not have a fixed length. This test uses a
+ // small, 64-bit prime, so check for at least 32 bits of output after removing
+ // leading zeros.
+ EXPECT_GE(key1.size(), 4u);
}
// The following parameters are taken from RFC 5114, section 2.2. This is not a
@@ -280,38 +195,30 @@
0x93, 0x74, 0x89, 0x59,
};
-static bool TestBadY() {
+TEST(DHTest, BadY) {
bssl::UniquePtr<DH> dh(DH_new());
+ ASSERT_TRUE(dh);
dh->p = BN_bin2bn(kRFC5114_2048_224P, sizeof(kRFC5114_2048_224P), nullptr);
dh->g = BN_bin2bn(kRFC5114_2048_224G, sizeof(kRFC5114_2048_224G), nullptr);
dh->q = BN_bin2bn(kRFC5114_2048_224Q, sizeof(kRFC5114_2048_224Q), nullptr);
- if (!dh->p || !dh->g || !dh->q) {
- return false;
- }
+ ASSERT_TRUE(dh->p);
+ ASSERT_TRUE(dh->g);
+ ASSERT_TRUE(dh->q);
bssl::UniquePtr<BIGNUM> pub_key(
BN_bin2bn(kRFC5114_2048_224BadY, sizeof(kRFC5114_2048_224BadY), nullptr));
- if (!dh || !pub_key || !DH_generate_key(dh.get())) {
- return false;
- }
+ ASSERT_TRUE(pub_key);
+ ASSERT_TRUE(DH_generate_key(dh.get()));
int flags;
- if (!DH_check_pub_key(dh.get(), pub_key.get(), &flags)) {
- return false;
- }
- if (!(flags & DH_CHECK_PUBKEY_INVALID)) {
- fprintf(stderr, "DH_check_pub_key did not reject the key.\n");
- return false;
- }
+ ASSERT_TRUE(DH_check_pub_key(dh.get(), pub_key.get(), &flags));
+ EXPECT_TRUE(flags & DH_CHECK_PUBKEY_INVALID)
+ << "DH_check_pub_key did not reject the key";
std::vector<uint8_t> result(DH_size(dh.get()));
- if (DH_compute_key(result.data(), pub_key.get(), dh.get()) >= 0) {
- fprintf(stderr, "DH_compute_key unexpectedly succeeded.\n");
- return false;
- }
+ EXPECT_LT(DH_compute_key(result.data(), pub_key.get(), dh.get()), 0)
+ << "DH_compute_key unexpectedly succeeded";
ERR_clear_error();
-
- return true;
}
static bool BIGNUMEqualsHex(const BIGNUM *bn, const char *hex) {
@@ -323,7 +230,7 @@
return BN_cmp(bn, hex_bn) == 0;
}
-static bool TestASN1() {
+TEST(DHTest, ASN1) {
// kParams are a set of Diffie-Hellman parameters generated with
// openssl dhparam 256
static const uint8_t kParams[] = {
@@ -336,27 +243,22 @@
CBS cbs;
CBS_init(&cbs, kParams, sizeof(kParams));
bssl::UniquePtr<DH> dh(DH_parse_parameters(&cbs));
- if (!dh || CBS_len(&cbs) != 0 ||
- !BIGNUMEqualsHex(
- DH_get0_p(dh.get()),
- "d72034a3274fdfbf04fd246825b656d8ab2a412d740a52087c40714ed2579313") ||
- !BIGNUMEqualsHex(DH_get0_g(dh.get()), "2") || dh->priv_length != 0) {
- return false;
- }
+ ASSERT_TRUE(dh);
+ EXPECT_EQ(CBS_len(&cbs), 0u);
+ EXPECT_TRUE(BIGNUMEqualsHex(
+ DH_get0_p(dh.get()),
+ "d72034a3274fdfbf04fd246825b656d8ab2a412d740a52087c40714ed2579313"));
+ EXPECT_TRUE(BIGNUMEqualsHex(DH_get0_g(dh.get()), "2"));
+ EXPECT_EQ(dh->priv_length, 0u);
bssl::ScopedCBB cbb;
uint8_t *der;
size_t der_len;
- if (!CBB_init(cbb.get(), 0) ||
- !DH_marshal_parameters(cbb.get(), dh.get()) ||
- !CBB_finish(cbb.get(), &der, &der_len)) {
- return false;
- }
+ ASSERT_TRUE(CBB_init(cbb.get(), 0));
+ ASSERT_TRUE(DH_marshal_parameters(cbb.get(), dh.get()));
+ ASSERT_TRUE(CBB_finish(cbb.get(), &der, &der_len));
bssl::UniquePtr<uint8_t> free_der(der);
- if (der_len != sizeof(kParams) ||
- OPENSSL_memcmp(der, kParams, der_len) != 0) {
- return false;
- }
+ EXPECT_EQ(Bytes(kParams), Bytes(der, der_len));
// kParamsDSA are a set of Diffie-Hellman parameters generated with
// openssl dhparam 256 -dsaparam
@@ -377,38 +279,30 @@
CBS_init(&cbs, kParamsDSA, sizeof(kParamsDSA));
dh.reset(DH_parse_parameters(&cbs));
- if (!dh || CBS_len(&cbs) != 0 ||
- !BIGNUMEqualsHex(DH_get0_p(dh.get()),
- "93f3c11801e662b6d1469a2c72ea31d91810302863e2347d80caee8"
- "22b193c19bb42830270dddb8c03abe99cc4004d705f5203312ca467"
- "3451952aac11e26a55") ||
- !BIGNUMEqualsHex(DH_get0_g(dh.get()),
- "44c8105344323163d8d18c75c898533b5b4a2a0a09e7d03c5372a86"
- "b70419c267144fc7f0875e102ab7441e82a3d3c263309e48bb441ec"
- "a6a8ba1a078a77f55f") ||
- dh->priv_length != 160) {
- return false;
- }
+ ASSERT_TRUE(dh);
+ EXPECT_EQ(CBS_len(&cbs), 0u);
+ EXPECT_TRUE(
+ BIGNUMEqualsHex(DH_get0_p(dh.get()),
+ "93f3c11801e662b6d1469a2c72ea31d91810302863e2347d80caee8"
+ "22b193c19bb42830270dddb8c03abe99cc4004d705f5203312ca467"
+ "3451952aac11e26a55"));
+ EXPECT_TRUE(
+ BIGNUMEqualsHex(DH_get0_g(dh.get()),
+ "44c8105344323163d8d18c75c898533b5b4a2a0a09e7d03c5372a86"
+ "b70419c267144fc7f0875e102ab7441e82a3d3c263309e48bb441ec"
+ "a6a8ba1a078a77f55f"));
+ EXPECT_EQ(dh->priv_length, 160u);
- if (!CBB_init(cbb.get(), 0) ||
- !DH_marshal_parameters(cbb.get(), dh.get()) ||
- !CBB_finish(cbb.get(), &der, &der_len)) {
- return false;
- }
+ ASSERT_TRUE(CBB_init(cbb.get(), 0));
+ ASSERT_TRUE(DH_marshal_parameters(cbb.get(), dh.get()));
+ ASSERT_TRUE(CBB_finish(cbb.get(), &der, &der_len));
bssl::UniquePtr<uint8_t> free_der2(der);
- if (der_len != sizeof(kParamsDSA) ||
- OPENSSL_memcmp(der, kParamsDSA, der_len) != 0) {
- return false;
- }
-
- return true;
+ EXPECT_EQ(Bytes(kParamsDSA), Bytes(der, der_len));
}
-static bool TestRFC3526() {
+TEST(DHTest, RFC3526) {
bssl::UniquePtr<BIGNUM> bn(BN_get_rfc3526_prime_1536(nullptr));
- if (!bn) {
- return false;
- }
+ ASSERT_TRUE(bn);
static const uint8_t kPrime1536[] = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc9, 0x0f, 0xda, 0xa2,
@@ -430,14 +324,9 @@
};
uint8_t buffer[sizeof(kPrime1536)];
- if (BN_num_bytes(bn.get()) != sizeof(kPrime1536) ||
- BN_bn2bin(bn.get(), buffer) != sizeof(kPrime1536) ||
- OPENSSL_memcmp(buffer, kPrime1536, sizeof(kPrime1536)) != 0) {
- fprintf(stderr, "1536-bit MODP prime did not match.\n");
- return false;
- }
-
- return true;
+ ASSERT_EQ(BN_num_bytes(bn.get()), sizeof(kPrime1536));
+ ASSERT_EQ(BN_bn2bin(bn.get(), buffer), sizeof(kPrime1536));
+ EXPECT_EQ(Bytes(buffer), Bytes(kPrime1536));
}
TEST(DHTest, LeadingZeros) {
diff --git a/decrepit/ripemd/ripemd_test.cc b/decrepit/ripemd/ripemd_test.cc
index 0700bae..6338fec 100644
--- a/decrepit/ripemd/ripemd_test.cc
+++ b/decrepit/ripemd/ripemd_test.cc
@@ -57,17 +57,13 @@
// TODO(davidben): Convert this file to GTest properly.
TEST(RIPEMDTest, RunTest) {
- unsigned test_num = 0;
- int ok = 1;
-
for (const auto &test : kRIPEMDTestCases) {
- test_num++;
-
+ SCOPED_TRACE(test.input);
const size_t input_len = strlen(test.input);
for (size_t stride = 0; stride <= input_len; stride++) {
+ SCOPED_TRACE(stride);
uint8_t digest[RIPEMD160_DIGEST_LENGTH];
-
if (stride == 0) {
RIPEMD160(reinterpret_cast<const uint8_t *>(test.input), input_len,
digest);
@@ -89,12 +85,7 @@
RIPEMD160_Final(digest, &ctx);
}
- if (OPENSSL_memcmp(digest, test.expected, sizeof(digest)) != 0) {
- fprintf(stderr, "#%u: bad result with stride %u: ", test_num,
- static_cast<unsigned>(stride));
- hexdump(stderr, "", digest, sizeof(digest));
- ok = 0;
- }
+ EXPECT_EQ(Bytes(digest), Bytes(test.expected));
}
}
@@ -107,12 +98,6 @@
static const uint8_t kMillionADigest[RIPEMD160_DIGEST_LENGTH] = {
0x52, 0x78, 0x32, 0x43, 0xc1, 0x69, 0x7b, 0xdb, 0xe1, 0x6d,
0x37, 0xf9, 0x7f, 0x68, 0xf0, 0x83, 0x25, 0xdc, 0x15, 0x28};
-
- if (OPENSSL_memcmp(digest, kMillionADigest, sizeof(digest)) != 0) {
- fprintf(stderr, u8"Digest incorrect for “million a's” test: ");
- hexdump(stderr, "", digest, sizeof(digest));
- ok = 0;
- }
-
- EXPECT_EQ(1, ok);
+ EXPECT_EQ(Bytes(digest), Bytes(kMillionADigest))
+ << "Digest incorrect for \"million a's\" test";
}
