diff options
author | Matt Braithwaite <mab@google.com> | 2016-08-18 06:10:28 +0300 |
---|---|---|
committer | CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org> | 2016-09-02 01:22:54 +0300 |
commit | d17d74d73f8a008f5e7ca6a64257b3c3a99d1bb4 (patch) | |
tree | 77f0a84c6ddac2344a2bbcc9daff73f7233ddc1c /crypto | |
parent | bc61769e49df6c84de636051ecd8b8104c07caf4 (diff) |
Replace Scoped* heap types with bssl::UniquePtr.
Unlike the Scoped* types, bssl::UniquePtr is available to C++ users, and
offered for a large variety of types. The 'extern "C++"' trick is used
to make the C++ bits digestible to C callers that wrap header files in
'extern "C"'.
Change-Id: Ifbca4c2997d6628e33028c7d7620c72aff0f862e
Reviewed-on: https://boringssl-review.googlesource.com/10521
Reviewed-by: David Benjamin <davidben@google.com>
Commit-Queue: David Benjamin <davidben@google.com>
CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
Diffstat (limited to 'crypto')
-rw-r--r-- | crypto/asn1/asn1_test.cc | 4 | ||||
-rw-r--r-- | crypto/bio/bio_test.cc | 15 | ||||
-rw-r--r-- | crypto/bn/bn_test.cc | 190 | ||||
-rw-r--r-- | crypto/bytestring/bytestring_test.cc | 19 | ||||
-rw-r--r-- | crypto/cmac/cmac_test.cc | 5 | ||||
-rw-r--r-- | crypto/curve25519/spake25519_test.cc | 5 | ||||
-rw-r--r-- | crypto/dh/dh_test.cc | 25 | ||||
-rw-r--r-- | crypto/ec/ec_test.cc | 72 | ||||
-rw-r--r-- | crypto/ecdh/ecdh_test.cc | 35 | ||||
-rw-r--r-- | crypto/ecdsa/ecdsa_sign_test.cc | 41 | ||||
-rw-r--r-- | crypto/ecdsa/ecdsa_test.cc | 16 | ||||
-rw-r--r-- | crypto/ecdsa/ecdsa_verify_test.cc | 33 | ||||
-rw-r--r-- | crypto/evp/evp_extra_test.cc | 31 | ||||
-rw-r--r-- | crypto/evp/evp_test.cc | 9 | ||||
-rw-r--r-- | crypto/newhope/newhope_statistical_test.cc | 4 | ||||
-rw-r--r-- | crypto/newhope/newhope_test.cc | 7 | ||||
-rw-r--r-- | crypto/newhope/newhope_vectors_test.cc | 11 | ||||
-rw-r--r-- | crypto/pkcs8/pkcs12_test.cc | 16 | ||||
-rw-r--r-- | crypto/pkcs8/pkcs8_test.cc | 6 | ||||
-rw-r--r-- | crypto/rsa/rsa_test.cc | 32 | ||||
-rw-r--r-- | crypto/test/scoped_types.h | 133 | ||||
-rw-r--r-- | crypto/x509/x509_test.cc | 55 |
22 files changed, 311 insertions, 453 deletions
diff --git a/crypto/asn1/asn1_test.cc b/crypto/asn1/asn1_test.cc index 8b024427..77a1ee0d 100644 --- a/crypto/asn1/asn1_test.cc +++ b/crypto/asn1/asn1_test.cc @@ -18,8 +18,6 @@ #include <openssl/crypto.h> #include <openssl/err.h> -#include "../test/scoped_types.h" - // kTag128 is an ASN.1 structure with a universal tag with number 128. static const uint8_t kTag128[] = { @@ -42,7 +40,7 @@ static const uint8_t kTagOverflow[] = { static bool TestLargeTags() { const uint8_t *p = kTag258; - ScopedASN1_TYPE obj(d2i_ASN1_TYPE(NULL, &p, sizeof(kTag258))); + bssl::UniquePtr<ASN1_TYPE> obj(d2i_ASN1_TYPE(NULL, &p, sizeof(kTag258))); if (obj) { fprintf(stderr, "Parsed value with illegal tag (type = %d).\n", obj->type); return false; diff --git a/crypto/bio/bio_test.cc b/crypto/bio/bio_test.cc index d7be884e..cbc4fde8 100644 --- a/crypto/bio/bio_test.cc +++ b/crypto/bio/bio_test.cc @@ -41,7 +41,6 @@ OPENSSL_MSVC_PRAGMA(warning(pop)) #include <algorithm> #include "../internal.h" -#include "../test/scoped_types.h" #if !defined(OPENSSL_WINDOWS) @@ -104,7 +103,7 @@ static bool TestSocketConnect() { char hostname[80]; BIO_snprintf(hostname, sizeof(hostname), "%s:%d", "127.0.0.1", ntohs(sin.sin_port)); - ScopedBIO bio(BIO_new_connect(hostname)); + bssl::UniquePtr<BIO> bio(BIO_new_connect(hostname)); if (!bio) { fprintf(stderr, "BIO_new_connect failed.\n"); return false; @@ -216,8 +215,8 @@ static bool TestZeroCopyBioPairs() { if (!BIO_new_bio_pair(&bio1, kBufferSize, &bio2, kBufferSize)) { return false; } - ScopedBIO bio1_scoper(bio1); - ScopedBIO bio2_scoper(bio2); + bssl::UniquePtr<BIO> bio1_scoper(bio1); + bssl::UniquePtr<BIO> bio2_scoper(bio2); total_write += BioWriteZeroCopyWrapper( bio1, bio1_application_send_buffer, kLengths[i]); @@ -287,7 +286,7 @@ static bool TestPrintf() { // 256 (the size of the buffer) to ensure edge cases are correct. static const size_t kLengths[] = { 5, 250, 251, 252, 253, 254, 1023 }; - ScopedBIO bio(BIO_new(BIO_s_mem())); + bssl::UniquePtr<BIO> bio(BIO_new(BIO_s_mem())); if (!bio) { fprintf(stderr, "BIO_new failed\n"); return false; @@ -331,7 +330,7 @@ static bool TestPrintf() { static bool ReadASN1(bool should_succeed, const uint8_t *data, size_t data_len, size_t expected_len, size_t max_len) { - ScopedBIO bio(BIO_new_mem_buf(data, data_len)); + bssl::UniquePtr<BIO> bio(BIO_new_mem_buf(data, data_len)); uint8_t *out; size_t out_len; @@ -339,7 +338,7 @@ static bool ReadASN1(bool should_succeed, const uint8_t *data, size_t data_len, if (!ok) { out = nullptr; } - ScopedOpenSSLBytes out_storage(out); + bssl::UniquePtr<uint8_t> out_storage(out); if (should_succeed != (ok == 1)) { return false; @@ -369,7 +368,7 @@ static bool TestASN1() { static const size_t kLargePayloadLen = 8000; static const uint8_t kLargePrefix[] = {0x30, 0x82, kLargePayloadLen >> 8, kLargePayloadLen & 0xff}; - ScopedOpenSSLBytes large(reinterpret_cast<uint8_t *>( + bssl::UniquePtr<uint8_t> large(reinterpret_cast<uint8_t *>( OPENSSL_malloc(sizeof(kLargePrefix) + kLargePayloadLen))); if (!large) { return false; diff --git a/crypto/bn/bn_test.cc b/crypto/bn/bn_test.cc index bb83a407..0867dec2 100644 --- a/crypto/bn/bn_test.cc +++ b/crypto/bn/bn_test.cc @@ -81,30 +81,30 @@ #include <utility> #include <openssl/bn.h> +#include <openssl/bytestring.h> #include <openssl/crypto.h> #include <openssl/err.h> #include <openssl/mem.h> #include "../internal.h" #include "../test/file_test.h" -#include "../test/scoped_types.h" #include "../test/test_util.h" -static int HexToBIGNUM(ScopedBIGNUM *out, const char *in) { +static int HexToBIGNUM(bssl::UniquePtr<BIGNUM> *out, const char *in) { BIGNUM *raw = NULL; int ret = BN_hex2bn(&raw, in); out->reset(raw); return ret; } -static ScopedBIGNUM GetBIGNUM(FileTest *t, const char *attribute) { +static bssl::UniquePtr<BIGNUM> GetBIGNUM(FileTest *t, const char *attribute) { std::string hex; if (!t->GetAttribute(&hex, attribute)) { return nullptr; } - ScopedBIGNUM ret; + bssl::UniquePtr<BIGNUM> ret; if (HexToBIGNUM(&ret, hex.c_str()) != static_cast<int>(hex.size())) { t->PrintLine("Could not decode '%s'.", hex.c_str()); return nullptr; @@ -113,7 +113,7 @@ static ScopedBIGNUM GetBIGNUM(FileTest *t, const char *attribute) { } static bool GetInt(FileTest *t, int *out, const char *attribute) { - ScopedBIGNUM ret = GetBIGNUM(t, attribute); + bssl::UniquePtr<BIGNUM> ret = GetBIGNUM(t, attribute); if (!ret) { return false; } @@ -133,8 +133,8 @@ static bool ExpectBIGNUMsEqual(FileTest *t, const char *operation, return true; } - ScopedOpenSSLString expected_str(BN_bn2hex(expected)); - ScopedOpenSSLString actual_str(BN_bn2hex(actual)); + bssl::UniquePtr<char> expected_str(BN_bn2hex(expected)); + bssl::UniquePtr<char> actual_str(BN_bn2hex(actual)); if (!expected_str || !actual_str) { return false; } @@ -147,14 +147,14 @@ static bool ExpectBIGNUMsEqual(FileTest *t, const char *operation, } static bool TestSum(FileTest *t, BN_CTX *ctx) { - ScopedBIGNUM a = GetBIGNUM(t, "A"); - ScopedBIGNUM b = GetBIGNUM(t, "B"); - ScopedBIGNUM sum = GetBIGNUM(t, "Sum"); + bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A"); + bssl::UniquePtr<BIGNUM> b = GetBIGNUM(t, "B"); + bssl::UniquePtr<BIGNUM> sum = GetBIGNUM(t, "Sum"); if (!a || !b || !sum) { return false; } - ScopedBIGNUM ret(BN_new()); + bssl::UniquePtr<BIGNUM> ret(BN_new()); if (!ret || !BN_add(ret.get(), a.get(), b.get()) || !ExpectBIGNUMsEqual(t, "A + B", sum.get(), ret.get()) || @@ -246,16 +246,16 @@ static bool TestSum(FileTest *t, BN_CTX *ctx) { } static bool TestLShift1(FileTest *t, BN_CTX *ctx) { - ScopedBIGNUM a = GetBIGNUM(t, "A"); - ScopedBIGNUM lshift1 = GetBIGNUM(t, "LShift1"); - ScopedBIGNUM zero(BN_new()); + bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A"); + bssl::UniquePtr<BIGNUM> lshift1 = GetBIGNUM(t, "LShift1"); + bssl::UniquePtr<BIGNUM> zero(BN_new()); if (!a || !lshift1 || !zero) { return false; } BN_zero(zero.get()); - ScopedBIGNUM ret(BN_new()), two(BN_new()), remainder(BN_new()); + bssl::UniquePtr<BIGNUM> ret(BN_new()), two(BN_new()), remainder(BN_new()); if (!ret || !two || !remainder || !BN_set_word(two.get(), 2) || !BN_add(ret.get(), a.get(), a.get()) || @@ -287,14 +287,14 @@ static bool TestLShift1(FileTest *t, BN_CTX *ctx) { } static bool TestLShift(FileTest *t, BN_CTX *ctx) { - ScopedBIGNUM a = GetBIGNUM(t, "A"); - ScopedBIGNUM lshift = GetBIGNUM(t, "LShift"); + bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A"); + bssl::UniquePtr<BIGNUM> lshift = GetBIGNUM(t, "LShift"); int n = 0; if (!a || !lshift || !GetInt(t, &n, "N")) { return false; } - ScopedBIGNUM ret(BN_new()); + bssl::UniquePtr<BIGNUM> ret(BN_new()); if (!ret || !BN_lshift(ret.get(), a.get(), n) || !ExpectBIGNUMsEqual(t, "A << N", lshift.get(), ret.get()) || @@ -307,14 +307,14 @@ static bool TestLShift(FileTest *t, BN_CTX *ctx) { } static bool TestRShift(FileTest *t, BN_CTX *ctx) { - ScopedBIGNUM a = GetBIGNUM(t, "A"); - ScopedBIGNUM rshift = GetBIGNUM(t, "RShift"); + bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A"); + bssl::UniquePtr<BIGNUM> rshift = GetBIGNUM(t, "RShift"); int n = 0; if (!a || !rshift || !GetInt(t, &n, "N")) { return false; } - ScopedBIGNUM ret(BN_new()); + bssl::UniquePtr<BIGNUM> ret(BN_new()); if (!ret || !BN_rshift(ret.get(), a.get(), n) || !ExpectBIGNUMsEqual(t, "A >> N", rshift.get(), ret.get())) { @@ -325,16 +325,16 @@ static bool TestRShift(FileTest *t, BN_CTX *ctx) { } static bool TestSquare(FileTest *t, BN_CTX *ctx) { - ScopedBIGNUM a = GetBIGNUM(t, "A"); - ScopedBIGNUM square = GetBIGNUM(t, "Square"); - ScopedBIGNUM zero(BN_new()); + bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A"); + bssl::UniquePtr<BIGNUM> square = GetBIGNUM(t, "Square"); + bssl::UniquePtr<BIGNUM> zero(BN_new()); if (!a || !square || !zero) { return false; } BN_zero(zero.get()); - ScopedBIGNUM ret(BN_new()), remainder(BN_new()); + bssl::UniquePtr<BIGNUM> ret(BN_new()), remainder(BN_new()); if (!ret || !BN_sqr(ret.get(), a.get(), ctx) || !ExpectBIGNUMsEqual(t, "A^2", square.get(), ret.get()) || @@ -354,7 +354,7 @@ static bool TestSquare(FileTest *t, BN_CTX *ctx) { // BN_sqrt should fail on non-squares and negative numbers. if (!BN_is_zero(square.get())) { - ScopedBIGNUM tmp(BN_new()); + bssl::UniquePtr<BIGNUM> tmp(BN_new()); if (!tmp || !BN_copy(tmp.get(), square.get())) { return false; } @@ -381,17 +381,17 @@ static bool TestSquare(FileTest *t, BN_CTX *ctx) { } static bool TestProduct(FileTest *t, BN_CTX *ctx) { - ScopedBIGNUM a = GetBIGNUM(t, "A"); - ScopedBIGNUM b = GetBIGNUM(t, "B"); - ScopedBIGNUM product = GetBIGNUM(t, "Product"); - ScopedBIGNUM zero(BN_new()); + bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A"); + bssl::UniquePtr<BIGNUM> b = GetBIGNUM(t, "B"); + bssl::UniquePtr<BIGNUM> product = GetBIGNUM(t, "Product"); + bssl::UniquePtr<BIGNUM> zero(BN_new()); if (!a || !b || !product || !zero) { return false; } BN_zero(zero.get()); - ScopedBIGNUM ret(BN_new()), remainder(BN_new()); + bssl::UniquePtr<BIGNUM> ret(BN_new()), remainder(BN_new()); if (!ret || !remainder || !BN_mul(ret.get(), a.get(), b.get(), ctx) || !ExpectBIGNUMsEqual(t, "A * B", product.get(), ret.get()) || @@ -408,15 +408,15 @@ static bool TestProduct(FileTest *t, BN_CTX *ctx) { } static bool TestQuotient(FileTest *t, BN_CTX *ctx) { - ScopedBIGNUM a = GetBIGNUM(t, "A"); - ScopedBIGNUM b = GetBIGNUM(t, "B"); - ScopedBIGNUM quotient = GetBIGNUM(t, "Quotient"); - ScopedBIGNUM remainder = GetBIGNUM(t, "Remainder"); + bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A"); + bssl::UniquePtr<BIGNUM> b = GetBIGNUM(t, "B"); + bssl::UniquePtr<BIGNUM> quotient = GetBIGNUM(t, "Quotient"); + bssl::UniquePtr<BIGNUM> remainder = GetBIGNUM(t, "Remainder"); if (!a || !b || !quotient || !remainder) { return false; } - ScopedBIGNUM ret(BN_new()), ret2(BN_new()); + bssl::UniquePtr<BIGNUM> ret(BN_new()), ret2(BN_new()); if (!ret || !ret2 || !BN_div(ret.get(), ret2.get(), a.get(), b.get(), ctx) || !ExpectBIGNUMsEqual(t, "A / B", quotient.get(), ret.get()) || @@ -457,7 +457,7 @@ static bool TestQuotient(FileTest *t, BN_CTX *ctx) { // Test BN_nnmod. if (!BN_is_negative(b.get())) { - ScopedBIGNUM nnmod(BN_new()); + bssl::UniquePtr<BIGNUM> nnmod(BN_new()); if (!nnmod || !BN_copy(nnmod.get(), remainder.get()) || (BN_is_negative(nnmod.get()) && @@ -473,15 +473,15 @@ static bool TestQuotient(FileTest *t, BN_CTX *ctx) { } static bool TestModMul(FileTest *t, BN_CTX *ctx) { - ScopedBIGNUM a = GetBIGNUM(t, "A"); - ScopedBIGNUM b = GetBIGNUM(t, "B"); - ScopedBIGNUM m = GetBIGNUM(t, "M"); - ScopedBIGNUM mod_mul = GetBIGNUM(t, "ModMul"); + bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A"); + bssl::UniquePtr<BIGNUM> b = GetBIGNUM(t, "B"); + bssl::UniquePtr<BIGNUM> m = GetBIGNUM(t, "M"); + bssl::UniquePtr<BIGNUM> mod_mul = GetBIGNUM(t, "ModMul"); if (!a || !b || !m || !mod_mul) { return false; } - ScopedBIGNUM ret(BN_new()); + bssl::UniquePtr<BIGNUM> ret(BN_new()); if (!ret || !BN_mod_mul(ret.get(), a.get(), b.get(), m.get(), ctx) || !ExpectBIGNUMsEqual(t, "A * B (mod M)", mod_mul.get(), ret.get())) { @@ -490,8 +490,8 @@ static bool TestModMul(FileTest *t, BN_CTX *ctx) { if (BN_is_odd(m.get())) { // Reduce |a| and |b| and test the Montgomery version. - ScopedBN_MONT_CTX mont(BN_MONT_CTX_new()); - ScopedBIGNUM a_tmp(BN_new()), b_tmp(BN_new()); + bssl::UniquePtr<BN_MONT_CTX> mont(BN_MONT_CTX_new()); + bssl::UniquePtr<BIGNUM> a_tmp(BN_new()), b_tmp(BN_new()); if (!mont || !a_tmp || !b_tmp || !BN_MONT_CTX_set(mont.get(), m.get(), ctx) || !BN_nnmod(a_tmp.get(), a.get(), m.get(), ctx) || @@ -511,15 +511,15 @@ static bool TestModMul(FileTest *t, BN_CTX *ctx) { } static bool TestModExp(FileTest *t, BN_CTX *ctx) { - ScopedBIGNUM a = GetBIGNUM(t, "A"); - ScopedBIGNUM e = GetBIGNUM(t, "E"); - ScopedBIGNUM m = GetBIGNUM(t, "M"); - ScopedBIGNUM mod_exp = GetBIGNUM(t, "ModExp"); + bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A"); + bssl::UniquePtr<BIGNUM> e = GetBIGNUM(t, "E"); + bssl::UniquePtr<BIGNUM> m = GetBIGNUM(t, "M"); + bssl::UniquePtr<BIGNUM> mod_exp = GetBIGNUM(t, "ModExp"); if (!a || !e || !m || !mod_exp) { return false; } - ScopedBIGNUM ret(BN_new()); + bssl::UniquePtr<BIGNUM> ret(BN_new()); if (!ret || !BN_mod_exp(ret.get(), a.get(), e.get(), m.get(), ctx) || !ExpectBIGNUMsEqual(t, "A ^ E (mod M)", mod_exp.get(), ret.get())) { @@ -542,14 +542,14 @@ static bool TestModExp(FileTest *t, BN_CTX *ctx) { } static bool TestExp(FileTest *t, BN_CTX *ctx) { - ScopedBIGNUM a = GetBIGNUM(t, "A"); - ScopedBIGNUM e = GetBIGNUM(t, "E"); - ScopedBIGNUM exp = GetBIGNUM(t, "Exp"); + bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A"); + bssl::UniquePtr<BIGNUM> e = GetBIGNUM(t, "E"); + bssl::UniquePtr<BIGNUM> exp = GetBIGNUM(t, "Exp"); if (!a || !e || !exp) { return false; } - ScopedBIGNUM ret(BN_new()); + bssl::UniquePtr<BIGNUM> ret(BN_new()); if (!ret || !BN_exp(ret.get(), a.get(), e.get(), ctx) || !ExpectBIGNUMsEqual(t, "A ^ E", exp.get(), ret.get())) { @@ -560,15 +560,15 @@ static bool TestExp(FileTest *t, BN_CTX *ctx) { } static bool TestModSqrt(FileTest *t, BN_CTX *ctx) { - ScopedBIGNUM a = GetBIGNUM(t, "A"); - ScopedBIGNUM p = GetBIGNUM(t, "P"); - ScopedBIGNUM mod_sqrt = GetBIGNUM(t, "ModSqrt"); + bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A"); + bssl::UniquePtr<BIGNUM> p = GetBIGNUM(t, "P"); + bssl::UniquePtr<BIGNUM> mod_sqrt = GetBIGNUM(t, "ModSqrt"); if (!a || !p || !mod_sqrt) { return false; } - ScopedBIGNUM ret(BN_new()); - ScopedBIGNUM ret2(BN_new()); + bssl::UniquePtr<BIGNUM> ret(BN_new()); + bssl::UniquePtr<BIGNUM> ret2(BN_new()); if (!ret || !ret2 || !BN_mod_sqrt(ret.get(), a.get(), p.get(), ctx) || @@ -586,14 +586,14 @@ static bool TestModSqrt(FileTest *t, BN_CTX *ctx) { } static bool TestModInv(FileTest *t, BN_CTX *ctx) { - ScopedBIGNUM a = GetBIGNUM(t, "A"); - ScopedBIGNUM m = GetBIGNUM(t, "M"); - ScopedBIGNUM mod_inv = GetBIGNUM(t, "ModInv"); + bssl::UniquePtr<BIGNUM> a = GetBIGNUM(t, "A"); + bssl::UniquePtr<BIGNUM> m = GetBIGNUM(t, "M"); + bssl::UniquePtr<BIGNUM> mod_inv = GetBIGNUM(t, "ModInv"); if (!a || !m || !mod_inv) { return false; } - ScopedBIGNUM ret(BN_new()); + bssl::UniquePtr<BIGNUM> ret(BN_new()); if (!ret || !BN_mod_inverse(ret.get(), a.get(), m.get(), ctx) || !ExpectBIGNUMsEqual(t, "inv(A) (mod M)", mod_inv.get(), ret.get())) { @@ -650,7 +650,7 @@ static bool TestBN2BinPadded(BN_CTX *ctx) { memset(zeros, 0, sizeof(zeros)); // Test edge case at 0. - ScopedBIGNUM n(BN_new()); + bssl::UniquePtr<BIGNUM> n(BN_new()); if (!n || !BN_bn2bin_padded(NULL, 0, n.get())) { fprintf(stderr, "BN_bn2bin_padded failed to encode 0 in an empty buffer.\n"); @@ -713,7 +713,7 @@ static bool TestBN2BinPadded(BN_CTX *ctx) { return true; } -static int DecimalToBIGNUM(ScopedBIGNUM *out, const char *in) { +static int DecimalToBIGNUM(bssl::UniquePtr<BIGNUM> *out, const char *in) { BIGNUM *raw = NULL; int ret = BN_dec2bn(&raw, in); out->reset(raw); @@ -721,7 +721,7 @@ static int DecimalToBIGNUM(ScopedBIGNUM *out, const char *in) { } static bool TestDec2BN(BN_CTX *ctx) { - ScopedBIGNUM bn; + bssl::UniquePtr<BIGNUM> bn; int ret = DecimalToBIGNUM(&bn, "0"); if (ret != 1 || !BN_is_zero(bn.get()) || BN_is_negative(bn.get())) { fprintf(stderr, "BN_dec2bn gave a bad result.\n"); @@ -756,7 +756,7 @@ static bool TestDec2BN(BN_CTX *ctx) { } static bool TestHex2BN(BN_CTX *ctx) { - ScopedBIGNUM bn; + bssl::UniquePtr<BIGNUM> bn; int ret = HexToBIGNUM(&bn, "0"); if (ret != 1 || !BN_is_zero(bn.get()) || BN_is_negative(bn.get())) { fprintf(stderr, "BN_hex2bn gave a bad result.\n"); @@ -790,16 +790,16 @@ static bool TestHex2BN(BN_CTX *ctx) { return true; } -static ScopedBIGNUM ASCIIToBIGNUM(const char *in) { +static bssl::UniquePtr<BIGNUM> ASCIIToBIGNUM(const char *in) { BIGNUM *raw = NULL; if (!BN_asc2bn(&raw, in)) { return nullptr; } - return ScopedBIGNUM(raw); + return bssl::UniquePtr<BIGNUM>(raw); } static bool TestASC2BN(BN_CTX *ctx) { - ScopedBIGNUM bn = ASCIIToBIGNUM("0"); + bssl::UniquePtr<BIGNUM> bn = ASCIIToBIGNUM("0"); if (!bn || !BN_is_zero(bn.get()) || BN_is_negative(bn.get())) { fprintf(stderr, "BN_asc2bn gave a bad result.\n"); return false; @@ -870,7 +870,7 @@ static bool TestMPI() { for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(kMPITests); i++) { const MPITest &test = kMPITests[i]; - ScopedBIGNUM bn(ASCIIToBIGNUM(test.base10)); + bssl::UniquePtr<BIGNUM> bn(ASCIIToBIGNUM(test.base10)); const size_t mpi_len = BN_bn2mpi(bn.get(), NULL); if (mpi_len > sizeof(scratch)) { fprintf(stderr, "MPI test #%u: MPI size is too large to test.\n", @@ -892,7 +892,7 @@ static bool TestMPI() { return false; } - ScopedBIGNUM bn2(BN_mpi2bn(scratch, mpi_len, NULL)); + bssl::UniquePtr<BIGNUM> bn2(BN_mpi2bn(scratch, mpi_len, NULL)); if (bn2.get() == nullptr) { fprintf(stderr, "MPI test #%u: failed to parse\n", (unsigned)i); return false; @@ -908,7 +908,7 @@ static bool TestMPI() { } static bool TestRand() { - ScopedBIGNUM bn(BN_new()); + bssl::UniquePtr<BIGNUM> bn(BN_new()); if (!bn) { return false; } @@ -993,13 +993,13 @@ static const ASN1Test kASN1BuggyTests[] = { static bool TestASN1() { for (const ASN1Test &test : kASN1Tests) { - ScopedBIGNUM bn = ASCIIToBIGNUM(test.value_ascii); + bssl::UniquePtr<BIGNUM> bn = ASCIIToBIGNUM(test.value_ascii); if (!bn) { return false; } // Test that the input is correctly parsed. - ScopedBIGNUM bn2(BN_new()); + bssl::UniquePtr<BIGNUM> bn2(BN_new()); if (!bn2) { return false; } @@ -1025,7 +1025,7 @@ static bool TestASN1() { CBB_cleanup(&cbb); return false; } - ScopedOpenSSLBytes delete_der(der); + bssl::UniquePtr<uint8_t> delete_der(der); if (der_len != test.der_len || memcmp(der, reinterpret_cast<const uint8_t*>(test.der), der_len) != 0) { fprintf(stderr, "Bad serialization.\n"); @@ -1045,7 +1045,7 @@ static bool TestASN1() { } for (const ASN1InvalidTest &test : kASN1InvalidTests) { - ScopedBIGNUM bn(BN_new()); + bssl::UniquePtr<BIGNUM> bn(BN_new()); if (!bn) { return false; } @@ -1069,7 +1069,7 @@ static bool TestASN1() { for (const ASN1Test &test : kASN1BuggyTests) { // These broken encodings are rejected by |BN_parse_asn1_unsigned|. - ScopedBIGNUM bn(BN_new()); + bssl::UniquePtr<BIGNUM> bn(BN_new()); if (!bn) { return false; } @@ -1083,7 +1083,7 @@ static bool TestASN1() { ERR_clear_error(); // However |BN_parse_asn1_unsigned_buggy| accepts them. - ScopedBIGNUM bn2 = ASCIIToBIGNUM(test.value_ascii); + bssl::UniquePtr<BIGNUM> bn2 = ASCIIToBIGNUM(test.value_ascii); if (!bn2) { return false; } @@ -1101,7 +1101,7 @@ static bool TestASN1() { } // Serializing negative numbers is not supported. - ScopedBIGNUM bn = ASCIIToBIGNUM("-1"); + bssl::UniquePtr<BIGNUM> bn = ASCIIToBIGNUM("-1"); if (!bn) { return false; } @@ -1120,9 +1120,9 @@ static bool TestASN1() { } static bool TestNegativeZero(BN_CTX *ctx) { - ScopedBIGNUM a(BN_new()); - ScopedBIGNUM b(BN_new()); - ScopedBIGNUM c(BN_new()); + bssl::UniquePtr<BIGNUM> a(BN_new()); + bssl::UniquePtr<BIGNUM> b(BN_new()); + bssl::UniquePtr<BIGNUM> c(BN_new()); if (!a || !b || !c) { return false; } @@ -1142,7 +1142,7 @@ static bool TestNegativeZero(BN_CTX *ctx) { } for (int consttime = 0; consttime < 2; consttime++) { - ScopedBIGNUM numerator(BN_new()), denominator(BN_new()); + bssl::UniquePtr<BIGNUM> numerator(BN_new()), denominator(BN_new()); if (!numerator || !denominator) { return false; } @@ -1190,8 +1190,8 @@ static bool TestNegativeZero(BN_CTX *ctx) { // Test that forcibly creating a negative zero does not break |BN_bn2hex| or // |BN_bn2dec|. a->neg = 1; - ScopedOpenSSLString dec(BN_bn2dec(a.get())); - ScopedOpenSSLString hex(BN_bn2hex(a.get())); + bssl::UniquePtr<char> dec(BN_bn2dec(a.get())); + bssl::UniquePtr<char> hex(BN_bn2hex(a.get())); if (!dec || !hex || strcmp(dec.get(), "-0") != 0 || strcmp(hex.get(), "-0") != 0) { @@ -1203,10 +1203,10 @@ static bool TestNegativeZero(BN_CTX *ctx) { } static bool TestBadModulus(BN_CTX *ctx) { - ScopedBIGNUM a(BN_new()); - ScopedBIGNUM b(BN_new()); - ScopedBIGNUM zero(BN_new()); - ScopedBN_MONT_CTX mont(BN_MONT_CTX_new()); + bssl::UniquePtr<BIGNUM> a(BN_new()); + bssl::UniquePtr<BIGNUM> b(BN_new()); + bssl::UniquePtr<BIGNUM> zero(BN_new()); + bssl::UniquePtr<BN_MONT_CTX> mont(BN_MONT_CTX_new()); if (!a || !b || !zero || !mont) { return false; } @@ -1290,7 +1290,7 @@ static bool TestBadModulus(BN_CTX *ctx) { // TestExpModZero tests that 1**0 mod 1 == 0. static bool TestExpModZero() { - ScopedBIGNUM zero(BN_new()), a(BN_new()), r(BN_new()); + bssl::UniquePtr<BIGNUM> zero(BN_new()), a(BN_new()), r(BN_new()); if (!zero || !a || !r || !BN_rand(a.get(), 1024, BN_RAND_TOP_ONE, BN_RAND_BOTTOM_ANY)) { return false; @@ -1317,7 +1317,7 @@ static bool TestExpModZero() { static bool TestSmallPrime(BN_CTX *ctx) { static const unsigned kBits = 10; - ScopedBIGNUM r(BN_new()); + bssl::UniquePtr<BIGNUM> r(BN_new()); if (!r || !BN_generate_prime_ex(r.get(), static_cast<int>(kBits), 0, NULL, NULL, NULL)) { return false; @@ -1334,7 +1334,7 @@ static bool TestSmallPrime(BN_CTX *ctx) { static bool TestCmpWord() { static const BN_ULONG kMaxWord = (BN_ULONG)-1; - ScopedBIGNUM r(BN_new()); + bssl::UniquePtr<BIGNUM> r(BN_new()); if (!r || !BN_set_word(r.get(), 0)) { return false; @@ -1416,13 +1416,13 @@ static bool TestBN2Dec() { }; for (const char *test : kBN2DecTests) { - ScopedBIGNUM bn; + bssl::UniquePtr<BIGNUM> bn; int ret = DecimalToBIGNUM(&bn, test); if (ret == 0) { return false; } - ScopedOpenSSLString dec(BN_bn2dec(bn.get())); + bssl::UniquePtr<char> dec(BN_bn2dec(bn.get())); if (!dec) { fprintf(stderr, "BN_bn2dec failed on %s.\n", test); return false; @@ -1445,7 +1445,7 @@ int main(int argc, char *argv[]) { return 1; } - ScopedBN_CTX ctx(BN_CTX_new()); + bssl::UniquePtr<BN_CTX> ctx(BN_CTX_new()); if (!ctx) { return 1; } diff --git a/crypto/bytestring/bytestring_test.cc b/crypto/bytestring/bytestring_test.cc index f567fd0c..45a2335a 100644 --- a/crypto/bytestring/bytestring_test.cc +++ b/crypto/bytestring/bytestring_test.cc @@ -27,7 +27,6 @@ #include "internal.h" #include "../internal.h" -#include "../test/scoped_types.h" namespace bssl { @@ -294,7 +293,7 @@ static bool TestCBBBasic() { return false; } - ScopedOpenSSLBytes scoper(buf); + bssl::UniquePtr<uint8_t> scoper(buf); return buf_len == sizeof(kExpected) && memcmp(buf, kExpected, buf_len) == 0; } @@ -345,7 +344,7 @@ static bool TestCBBFinishChild() { CBB_cleanup(&cbb); return false; } - ScopedOpenSSLBytes scoper(out_buf); + bssl::UniquePtr<uint8_t> scoper(out_buf); return out_size == 1 && out_buf[0] == 0; } @@ -378,7 +377,7 @@ static bool TestCBBPrefixed() { return false; } - ScopedOpenSSLBytes scoper(buf); + bssl::UniquePtr<uint8_t> scoper(buf); return buf_len == sizeof(kExpected) && memcmp(buf, kExpected, buf_len) == 0; } @@ -418,7 +417,7 @@ static bool TestCBBDiscardChild() { if (!CBB_finish(cbb.get(), &buf, &buf_len)) { return false; } - ScopedOpenSSLBytes scoper(buf); + bssl::UniquePtr<uint8_t> scoper(buf); static const uint8_t kExpected[] = { 0xaa, @@ -464,7 +463,7 @@ static bool TestCBBMisuse() { CBB_cleanup(&cbb); return false; } - ScopedOpenSSLBytes scoper(buf); + bssl::UniquePtr<uint8_t> scoper(buf); if (buf_len != 3 || memcmp(buf, "\x01\x01\x02", 3) != 0) { @@ -488,7 +487,7 @@ static bool TestCBBASN1() { CBB_cleanup(&cbb); return false; } - ScopedOpenSSLBytes scoper(buf); + bssl::UniquePtr<uint8_t> scoper(buf); if (buf_len != sizeof(kExpected) || memcmp(buf, kExpected, buf_len) != 0) { return false; @@ -563,7 +562,7 @@ static bool DoBerConvert(const char *name, fprintf(stderr, "%s: CBS_asn1_ber_to_der failed.\n", name); return false; } - ScopedOpenSSLBytes scoper(out); + bssl::UniquePtr<uint8_t> scoper(out); if (out == NULL) { if (ber_len != der_len || @@ -676,7 +675,7 @@ static bool TestImplicitString() { int ok = CBS_get_asn1_implicit_string(&in, &out, &storage, CBS_ASN1_CONTEXT_SPECIFIC | 0, CBS_ASN1_OCTETSTRING); - ScopedOpenSSLBytes scoper(storage); + bssl::UniquePtr<uint8_t> scoper(storage); if (static_cast<bool>(ok) != test.ok) { fprintf(stderr, "CBS_get_asn1_implicit_string unexpectedly %s\n", @@ -754,7 +753,7 @@ static bool TestASN1Uint64() { CBB_cleanup(&cbb); return false; } - ScopedOpenSSLBytes scoper(out); + bssl::UniquePtr<uint8_t> scoper(out); if (len != test->encoding_len || memcmp(out, test->encoding, len) != 0) { return false; } diff --git a/crypto/cmac/cmac_test.cc b/crypto/cmac/cmac_test.cc index 2496f2a9..7cb1df50 100644 --- a/crypto/cmac/cmac_test.cc +++ b/crypto/cmac/cmac_test.cc @@ -16,9 +16,10 @@ #include <algorithm> +#include <openssl/cipher.h> #include <openssl/cmac.h> +#include <openssl/mem.h> -#include "../test/scoped_types.h" #include "../test/test_util.h" @@ -43,7 +44,7 @@ static int test(const char *name, const uint8_t *key, size_t key_len, return 0; } - ScopedCMAC_CTX ctx(CMAC_CTX_new()); + bssl::UniquePtr<CMAC_CTX> ctx(CMAC_CTX_new()); if (!ctx || !CMAC_Init(ctx.get(), key, key_len, EVP_aes_128_cbc(), NULL)) { fprintf(stderr, "%s: CMAC_Init failed.\n", name); return 0; diff --git a/crypto/curve25519/spake25519_test.cc b/crypto/curve25519/spake25519_test.cc index d97a8602..363b60ca 100644 --- a/crypto/curve25519/spake25519_test.cc +++ b/crypto/curve25519/spake25519_test.cc @@ -19,18 +19,17 @@ #include <string.h> #include <openssl/curve25519.h> -#include "../test/scoped_types.h" struct SPAKE2Run { bool Run() { - ScopedSPAKE2_CTX alice(SPAKE2_CTX_new( + bssl::UniquePtr<SPAKE2_CTX> alice(SPAKE2_CTX_new( spake2_role_alice, reinterpret_cast<const uint8_t *>(alice_names.first.data()), alice_names.first.size(), reinterpret_cast<const uint8_t *>(alice_names.second.data()), alice_names.second.size())); - ScopedSPAKE2_CTX bob(SPAKE2_CTX_new( + bssl::UniquePtr<SPAKE2_CTX> bob(SPAKE2_CTX_new( spake2_role_bob, reinterpret_cast<const uint8_t *>(bob_names.first.data()), bob_names.first.size(), diff --git a/crypto/dh/dh_test.cc b/crypto/dh/dh_test.cc index b8bfe46e..12984e64 100644 --- a/crypto/dh/dh_test.cc +++ b/crypto/dh/dh_test.cc @@ -64,11 +64,10 @@ #include <openssl/bn.h> #include <openssl/c++/bytestring.h> #include <openssl/crypto.h> +#include <openssl/dh.h> #include <openssl/err.h> #include <openssl/mem.h> -#include "../test/scoped_types.h" - namespace bssl { static bool RunBasicTests(); @@ -115,7 +114,7 @@ static int GenerateCallback(int p, int n, BN_GENCB *arg) { static bool RunBasicTests() { BN_GENCB cb; BN_GENCB_set(&cb, &GenerateCallback, stdout); - ScopedDH a(DH_new()); + bssl::UniquePtr<DH> a(DH_new()); if (!a || !DH_generate_parameters_ex(a.get(), 64, DH_GENERATOR_5, &cb)) { return false; } @@ -143,7 +142,7 @@ static bool RunBasicTests() { BN_print_fp(stdout, a->g); printf("\n"); - ScopedDH b(DH_new()); + bssl::UniquePtr<DH> b(DH_new()); if (!b) { return false; } @@ -437,8 +436,8 @@ static bool RunRFC5114Tests() { for (unsigned i = 0; i < sizeof(kRFCTestData) / sizeof(RFC5114TestData); i++) { const RFC5114TestData *td = kRFCTestData + i; /* Set up DH structures setting key components */ - ScopedDH dhA(td->get_param(nullptr)); - ScopedDH dhB(td->get_param(nullptr)); + bssl::UniquePtr<DH> dhA(td->get_param(nullptr)); + bssl::UniquePtr<DH> dhB(td->get_param(nullptr)); if (!dhA || !dhB) { fprintf(stderr, "Initialisation error RFC5114 set %u\n", i + 1); return false; @@ -513,8 +512,8 @@ static const uint8_t kRFC5114_2048_224BadY[] = { }; static bool TestBadY() { - ScopedDH dh(DH_get_2048_224(nullptr)); - ScopedBIGNUM pub_key( + bssl::UniquePtr<DH> dh(DH_get_2048_224(nullptr)); + 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; @@ -544,7 +543,7 @@ static bool BIGNUMEqualsHex(const BIGNUM *bn, const char *hex) { if (!BN_hex2bn(&hex_bn, hex)) { return false; } - ScopedBIGNUM free_hex_bn(hex_bn); + bssl::UniquePtr<BIGNUM> free_hex_bn(hex_bn); return BN_cmp(bn, hex_bn) == 0; } @@ -560,7 +559,7 @@ static bool TestASN1() { CBS cbs; CBS_init(&cbs, kParams, sizeof(kParams)); - ScopedDH dh(DH_parse_parameters(&cbs)); + bssl::UniquePtr<DH> dh(DH_parse_parameters(&cbs)); if (!dh || CBS_len(&cbs) != 0 || !BIGNUMEqualsHex( dh->p, @@ -577,7 +576,7 @@ static bool TestASN1() { !CBB_finish(cbb.get(), &der, &der_len)) { return false; } - ScopedOpenSSLBytes free_der(der); + bssl::UniquePtr<uint8_t> free_der(der); if (der_len != sizeof(kParams) || memcmp(der, kParams, der_len) != 0) { return false; } @@ -619,7 +618,7 @@ static bool TestASN1() { !CBB_finish(cbb.get(), &der, &der_len)) { return false; } - ScopedOpenSSLBytes free_der2(der); + bssl::UniquePtr<uint8_t> free_der2(der); if (der_len != sizeof(kParamsDSA) || memcmp(der, kParamsDSA, der_len) != 0) { return false; } @@ -628,7 +627,7 @@ static bool TestASN1() { } static bool TestRFC3526() { - ScopedBIGNUM bn(BN_get_rfc3526_prime_1536(nullptr)); + bssl::UniquePtr<BIGNUM> bn(BN_get_rfc3526_prime_1536(nullptr)); if (!bn) { return false; } diff --git a/crypto/ec/ec_test.cc b/crypto/ec/ec_test.cc index ca0e1401..9648d57d 100644 --- a/crypto/ec/ec_test.cc +++ b/crypto/ec/ec_test.cc @@ -18,12 +18,13 @@ #include <vector> #include <openssl/c++/bytestring.h> +#include <openssl/bn.h> #include <openssl/crypto.h> #include <openssl/ec_key.h> #include <openssl/err.h> #include <openssl/mem.h> +#include <openssl/nid.h> -#include "../test/scoped_types.h" namespace bssl { @@ -97,10 +98,11 @@ static const uint8_t kECKeyWithZeros[] = { // DecodeECPrivateKey decodes |in| as an ECPrivateKey structure and returns the // result or nullptr on error. -static ScopedEC_KEY DecodeECPrivateKey(const uint8_t *in, size_t in_len) { +static bssl::UniquePtr<EC_KEY> DecodeECPrivateKey(const uint8_t *in, + size_t in_len) { CBS cbs; CBS_init(&cbs, in, in_len); - ScopedEC_KEY ret(EC_KEY_parse_private_key(&cbs, NULL)); + bssl::UniquePtr<EC_KEY> ret(EC_KEY_parse_private_key(&cbs, NULL)); if (!ret || CBS_len(&cbs) != 0) { return nullptr; } @@ -124,7 +126,7 @@ static bool EncodeECPrivateKey(std::vector<uint8_t> *out, const EC_KEY *key) { } static bool Testd2i_ECPrivateKey() { - ScopedEC_KEY key = DecodeECPrivateKey(kECKeyWithoutPublic, + bssl::UniquePtr<EC_KEY> key = DecodeECPrivateKey(kECKeyWithoutPublic, sizeof(kECKeyWithoutPublic)); if (!key) { fprintf(stderr, "Failed to parse private key.\n"); @@ -152,8 +154,8 @@ static bool Testd2i_ECPrivateKey() { return false; } - ScopedBIGNUM x(BN_new()); - ScopedBIGNUM y(BN_new()); + bssl::UniquePtr<BIGNUM> x(BN_new()); + bssl::UniquePtr<BIGNUM> y(BN_new()); if (!x || !y) { return false; } @@ -162,8 +164,8 @@ static bool Testd2i_ECPrivateKey() { fprintf(stderr, "Failed to get public key in affine coordinates.\n"); return false; } - ScopedOpenSSLString x_hex(BN_bn2hex(x.get())); - ScopedOpenSSLString y_hex(BN_bn2hex(y.get())); + bssl::UniquePtr<char> x_hex(BN_bn2hex(x.get())); + bssl::UniquePtr<char> y_hex(BN_bn2hex(y.get())); if (!x_hex || !y_hex) { return false; } @@ -182,7 +184,7 @@ static bool Testd2i_ECPrivateKey() { static bool TestZeroPadding() { // Check that the correct encoding round-trips. - ScopedEC_KEY key = DecodeECPrivateKey(kECKeyWithZeros, + bssl::UniquePtr<EC_KEY> key = DecodeECPrivateKey(kECKeyWithZeros, sizeof(kECKeyWithZeros)); std::vector<uint8_t> out; if (!key || !EncodeECPrivateKey(&out, key.get())) { @@ -214,7 +216,7 @@ static bool TestZeroPadding() { static bool TestSpecifiedCurve() { // Test keys with specified curves may be decoded. - ScopedEC_KEY key = + bssl::UniquePtr<EC_KEY> key = DecodeECPrivateKey(kECKeySpecifiedCurve, sizeof(kECKeySpecifiedCurve)); if (!key) { ERR_print_errors_fp(stderr); @@ -245,7 +247,7 @@ static bool TestSpecifiedCurve() { } static bool TestSetAffine(const int nid) { - ScopedEC_KEY key(EC_KEY_new_by_curve_name(nid)); + bssl::UniquePtr<EC_KEY> key(EC_KEY_new_by_curve_name(nid)); if (!key) { return false; } @@ -265,8 +267,8 @@ static bool TestSetAffine(const int nid) { return false; } - ScopedBIGNUM x(BN_new()); - ScopedBIGNUM y(BN_new()); + bssl::UniquePtr<BIGNUM> x(BN_new()); + bssl::UniquePtr<BIGNUM> y(BN_new()); if (!EC_POINT_get_affine_coordinates_GFp(group, EC_KEY_get0_public_key(key.get()), x.get(), y.get(), nullptr)) { @@ -276,7 +278,7 @@ static bool TestSetAffine(const int nid) { return false; } - ScopedEC_POINT point(EC_POINT_new(group)); + auto point = bssl::UniquePtr<EC_POINT>(EC_POINT_new(group)); if (!point) { return false; } @@ -294,7 +296,7 @@ static bool TestSetAffine(const int nid) { return false; } - ScopedEC_POINT invalid_point(EC_POINT_new(group)); + bssl::UniquePtr<EC_POINT> invalid_point(EC_POINT_new(group)); if (!invalid_point) { return false; } @@ -314,7 +316,7 @@ static bool TestSetAffine(const int nid) { static bool TestArbitraryCurve() { // Make a P-256 key and extract the affine coordinates. - ScopedEC_KEY key(EC_KEY_new_by_curve_name(NID_X9_62_prime256v1)); + bssl::UniquePtr<EC_KEY> key(EC_KEY_new_by_curve_name(NID_X9_62_prime256v1)); if (!key || !EC_KEY_generate_key(key.get())) { return false; } @@ -350,25 +352,25 @@ static bool TestArbitraryCurve() { 0xff, 0xff, 0xff, 0xff, 0xff, 0xbc, 0xe6, 0xfa, 0xad, 0xa7, 0x17, 0x9e, 0x84, 0xf3, 0xb9, 0xca, 0xc2, 0xfc, 0x63, 0x25, 0x51, }; - ScopedBN_CTX ctx(BN_CTX_new()); - ScopedBIGNUM p(BN_bin2bn(kP, sizeof(kP), nullptr)); - ScopedBIGNUM a(BN_bin2bn(kA, sizeof(kA), nullptr)); - ScopedBIGNUM b(BN_bin2bn(kB, sizeof(kB), nullptr)); - ScopedBIGNUM gx(BN_bin2bn(kX, sizeof(kX), nullptr)); - ScopedBIGNUM gy(BN_bin2bn(kY, sizeof(kY), nullptr)); - ScopedBIGNUM order(BN_bin2bn(kOrder, sizeof(kOrder), nullptr)); - ScopedBIGNUM cofactor(BN_new()); + bssl::UniquePtr<BN_CTX> ctx(BN_CTX_new()); + bssl::UniquePtr<BIGNUM> p(BN_bin2bn(kP, sizeof(kP), nullptr)); + bssl::UniquePtr<BIGNUM> a(BN_bin2bn(kA, sizeof(kA), nullptr)); + bssl::UniquePtr<BIGNUM> b(BN_bin2bn(kB, sizeof(kB), nullptr)); + bssl::UniquePtr<BIGNUM> gx(BN_bin2bn(kX, sizeof(kX), nullptr)); + bssl::UniquePtr<BIGNUM> gy(BN_bin2bn(kY, sizeof(kY), nullptr)); + bssl::UniquePtr<BIGNUM> order(BN_bin2bn(kOrder, sizeof(kOrder), nullptr)); + bssl::UniquePtr<BIGNUM> cofactor(BN_new()); if (!ctx || !p || !a || !b || !gx || !gy || !order || !cofactor || !BN_set_word(cofactor.get(), 1)) { return false; } - ScopedEC_GROUP group( + bssl::UniquePtr<EC_GROUP> group( EC_GROUP_new_curve_GFp(p.get(), a.get(), b.get(), ctx.get())); if (!group) { return false; } - ScopedEC_POINT generator(EC_POINT_new(group.get())); + bssl::UniquePtr<EC_POINT> generator(EC_POINT_new(group.get())); if (!generator || !EC_POINT_set_affine_coordinates_GFp(group.get(), generator.get(), gx.get(), gy.get(), ctx.get()) || @@ -383,9 +385,9 @@ static bool TestArbitraryCurve() { } // Copy |key| to |key2| using |group|. - ScopedEC_KEY key2(EC_KEY_new()); - ScopedEC_POINT point(EC_POINT_new(group.get())); - ScopedBIGNUM x(BN_new()), y(BN_new()); + bssl::UniquePtr<EC_KEY> key2(EC_KEY_new()); + bssl::UniquePtr<EC_POINT> point(EC_POINT_new(group.get())); + bssl::UniquePtr<BIGNUM> x(BN_new()), y(BN_new()); if (!key2 || !point || !x || !y || !EC_KEY_set_group(key2.get(), group.get()) || !EC_KEY_set_private_key(key2.get(), EC_KEY_get0_private_key(key.get())) || @@ -409,7 +411,7 @@ static bool TestArbitraryCurve() { } static bool TestAddingEqualPoints(int nid) { - ScopedEC_KEY key(EC_KEY_new_by_curve_name(nid)); + bssl::UniquePtr<EC_KEY> key(EC_KEY_new_by_curve_name(nid)); if (!key) { return false; } @@ -422,10 +424,10 @@ static bool TestAddingEqualPoints(int nid) { return false; } - ScopedEC_POINT p1(EC_POINT_new(group)); - ScopedEC_POINT p2(EC_POINT_new(group)); - ScopedEC_POINT double_p1(EC_POINT_new(group)); - ScopedEC_POINT p1_plus_p2(EC_POINT_new(group)); + bssl::UniquePtr<EC_POINT> p1(EC_POINT_new(group)); + bssl::UniquePtr<EC_POINT> p2(EC_POINT_new(group)); + bssl::UniquePtr<EC_POINT> double_p1(EC_POINT_new(group)); + bssl::UniquePtr<EC_POINT> p1_plus_p2(EC_POINT_new(group)); if (!p1 || !p2 || !double_p1 || !p1_plus_p2) { return false; } @@ -437,7 +439,7 @@ static bool TestAddingEqualPoints(int nid) { return false; } - ScopedBN_CTX ctx(BN_CTX_new()); + bssl::UniquePtr<BN_CTX> ctx(BN_CTX_new()); if (!ctx) { return false; } diff --git a/crypto/ecdh/ecdh_test.cc b/crypto/ecdh/ecdh_test.cc index 95f14023..a02fd22f 100644 --- a/crypto/ecdh/ecdh_test.cc +++ b/crypto/ecdh/ecdh_test.cc @@ -21,59 +21,60 @@ #include <openssl/ec.h> #include <openssl/ec_key.h> #include <openssl/ecdh.h> +#include <openssl/nid.h> #include "../test/file_test.h" -#include "../test/scoped_types.h" -static ScopedEC_GROUP GetCurve(FileTest *t, const char *key) { +static bssl::UniquePtr<EC_GROUP> GetCurve(FileTest *t, const char *key) { std::string curve_name; if (!t->GetAttribute(&curve_name, key)) { return nullptr; } if (curve_name == "P-224") { - return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp224r1)); + return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp224r1)); } if (curve_name == "P-256") { - return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1)); + return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name( + NID_X9_62_prime256v1)); } if (curve_name == "P-384") { - return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp384r1)); + return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp384r1)); } if (curve_name == "P-521") { - return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp521r1)); + return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp521r1)); } t->PrintLine("Unknown curve '%s'", curve_name.c_str()); return nullptr; } -static ScopedBIGNUM GetBIGNUM(FileTest *t, const char *key) { +static bssl::UniquePtr<BIGNUM> GetBIGNUM(FileTest *t, const char *key) { std::vector<uint8_t> bytes; if (!t->GetBytes(&bytes, key)) { return nullptr; } - return ScopedBIGNUM(BN_bin2bn(bytes.data(), bytes.size(), nullptr)); + return bssl::UniquePtr<BIGNUM>(BN_bin2bn(bytes.data(), bytes.size(), nullptr)); } static bool TestECDH(FileTest *t, void *arg) { - ScopedEC_GROUP group = GetCurve(t, "Curve"); - ScopedBIGNUM priv_key = GetBIGNUM(t, "Private"); - ScopedBIGNUM x = GetBIGNUM(t, "X"); - ScopedBIGNUM y = GetBIGNUM(t, "Y"); - ScopedBIGNUM peer_x = GetBIGNUM(t, "PeerX"); - ScopedBIGNUM peer_y = GetBIGNUM(t, "PeerY"); + bssl::UniquePtr<EC_GROUP> group = GetCurve(t, "Curve"); + bssl::UniquePtr<BIGNUM> priv_key = GetBIGNUM(t, "Private"); + bssl::UniquePtr<BIGNUM> x = GetBIGNUM(t, "X"); + bssl::UniquePtr<BIGNUM> y = GetBIGNUM(t, "Y"); + bssl::UniquePtr<BIGNUM> peer_x = GetBIGNUM(t, "PeerX"); + bssl::UniquePtr<BIGNUM> peer_y = GetBIGNUM(t, "PeerY"); std::vector<uint8_t> z; if (!group || !priv_key || !x || !y || !peer_x || !peer_y || !t->GetBytes(&z, "Z")) { return false; } - ScopedEC_KEY key(EC_KEY_new()); - ScopedEC_POINT pub_key(EC_POINT_new(group.get())); - ScopedEC_POINT peer_pub_key(EC_POINT_new(group.get())); + bssl::UniquePtr<EC_KEY> key(EC_KEY_new()); + bssl::UniquePtr<EC_POINT> pub_key(EC_POINT_new(group.get())); + bssl::UniquePtr<EC_POINT> peer_pub_key(EC_POINT_new(group.get())); if (!key || !pub_key || !peer_pub_key || !EC_KEY_set_group(key.get(), group.get()) || !EC_KEY_set_private_key(key.get(), priv_key.get()) || diff --git a/crypto/ecdsa/ecdsa_sign_test.cc b/crypto/ecdsa/ecdsa_sign_test.cc index 683f0f05..ee95773c 100644 --- a/crypto/ecdsa/ecdsa_sign_test.cc +++ b/crypto/ecdsa/ecdsa_sign_test.cc @@ -21,59 +21,60 @@ #include <openssl/ec.h> #include <openssl/ec_key.h> #include <openssl/ecdsa.h> +#include <openssl/nid.h> #include "../test/file_test.h" -#include "../test/scoped_types.h" -static ScopedEC_GROUP GetCurve(FileTest *t, const char *key) { +static bssl::UniquePtr<EC_GROUP> GetCurve(FileTest *t, const char *key) { std::string curve_name; if (!t->GetAttribute(&curve_name, key)) { return nullptr; } if (curve_name == "P-224") { - return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp224r1)); + return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp224r1)); } if (curve_name == "P-256") { - return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1)); + return bssl::UniquePtr<EC_GROUP>( + EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1)); } if (curve_name == "P-384") { - return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp384r1)); + return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp384r1)); } if (curve_name == "P-521") { - return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp521r1)); + return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp521r1)); } t->PrintLine("Unknown curve '%s'", curve_name.c_str()); return nullptr; } -static ScopedBIGNUM GetBIGNUM(FileTest *t, const char *key) { +static bssl::UniquePtr<BIGNUM> GetBIGNUM(FileTest *t, const char *key) { std::vector<uint8_t> bytes; if (!t->GetBytes(&bytes, key)) { return nullptr; } - return ScopedBIGNUM(BN_bin2bn(bytes.data(), bytes.size(), nullptr)); + return bssl::UniquePtr<BIGNUM>(BN_bin2bn(bytes.data(), bytes.size(), nullptr)); } static bool TestECDSASign(FileTest *t, void *arg) { - ScopedEC_GROUP group = GetCurve(t, "Curve"); - ScopedBIGNUM priv_key = GetBIGNUM(t, "Private"); - ScopedBIGNUM x = GetBIGNUM(t, "X"); - ScopedBIGNUM y = GetBIGNUM(t, "Y"); - ScopedBIGNUM k = GetBIGNUM(t, "K"); - ScopedBIGNUM r = GetBIGNUM(t, "R"); - ScopedBIGNUM s = GetBIGNUM(t, "S"); + bssl::UniquePtr<EC_GROUP> group = GetCurve(t, "Curve"); + bssl::UniquePtr<BIGNUM> priv_key = GetBIGNUM(t, "Private"); + bssl::UniquePtr<BIGNUM> x = GetBIGNUM(t, "X"); + bssl::UniquePtr<BIGNUM> y = GetBIGNUM(t, "Y"); + bssl::UniquePtr<BIGNUM> k = GetBIGNUM(t, "K"); + bssl::UniquePtr<BIGNUM> r = GetBIGNUM(t, "R"); + bssl::UniquePtr<BIGNUM> s = GetBIGNUM(t, "S"); std::vector<uint8_t> digest; if (!group || !priv_key || !x || !y || !k || !r || !s || !t->GetBytes(&digest, "Digest")) { return false; } - ScopedEC_KEY key(EC_KEY_new()); - ScopedEC_POINT pub_key(EC_POINT_new(group.get())); + bssl::UniquePtr<EC_KEY> key(EC_KEY_new()); + bssl::UniquePtr<EC_POINT> pub_key(EC_POINT_new(group.get())); if (!key || !pub_key || !EC_KEY_set_group(key.get(), group.get()) || !EC_KEY_set_private_key(key.get(), priv_key.get()) || @@ -85,15 +86,15 @@ static bool TestECDSASign(FileTest *t, void *arg) { } // |ECDSA_do_sign_ex| expects |k| to already be inverted. - ScopedBN_CTX ctx(BN_CTX_new()); + bssl::UniquePtr<BN_CTX> ctx(BN_CTX_new()); if (!ctx || !BN_mod_inverse(k.get(), k.get(), EC_GROUP_get0_order(group.get()), ctx.get())) { return false; } - ScopedECDSA_SIG sig(ECDSA_do_sign_ex(digest.data(), digest.size(), k.get(), - r.get(), key.get())); + bssl::UniquePtr<ECDSA_SIG> sig(ECDSA_do_sign_ex(digest.data(), digest.size(), k.get(), + r.get(), key.get())); if (!sig) { return false; } diff --git a/crypto/ecdsa/ecdsa_test.cc b/crypto/ecdsa/ecdsa_test.cc index 8d7827df..7c68de44 100644 --- a/crypto/ecdsa/ecdsa_test.cc +++ b/crypto/ecdsa/ecdsa_test.cc @@ -62,8 +62,6 @@ #include <openssl/nid.h> #include <openssl/rand.h> -#include "../test/scoped_types.h" - enum Api { kEncodedApi, kRawApi, @@ -82,7 +80,7 @@ static bool VerifyECDSASig(Api api, const uint8_t *digest, if (!ECDSA_SIG_to_bytes(&der, &der_len, ecdsa_sig)) { return false; } - ScopedOpenSSLBytes delete_der(der); + bssl::UniquePtr<uint8_t> delete_der(der); actual_result = ECDSA_verify(0, digest, digest_len, der, der_len, eckey); break; } @@ -171,7 +169,7 @@ static bool TestBuiltin(FILE *out) { fprintf(out, "%s: ", kCurves[n].name); int nid = kCurves[n].nid; - ScopedEC_GROUP group(EC_GROUP_new_by_curve_name(nid)); + bssl::UniquePtr<EC_GROUP> group(EC_GROUP_new_by_curve_name(nid)); if (!group) { fprintf(out, " failed\n"); return false; @@ -184,14 +182,14 @@ static bool TestBuiltin(FILE *out) { } // Create a new ECDSA key. - ScopedEC_KEY eckey(EC_KEY_new()); + bssl::UniquePtr<EC_KEY> eckey(EC_KEY_new()); if (!eckey || !EC_KEY_set_group(eckey.get(), group.get()) || !EC_KEY_generate_key(eckey.get())) { fprintf(out, " failed\n"); return false; } // Create a second key. - ScopedEC_KEY wrong_eckey(EC_KEY_new()); + bssl::UniquePtr<EC_KEY> wrong_eckey(EC_KEY_new()); if (!wrong_eckey || !EC_KEY_set_group(wrong_eckey.get(), group.get()) || !EC_KEY_generate_key(wrong_eckey.get())) { fprintf(out, " failed\n"); @@ -253,7 +251,7 @@ static bool TestBuiltin(FILE *out) { fprintf(out, "."); fflush(out); // Verify a tampered signature. - ScopedECDSA_SIG ecdsa_sig(ECDSA_SIG_from_bytes( + bssl::UniquePtr<ECDSA_SIG> ecdsa_sig(ECDSA_SIG_from_bytes( signature.data(), signature.size())); if (!ecdsa_sig || !TestTamperedSig(out, kEncodedApi, digest, 20, ecdsa_sig.get(), @@ -313,7 +311,7 @@ static bool TestBuiltin(FILE *out) { static bool TestECDSA_SIG_max_len(size_t order_len) { /* Create the largest possible |ECDSA_SIG| of the given constraints. */ - ScopedECDSA_SIG sig(ECDSA_SIG_new()); + bssl::UniquePtr<ECDSA_SIG> sig(ECDSA_SIG_new()); if (!sig) { return false; } @@ -328,7 +326,7 @@ static bool TestECDSA_SIG_max_len(size_t order_len) { if (!ECDSA_SIG_to_bytes(&der, &der_len, sig.get())) { return false; } - ScopedOpenSSLBytes delete_der(der); + bssl::UniquePtr<uint8_t> delete_der(der); size_t max_len = ECDSA_SIG_max_len(order_len); if (max_len != der_len) { diff --git a/crypto/ecdsa/ecdsa_verify_test.cc b/crypto/ecdsa/ecdsa_verify_test.cc index 7ef2d29f..18340e2b 100644 --- a/crypto/ecdsa/ecdsa_verify_test.cc +++ b/crypto/ecdsa/ecdsa_verify_test.cc @@ -21,58 +21,59 @@ #include <openssl/ec.h> #include <openssl/ec_key.h> #include <openssl/ecdsa.h> +#include <openssl/nid.h> #include "../test/file_test.h" -#include "../test/scoped_types.h" -static ScopedEC_GROUP GetCurve(FileTest *t, const char *key) { +static bssl::UniquePtr<EC_GROUP> GetCurve(FileTest *t, const char *key) { std::string curve_name; if (!t->GetAttribute(&curve_name, key)) { return nullptr; } if (curve_name == "P-224") { - return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp224r1)); + return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp224r1)); } if (curve_name == "P-256") { - return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1)); + return bssl::UniquePtr<EC_GROUP>( + EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1)); } if (curve_name == "P-384") { - return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp384r1)); + return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp384r1)); } if (curve_name == "P-521") { - return ScopedEC_GROUP(EC_GROUP_new_by_curve_name(NID_secp521r1)); + return bssl::UniquePtr<EC_GROUP>(EC_GROUP_new_by_curve_name(NID_secp521r1)); } t->PrintLine("Unknown curve '%s'", curve_name.c_str()); return nullptr; } -static ScopedBIGNUM GetBIGNUM(FileTest *t, const char *key) { +static bssl::UniquePtr<BIGNUM> GetBIGNUM(FileTest *t, const char *key) { std::vector<uint8_t> bytes; if (!t->GetBytes(&bytes, key)) { return nullptr; } - return ScopedBIGNUM(BN_bin2bn(bytes.data(), bytes.size(), nullptr)); + return bssl::UniquePtr<BIGNUM>(BN_bin2bn(bytes.data(), bytes.size(), nullptr)); } static bool TestECDSASign(FileTest *t, void *arg) { - ScopedEC_GROUP group = GetCurve(t, "Curve"); - ScopedBIGNUM x = GetBIGNUM(t, "X"); - ScopedBIGNUM y = GetBIGNUM(t, "Y"); - ScopedBIGNUM r = GetBIGNUM(t, "R"); - ScopedBIGNUM s = GetBIGNUM(t, "S"); + bssl::UniquePtr<EC_GROUP> group = GetCurve(t, "Curve"); + bssl::UniquePtr<BIGNUM> x = GetBIGNUM(t, "X"); + bssl::UniquePtr<BIGNUM> y = GetBIGNUM(t, "Y"); + bssl::UniquePtr<BIGNUM> r = GetBIGNUM(t, "R"); + bssl::UniquePtr<BIGNUM> s = GetBIGNUM(t, "S"); std::vector<uint8_t> digest; if (!group || !x || !y || !r || !s || !t->GetBytes(&digest, "Digest")) { return false; } - ScopedEC_KEY key(EC_KEY_new()); - ScopedEC_POINT pub_key(EC_POINT_new(group.get())); - ScopedECDSA_SIG sig(ECDSA_SIG_new()); + bssl::UniquePtr<EC_KEY> key(EC_KEY_new()); + bssl::UniquePtr<EC_POINT> pub_key(EC_POINT_new(group.get())); + bssl::UniquePtr<ECDSA_SIG> sig(ECDSA_SIG_new()); if (!key || !pub_key || !sig || !EC_KEY_set_group(key.get(), group.get()) || !EC_POINT_set_affine_coordinates_GFp(group.get(), pub_key.get(), x.get(), diff --git a/crypto/evp/evp_extra_test.cc b/crypto/evp/evp_extra_test.cc index b2c519eb..125dc032 100644 --- a/crypto/evp/evp_extra_test.cc +++ b/crypto/evp/evp_extra_test.cc @@ -24,10 +24,9 @@ #include <openssl/c++/digest.h> #include <openssl/crypto.h> #include <openssl/err.h> +#include <openssl/pkcs8.h> #include <openssl/rsa.h> -#include "../test/scoped_types.h" - namespace bssl { // kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you @@ -357,13 +356,13 @@ static const uint8_t kInvalidPrivateKey[] = { 0x48, 0x30, 0x01, 0xaa, 0x02, 0x86, 0xc0, 0x30, 0xdf, 0xe9, 0x80, }; -static ScopedEVP_PKEY LoadExampleRSAKey() { - ScopedRSA rsa(RSA_private_key_from_bytes(kExampleRSAKeyDER, +static bssl::UniquePtr<EVP_PKEY> LoadExampleRSAKey() { + bssl::UniquePtr<RSA> rsa(RSA_private_key_from_bytes(kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER))); if (!rsa) { return nullptr; } - ScopedEVP_PKEY pkey(EVP_PKEY_new()); + bssl::UniquePtr<EVP_PKEY> pkey(EVP_PKEY_new()); if (!pkey || !EVP_PKEY_set1_RSA(pkey.get(), rsa.get())) { return nullptr; } @@ -371,7 +370,7 @@ static ScopedEVP_PKEY LoadExampleRSAKey() { } static bool TestEVP_DigestSignInit(void) { - ScopedEVP_PKEY pkey = LoadExampleRSAKey(); + bssl::UniquePtr<EVP_PKEY> pkey = LoadExampleRSAKey(); ScopedEVP_MD_CTX md_ctx; if (!pkey || !EVP_DigestSignInit(md_ctx.get(), NULL, EVP_sha256(), NULL, pkey.get()) || @@ -409,7 +408,7 @@ static bool TestEVP_DigestSignInit(void) { } static bool TestEVP_DigestVerifyInit(void) { - ScopedEVP_PKEY pkey = LoadExampleRSAKey(); + bssl::UniquePtr<EVP_PKEY> pkey = LoadExampleRSAKey(); ScopedEVP_MD_CTX md_ctx; if (!pkey || !EVP_DigestVerifyInit(md_ctx.get(), NULL, EVP_sha256(), NULL, @@ -422,12 +421,12 @@ static bool TestEVP_DigestVerifyInit(void) { } static bool TestVerifyRecover() { - ScopedEVP_PKEY pkey = LoadExampleRSAKey(); + bssl::UniquePtr<EVP_PKEY> pkey = LoadExampleRSAKey(); if (!pkey) { return false; } - ScopedRSA rsa(EVP_PKEY_get1_RSA(pkey.get())); + bssl::UniquePtr<RSA> rsa(EVP_PKEY_get1_RSA(pkey.get())); if (!rsa) { return false; } @@ -444,7 +443,7 @@ static bool TestVerifyRecover() { } size_t out_len; - ScopedEVP_PKEY_CTX ctx(EVP_PKEY_CTX_new(pkey.get(), nullptr)); + bssl::UniquePtr<EVP_PKEY_CTX> ctx(EVP_PKEY_CTX_new(pkey.get(), nullptr)); if (!EVP_PKEY_verify_recover_init(ctx.get()) || !EVP_PKEY_CTX_set_rsa_padding(ctx.get(), RSA_PKCS1_PADDING) || !EVP_PKEY_CTX_set_signature_md(ctx.get(), EVP_sha256()) || @@ -502,7 +501,7 @@ static bool TestVerifyRecover() { static bool TestValidPrivateKey(const uint8_t *input, size_t input_len, int expected_id) { const uint8_t *p = input; - ScopedEVP_PKEY pkey(d2i_AutoPrivateKey(NULL, &p, input_len)); + bssl::UniquePtr<EVP_PKEY> pkey(d2i_AutoPrivateKey(NULL, &p, input_len)); if (!pkey || p != input + input_len) { fprintf(stderr, "d2i_AutoPrivateKey failed\n"); return false; @@ -556,7 +555,7 @@ static bool Testd2i_AutoPrivateKey() { } const uint8_t *p = kInvalidPrivateKey; - ScopedEVP_PKEY pkey(d2i_AutoPrivateKey(NULL, &p, sizeof(kInvalidPrivateKey))); + bssl::UniquePtr<EVP_PKEY> pkey(d2i_AutoPrivateKey(NULL, &p, sizeof(kInvalidPrivateKey))); if (pkey) { fprintf(stderr, "Parsed invalid private key\n"); return false; @@ -569,14 +568,14 @@ static bool Testd2i_AutoPrivateKey() { // TestEVP_PKCS82PKEY tests loading a bad key in PKCS8 format. static bool TestEVP_PKCS82PKEY(void) { const uint8_t *derp = kExampleBadECKeyDER; - ScopedPKCS8_PRIV_KEY_INFO p8inf( + bssl::UniquePtr<PKCS8_PRIV_KEY_INFO> p8inf( d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp, sizeof(kExampleBadECKeyDER))); if (!p8inf || derp != kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)) { fprintf(stderr, "Failed to parse key\n"); return false; } - ScopedEVP_PKEY pkey(EVP_PKCS82PKEY(p8inf.get())); + bssl::UniquePtr<EVP_PKEY> pkey(EVP_PKCS82PKEY(p8inf.get())); if (pkey) { fprintf(stderr, "Imported invalid EC key\n"); return false; @@ -588,7 +587,7 @@ static bool TestEVP_PKCS82PKEY(void) { // TestEVPMarshalEmptyPublicKey tests |EVP_marshal_public_key| on an empty key. static bool TestEVPMarshalEmptyPublicKey(void) { - ScopedEVP_PKEY empty(EVP_PKEY_new()); + bssl::UniquePtr<EVP_PKEY> empty(EVP_PKEY_new()); if (!empty) { return false; } @@ -608,7 +607,7 @@ static bool TestEVPMarshalEmptyPublicKey(void) { // Testd2i_PrivateKey tests |d2i_PrivateKey|. static bool Testd2i_PrivateKey(void) { const uint8_t *derp = kExampleRSAKeyDER; - ScopedEVP_PKEY pkey(d2i_PrivateKey(EVP_PKEY_RSA, nullptr, &derp, + bssl::UniquePtr<EVP_PKEY> pkey(d2i_PrivateKey(EVP_PKEY_RSA, nullptr, &derp, sizeof(kExampleRSAKeyDER))); if (!pkey || derp != kExampleRSAKeyDER + sizeof(kExampleRSAKeyDER)) { fprintf(stderr, "Failed to import raw RSA key.\n"); diff --git a/crypto/evp/evp_test.cc b/crypto/evp/evp_test.cc index 9c8735b4..58d3ebda 100644 --- a/crypto/evp/evp_test.cc +++ b/crypto/evp/evp_test.cc @@ -74,7 +74,6 @@ OPENSSL_MSVC_PRAGMA(warning(pop)) #include <openssl/err.h> #include "../test/file_test.h" -#include "../test/scoped_types.h" namespace bssl { @@ -115,7 +114,7 @@ static int GetKeyType(FileTest *t, const std::string &name) { return EVP_PKEY_NONE; } -using KeyMap = std::map<std::string, ScopedEVP_PKEY>; +using KeyMap = std::map<std::string, bssl::UniquePtr<EVP_PKEY>>; static bool ImportKey(FileTest *t, KeyMap *key_map, EVP_PKEY *(*parse_func)(CBS *cbs), @@ -127,7 +126,7 @@ static bool ImportKey(FileTest *t, KeyMap *key_map, CBS cbs; CBS_init(&cbs, input.data(), input.size()); - ScopedEVP_PKEY pkey(parse_func(&cbs)); + bssl::UniquePtr<EVP_PKEY> pkey(parse_func(&cbs)); if (!pkey) { return false; } @@ -150,7 +149,7 @@ static bool ImportKey(FileTest *t, KeyMap *key_map, !CBB_finish(cbb.get(), &der, &der_len)) { return false; } - ScopedOpenSSLBytes free_der(der); + bssl::UniquePtr<uint8_t> free_der(der); std::vector<uint8_t> output = input; if (t->HasAttribute("Output") && @@ -215,7 +214,7 @@ static bool TestEVP(FileTest *t, void *arg) { } // Set up the EVP_PKEY_CTX. - ScopedEVP_PKEY_CTX ctx(EVP_PKEY_CTX_new(key, nullptr)); + bssl::UniquePtr<EVP_PKEY_CTX> ctx(EVP_PKEY_CTX_new(key, nullptr)); if (!ctx || !key_op_init(ctx.get())) { return false; } diff --git a/crypto/newhope/newhope_statistical_test.cc b/crypto/newhope/newhope_statistical_test.cc index 44fac48a..3ca6d78d 100644 --- a/crypto/newhope/newhope_statistical_test.cc +++ b/crypto/newhope/newhope_statistical_test.cc @@ -19,9 +19,9 @@ #include <string.h> #include <openssl/crypto.h> +#include <openssl/newhope.h> #include <openssl/rand.h> -#include "../test/scoped_types.h" #include "internal.h" @@ -108,7 +108,7 @@ static bool TestKeys(void) { uint8_t key[NEWHOPE_KEY_LENGTH]; uint8_t offermsg[NEWHOPE_OFFERMSG_LENGTH]; - ScopedNEWHOPE_POLY sk(NEWHOPE_POLY_new()), pk(NEWHOPE_POLY_new()), + bssl::UniquePtr<NEWHOPE_POLY> sk(NEWHOPE_POLY_new()), pk(NEWHOPE_POLY_new()), sp(NEWHOPE_POLY_new()), ep(NEWHOPE_POLY_new()), epp(NEWHOPE_POLY_new()), a(NEWHOPE_POLY_new()), bp(NEWHOPE_POLY_new()), rec(NEWHOPE_POLY_new()); diff --git a/crypto/newhope/newhope_test.cc b/crypto/newhope/newhope_test.cc index 6637393f..a5907214 100644 --- a/crypto/newhope/newhope_test.cc +++ b/crypto/newhope/newhope_test.cc @@ -19,7 +19,6 @@ #include <openssl/crypto.h> #include <openssl/rand.h> -#include "../test/scoped_types.h" #include "internal.h" @@ -28,7 +27,7 @@ static const int kNumTests = 10; static bool TestKeys(void) { // Alice generates a public key. - ScopedNEWHOPE_POLY sk(NEWHOPE_POLY_new()); + bssl::UniquePtr<NEWHOPE_POLY> sk(NEWHOPE_POLY_new()); uint8_t offer_msg[NEWHOPE_OFFERMSG_LENGTH]; NEWHOPE_offer(offer_msg, sk.get()); @@ -58,7 +57,7 @@ static bool TestKeys(void) { static bool TestInvalidSK(void) { // Alice generates a public key. uint8_t offer_msg[NEWHOPE_OFFERMSG_LENGTH]; - ScopedNEWHOPE_POLY sk(NEWHOPE_POLY_new()); + bssl::UniquePtr<NEWHOPE_POLY> sk(NEWHOPE_POLY_new()); NEWHOPE_offer(offer_msg, sk.get()); // Bob derives a secret key and creates a response. @@ -93,7 +92,7 @@ static bool TestInvalidSK(void) { static bool TestInvalidAcceptMsg(void) { // Alice generates a public key. - ScopedNEWHOPE_POLY sk(NEWHOPE_POLY_new()); + bssl::UniquePtr<NEWHOPE_POLY> sk(NEWHOPE_POLY_new()); uint8_t offer_msg[NEWHOPE_OFFERMSG_LENGTH]; NEWHOPE_offer(offer_msg, sk.get()); diff --git a/crypto/newhope/newhope_vectors_test.cc b/crypto/newhope/newhope_vectors_test.cc index fe84cd4b..64aa0bbc 100644 --- a/crypto/newhope/newhope_vectors_test.cc +++ b/crypto/newhope/newhope_vectors_test.cc @@ -20,17 +20,16 @@ #include <openssl/rand.h> #include "../test/file_test.h" -#include "../test/scoped_types.h" #include "internal.h" static bool TestNewhope(FileTest *t, void *arg) { - ScopedNEWHOPE_POLY a(NEWHOPE_POLY_new()); - ScopedNEWHOPE_POLY s(NEWHOPE_POLY_new()), sp(NEWHOPE_POLY_new()); - ScopedNEWHOPE_POLY e(NEWHOPE_POLY_new()), ep(NEWHOPE_POLY_new()), + bssl::UniquePtr<NEWHOPE_POLY> a(NEWHOPE_POLY_new()); + bssl::UniquePtr<NEWHOPE_POLY> s(NEWHOPE_POLY_new()), sp(NEWHOPE_POLY_new()); + bssl::UniquePtr<NEWHOPE_POLY> e(NEWHOPE_POLY_new()), ep(NEWHOPE_POLY_new()), epp(NEWHOPE_POLY_new()); - ScopedNEWHOPE_POLY in_pk(NEWHOPE_POLY_new()); - ScopedNEWHOPE_POLY in_rec(NEWHOPE_POLY_new()); + bssl::UniquePtr<NEWHOPE_POLY> in_pk(NEWHOPE_POLY_new()); + bssl::UniquePtr<NEWHOPE_POLY> in_rec(NEWHOPE_POLY_new()); if (t->GetType() == "InRandA") { std::vector<uint8_t> a_bytes, s_bytes, e_bytes, expected_pk; diff --git a/crypto/pkcs8/pkcs12_test.cc b/crypto/pkcs8/pkcs12_test.cc index 17bcd273..5c1a1b48 100644 --- a/crypto/pkcs8/pkcs12_test.cc +++ b/crypto/pkcs8/pkcs12_test.cc @@ -23,8 +23,6 @@ #include <openssl/stack.h> #include <openssl/x509.h> -#include "../test/scoped_types.h" - /* kPKCS12DER contains sample PKCS#12 data generated by OpenSSL with: * openssl pkcs12 -export -inkey key.pem -in cacert.pem */ @@ -684,7 +682,7 @@ static const uint8_t kWindows[] = { static const char kPassword[] = "foo"; static bool Test(const char *name, const uint8_t *der, size_t der_len) { - ScopedX509Stack certs(sk_X509_new_null()); + bssl::UniquePtr<STACK_OF(X509)> certs(sk_X509_new_null()); if (!certs) { return false; } @@ -697,7 +695,7 @@ static bool Test(const char *name, const uint8_t *der, size_t der_len) { ERR_print_errors_fp(stderr); return false; } - ScopedEVP_PKEY delete_key(key); + bssl::UniquePtr<EVP_PKEY> delete_key(key); if (sk_X509_num(certs.get()) != 1 || key == nullptr) { fprintf(stderr, "Bad result from %s data.\n", name); @@ -708,12 +706,12 @@ static bool Test(const char *name, const uint8_t *der, size_t der_len) { } static bool TestCompat(const uint8_t *der, size_t der_len) { - ScopedBIO bio(BIO_new_mem_buf(der, der_len)); + bssl::UniquePtr<BIO> bio(BIO_new_mem_buf(der, der_len)); if (!bio) { return false; } - ScopedPKCS12 p12(d2i_PKCS12_bio(bio.get(), nullptr)); + bssl::UniquePtr<PKCS12> p12(d2i_PKCS12_bio(bio.get(), nullptr)); if (!p12) { fprintf(stderr, "PKCS12_parse failed.\n"); ERR_print_errors_fp(stderr); @@ -738,9 +736,9 @@ static bool TestCompat(const uint8_t *der, size_t der_len) { ERR_print_errors_fp(stderr); return false; } - ScopedEVP_PKEY delete_key(key); - ScopedX509 delete_cert(cert); - ScopedX509Stack delete_ca_certs(ca_certs); + bssl::UniquePtr<EVP_PKEY> delete_key(key); + bssl::UniquePtr<X509> delete_cert(cert); + bssl::UniquePtr<STACK_OF(X509)> delete_ca_certs(ca_certs); if (key == nullptr || cert == nullptr) { fprintf(stderr, "Bad result from PKCS12_parse.\n"); diff --git a/crypto/pkcs8/pkcs8_test.cc b/crypto/pkcs8/pkcs8_test.cc index 7a88ddf4..cbb20438 100644 --- a/crypto/pkcs8/pkcs8_test.cc +++ b/crypto/pkcs8/pkcs8_test.cc @@ -21,8 +21,6 @@ #include <openssl/pkcs8.h> #include <openssl/x509.h> -#include "../test/scoped_types.h" - /* kDER is a PKCS#8 encrypted private key. It was generated with: * @@ -64,14 +62,14 @@ static const uint8_t kDER[] = { static bool test(const uint8_t *der, size_t der_len) { const uint8_t *data = der; - ScopedX509_SIG sig(d2i_X509_SIG(NULL, &data, der_len)); + bssl::UniquePtr<X509_SIG> sig(d2i_X509_SIG(NULL, &data, der_len)); if (sig.get() == NULL || data != der + der_len) { fprintf(stderr, "d2i_X509_SIG failed or did not consume all bytes.\n"); return false; } static const char kPassword[] = "testing"; - ScopedPKCS8_PRIV_KEY_INFO keypair(PKCS8_decrypt(sig.get(), kPassword, -1)); + bssl::UniquePtr<PKCS8_PRIV_KEY_INFO> keypair(PKCS8_decrypt(sig.get(), kPassword, -1)); if (!keypair) { fprintf(stderr, "PKCS8_decrypt failed.\n"); ERR_print_errors_fp(stderr); diff --git a/crypto/rsa/rsa_test.cc b/crypto/rsa/rsa_test.cc index 62177a4c..8c4a7871 100644 --- a/crypto/rsa/rsa_test.cc +++ b/crypto/rsa/rsa_test.cc @@ -65,8 +65,6 @@ #include <openssl/err.h> #include <openssl/nid.h> -#include "../test/scoped_types.h" - // kPlaintext is a sample plaintext. static const uint8_t kPlaintext[] = "\x54\x85\x9b\x34\x2c\x49\xea\x2a"; @@ -526,7 +524,7 @@ static const uint8_t kExponent1RSAKey[] = { static bool TestRSA(const uint8_t *der, size_t der_len, const uint8_t *oaep_ciphertext, size_t oaep_ciphertext_len) { - ScopedRSA key(RSA_private_key_from_bytes(der, der_len)); + bssl::UniquePtr<RSA> key(RSA_private_key_from_bytes(der, der_len)); if (!key) { return false; } @@ -612,7 +610,7 @@ static bool TestRSA(const uint8_t *der, size_t der_len, static bool TestMultiPrimeKey(int nprimes, const uint8_t *der, size_t der_size, const uint8_t *enc, size_t enc_size) { - ScopedRSA rsa(d2i_RSAPrivateKey(nullptr, &der, der_size)); + bssl::UniquePtr<RSA> rsa(d2i_RSAPrivateKey(nullptr, &der, der_size)); if (!rsa) { fprintf(stderr, "%d-prime key failed to parse.\n", nprimes); ERR_print_errors_fp(stderr); @@ -645,8 +643,8 @@ static bool TestMultiPrimeKeygen() { uint8_t encrypted[kBits / 8], decrypted[kBits / 8]; size_t encrypted_len, decrypted_len; - ScopedRSA rsa(RSA_new()); - ScopedBIGNUM e(BN_new()); + bssl::UniquePtr<RSA> rsa(RSA_new()); + bssl::UniquePtr<BIGNUM> e(BN_new()); if (!rsa || !e || !BN_set_word(e.get(), RSA_F4) || !RSA_generate_multi_prime_key(rsa.get(), kBits, 3, e.get(), nullptr) || @@ -666,8 +664,8 @@ static bool TestMultiPrimeKeygen() { } static bool TestBadKey() { - ScopedRSA key(RSA_new()); - ScopedBIGNUM e(BN_new()); + bssl::UniquePtr<RSA> key(RSA_new()); + bssl::UniquePtr<BIGNUM> e(BN_new()); if (!key || !e || !BN_set_word(e.get(), RSA_F4)) { return false; @@ -705,7 +703,7 @@ static bool TestOnlyDGiven() { uint8_t buf[64]; unsigned buf_len = sizeof(buf); - ScopedRSA key(RSA_new()); + bssl::UniquePtr<RSA> key(RSA_new()); if (!key || !BN_hex2bn(&key->n, kN) || !BN_hex2bn(&key->e, kE) || @@ -739,7 +737,7 @@ static bool TestOnlyDGiven() { // Keys without the public exponent must continue to work when blinding is // disabled to support Java's RSAPrivateKeySpec API. See // https://bugs.chromium.org/p/boringssl/issues/detail?id=12. - ScopedRSA key2(RSA_new()); + bssl::UniquePtr<RSA> key2(RSA_new()); if (!key2 || !BN_hex2bn(&key2->n, kN) || !BN_hex2bn(&key2->d, kD)) { @@ -772,7 +770,7 @@ static bool TestOnlyDGiven() { } static bool TestRecoverCRTParams() { - ScopedBIGNUM e(BN_new()); + bssl::UniquePtr<BIGNUM> e(BN_new()); if (!e || !BN_set_word(e.get(), RSA_F4)) { return false; } @@ -780,7 +778,7 @@ static bool TestRecoverCRTParams() { ERR_clear_error(); for (unsigned i = 0; i < 1; i++) { - ScopedRSA key1(RSA_new()); + bssl::UniquePtr<RSA> key1(RSA_new()); if (!key1 || !RSA_generate_key_ex(key1.get(), 512, e.get(), nullptr)) { fprintf(stderr, "RSA_generate_key_ex failed.\n"); @@ -794,7 +792,7 @@ static bool TestRecoverCRTParams() { return false; } - ScopedRSA key2(RSA_new()); + bssl::UniquePtr<RSA> key2(RSA_new()); if (!key2) { return false; } @@ -844,7 +842,7 @@ static bool TestRecoverCRTParams() { static bool TestASN1() { // Test that private keys may be decoded. - ScopedRSA rsa(RSA_private_key_from_bytes(kKey1, sizeof(kKey1) - 1)); + bssl::UniquePtr<RSA> rsa(RSA_private_key_from_bytes(kKey1, sizeof(kKey1) - 1)); if (!rsa) { return false; } @@ -855,7 +853,7 @@ static bool TestASN1() { if (!RSA_private_key_to_bytes(&der, &der_len, rsa.get())) { return false; } - ScopedOpenSSLBytes delete_der(der); + bssl::UniquePtr<uint8_t> delete_der(der); if (der_len != sizeof(kKey1) - 1 || memcmp(der, kKey1, der_len) != 0) { return false; } @@ -878,7 +876,7 @@ static bool TestASN1() { if (!RSA_public_key_to_bytes(&der2, &der2_len, rsa.get())) { return false; } - ScopedOpenSSLBytes delete_der2(der2); + bssl::UniquePtr<uint8_t> delete_der2(der2); if (der_len != der2_len || memcmp(der, der2, der_len) != 0) { return false; } @@ -910,7 +908,7 @@ static bool TestASN1() { } static bool TestBadExponent() { - ScopedRSA rsa(RSA_public_key_from_bytes(kExponent1RSAKey, + bssl::UniquePtr<RSA> rsa(RSA_public_key_from_bytes(kExponent1RSAKey, sizeof(kExponent1RSAKey))); if (rsa) { diff --git a/crypto/test/scoped_types.h b/crypto/test/scoped_types.h deleted file mode 100644 index c124235d..00000000 --- a/crypto/test/scoped_types.h +++ /dev/null @@ -1,133 +0,0 @@ -/* Copyright (c) 2015, Google Inc. - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION - * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN - * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ - -#ifndef OPENSSL_HEADER_CRYPTO_TEST_SCOPED_TYPES_H -#define OPENSSL_HEADER_CRYPTO_TEST_SCOPED_TYPES_H - -#include <stdint.h> -#include <stdio.h> - -#include <memory> - -#include <openssl/aead.h> -#include <openssl/asn1.h> -#include <openssl/bio.h> -#include <openssl/bn.h> -#include <openssl/bytestring.h> -#include <openssl/cmac.h> -#include <openssl/curve25519.h> -#include <openssl/dh.h> -#include <openssl/ecdsa.h> -#include <openssl/ec.h> -#include <openssl/ec_key.h> -#include <openssl/evp.h> -#include <openssl/hmac.h> -#include <openssl/mem.h> -#include <openssl/newhope.h> -#include <openssl/pkcs8.h> -#include <openssl/rsa.h> -#include <openssl/stack.h> -#include <openssl/x509.h> - - -template<typename T, void (*func)(T*)> -struct OpenSSLDeleter { - void operator()(T *obj) { - func(obj); - } -}; - -template<typename StackType, typename T, void (*func)(T*)> -struct OpenSSLStackDeleter { - void operator()(StackType *obj) { - sk_pop_free(reinterpret_cast<_STACK*>(obj), - reinterpret_cast<void (*)(void *)>(func)); - } -}; - -template<typename T> -struct OpenSSLFree { - void operator()(T *buf) { - OPENSSL_free(buf); - } -}; - -struct FileCloser { - void operator()(FILE *file) { - fclose(file); - } -}; - -template<typename T, void (*func)(T*)> -using ScopedOpenSSLType = std::unique_ptr<T, OpenSSLDeleter<T, func>>; - -template<typename StackType, typename T, void (*func)(T*)> -using ScopedOpenSSLStack = - std::unique_ptr<StackType, OpenSSLStackDeleter<StackType, T, func>>; - -template<typename T, typename CleanupRet, void (*init_func)(T*), - CleanupRet (*cleanup_func)(T*)> -class ScopedOpenSSLContext { - public: - ScopedOpenSSLContext() { - init_func(&ctx_); - } - ~ScopedOpenSSLContext() { - cleanup_func(&ctx_); - } - - T *get() { return &ctx_; } - const T *get() const { return &ctx_; } - - void Reset() { - cleanup_func(&ctx_); - init_func(&ctx_); - } - - private: - T ctx_; -}; - -using ScopedASN1_TYPE = ScopedOpenSSLType<ASN1_TYPE, ASN1_TYPE_free>; -using ScopedBIO = ScopedOpenSSLType<BIO, BIO_vfree>; -using ScopedBIGNUM = ScopedOpenSSLType<BIGNUM, BN_free>; -using ScopedBN_CTX = ScopedOpenSSLType<BN_CTX, BN_CTX_free>; -using ScopedBN_MONT_CTX = ScopedOpenSSLType<BN_MONT_CTX, BN_MONT_CTX_free>; -using ScopedCMAC_CTX = ScopedOpenSSLType<CMAC_CTX, CMAC_CTX_free>; -using ScopedDH = ScopedOpenSSLType<DH, DH_free>; -using ScopedECDSA_SIG = ScopedOpenSSLType<ECDSA_SIG, ECDSA_SIG_free>; -using ScopedEC_GROUP = ScopedOpenSSLType<EC_GROUP, EC_GROUP_free>; -using ScopedEC_KEY = ScopedOpenSSLType<EC_KEY, EC_KEY_free>; -using ScopedEC_POINT = ScopedOpenSSLType<EC_POINT, EC_POINT_free>; -using ScopedEVP_PKEY = ScopedOpenSSLType<EVP_PKEY, EVP_PKEY_free>; -using ScopedEVP_PKEY_CTX = ScopedOpenSSLType<EVP_PKEY_CTX, EVP_PKEY_CTX_free>; -using ScopedNEWHOPE_POLY = ScopedOpenSSLType<NEWHOPE_POLY, NEWHOPE_POLY_free>; -using ScopedPKCS8_PRIV_KEY_INFO = ScopedOpenSSLType<PKCS8_PRIV_KEY_INFO, - PKCS8_PRIV_KEY_INFO_free>; -using ScopedPKCS12 = ScopedOpenSSLType<PKCS12, PKCS12_free>; -using ScopedSPAKE2_CTX = ScopedOpenSSLType<SPAKE2_CTX, SPAKE2_CTX_free>; -using ScopedRSA = ScopedOpenSSLType<RSA, RSA_free>; -using ScopedX509 = ScopedOpenSSLType<X509, X509_free>; -using ScopedX509_ALGOR = ScopedOpenSSLType<X509_ALGOR, X509_ALGOR_free>; -using ScopedX509_SIG = ScopedOpenSSLType<X509_SIG, X509_SIG_free>; -using ScopedX509_STORE_CTX = ScopedOpenSSLType<X509_STORE_CTX, X509_STORE_CTX_free>; - -using ScopedX509Stack = ScopedOpenSSLStack<STACK_OF(X509), X509, X509_free>; - -using ScopedOpenSSLBytes = std::unique_ptr<uint8_t, OpenSSLFree<uint8_t>>; -using ScopedOpenSSLString = std::unique_ptr<char, OpenSSLFree<char>>; - -using ScopedFILE = std::unique_ptr<FILE, FileCloser>; - -#endif // OPENSSL_HEADER_CRYPTO_TEST_SCOPED_TYPES_H diff --git a/crypto/x509/x509_test.cc b/crypto/x509/x509_test.cc index d1eed2a3..3c7cc636 100644 --- a/crypto/x509/x509_test.cc +++ b/crypto/x509/x509_test.cc @@ -23,8 +23,6 @@ #include <openssl/pem.h> #include <openssl/x509.h> -#include "../test/scoped_types.h" - namespace bssl { static const char kCrossSigningRootPEM[] = @@ -226,23 +224,25 @@ static const char kRSAKey[] = // CertFromPEM parses the given, NUL-terminated pem block and returns an // |X509*|. -static ScopedX509 CertFromPEM(const char *pem) { - ScopedBIO bio(BIO_new_mem_buf(pem, strlen(pem))); - return ScopedX509(PEM_read_bio_X509(bio.get(), nullptr, nullptr, nullptr)); +static bssl::UniquePtr<X509> CertFromPEM(const char *pem) { + bssl::UniquePtr<BIO> bio(BIO_new_mem_buf(pem, strlen(pem))); + return bssl::UniquePtr<X509>( + PEM_read_bio_X509(bio.get(), nullptr, nullptr, nullptr)); } // PrivateKeyFromPEM parses the given, NUL-terminated pem block and returns an // |EVP_PKEY*|. -static ScopedEVP_PKEY PrivateKeyFromPEM(const char *pem) { - ScopedBIO bio(BIO_new_mem_buf(const_cast<char *>(pem), strlen(pem))); - return ScopedEVP_PKEY( +static bssl::UniquePtr<EVP_PKEY> PrivateKeyFromPEM(const char *pem) { + bssl::UniquePtr<BIO> bio( + BIO_new_mem_buf(const_cast<char *>(pem), strlen(pem))); + return bssl::UniquePtr<EVP_PKEY>( PEM_read_bio_PrivateKey(bio.get(), nullptr, nullptr, nullptr)); } // CertsToStack converts a vector of |X509*| to an OpenSSL STACK_OF(X509*), // bumping the reference counts for each certificate in question. static STACK_OF(X509)* CertsToStack(const std::vector<X509*> &certs) { - ScopedX509Stack stack(sk_X509_new_null()); + bssl::UniquePtr<STACK_OF(X509)> stack(sk_X509_new_null()); if (!stack) { return nullptr; } @@ -259,14 +259,16 @@ static STACK_OF(X509)* CertsToStack(const std::vector<X509*> &certs) { static bool Verify(X509 *leaf, const std::vector<X509 *> &roots, const std::vector<X509 *> &intermediates, unsigned long flags = 0) { - ScopedX509Stack roots_stack(CertsToStack(roots)); - ScopedX509Stack intermediates_stack(CertsToStack(intermediates)); + bssl::UniquePtr<STACK_OF(X509)> roots_stack(CertsToStack(roots)); + bssl::UniquePtr<STACK_OF(X509)> intermediates_stack( + CertsToStack(intermediates)); + if (!roots_stack || !intermediates_stack) { return false; } - ScopedX509_STORE_CTX ctx(X509_STORE_CTX_new()); + bssl::UniquePtr<X509_STORE_CTX> ctx(X509_STORE_CTX_new()); if (!ctx) { return false; } @@ -293,14 +295,15 @@ static bool Verify(X509 *leaf, const std::vector<X509 *> &roots, } static bool TestVerify() { - ScopedX509 cross_signing_root(CertFromPEM(kCrossSigningRootPEM)); - ScopedX509 root(CertFromPEM(kRootCAPEM)); - ScopedX509 root_cross_signed(CertFromPEM(kRootCrossSignedPEM)); - ScopedX509 intermediate(CertFromPEM(kIntermediatePEM)); - ScopedX509 intermediate_self_signed(CertFromPEM(kIntermediateSelfSignedPEM)); - ScopedX509 leaf(CertFromPEM(kLeafPEM)); - ScopedX509 leaf_no_key_usage(CertFromPEM(kLeafNoKeyUsagePEM)); - ScopedX509 forgery(CertFromPEM(kForgeryPEM)); + bssl::UniquePtr<X509> cross_signing_root(CertFromPEM(kCrossSigningRootPEM)); + bssl::UniquePtr<X509> root(CertFromPEM(kRootCAPEM)); + bssl::UniquePtr<X509> root_cross_signed(CertFromPEM(kRootCrossSignedPEM)); + bssl::UniquePtr<X509> intermediate(CertFromPEM(kIntermediatePEM)); + bssl::UniquePtr<X509> intermediate_self_signed( + CertFromPEM(kIntermediateSelfSignedPEM)); + bssl::UniquePtr<X509> leaf(CertFromPEM(kLeafPEM)); + bssl::UniquePtr<X509> leaf_no_key_usage(CertFromPEM(kLeafNoKeyUsagePEM)); + bssl::UniquePtr<X509> forgery(CertFromPEM(kForgeryPEM)); if (!cross_signing_root || !root || @@ -380,12 +383,12 @@ static bool TestVerify() { } static bool TestPSS() { - ScopedX509 cert(CertFromPEM(kExamplePSSCert)); + bssl::UniquePtr<X509> cert(CertFromPEM(kExamplePSSCert)); if (!cert) { return false; } - ScopedEVP_PKEY pkey(X509_get_pubkey(cert.get())); + bssl::UniquePtr<EVP_PKEY> pkey(X509_get_pubkey(cert.get())); if (!pkey) { return false; } @@ -398,12 +401,12 @@ static bool TestPSS() { } static bool TestBadPSSParameters() { - ScopedX509 cert(CertFromPEM(kBadPSSCertPEM)); + bssl::UniquePtr<X509> cert(CertFromPEM(kBadPSSCertPEM)); if (!cert) { return false; } - ScopedEVP_PKEY pkey(X509_get_pubkey(cert.get())); + bssl::UniquePtr<EVP_PKEY> pkey(X509_get_pubkey(cert.get())); if (!pkey) { return false; } @@ -418,7 +421,7 @@ static bool TestBadPSSParameters() { static bool SignatureRoundTrips(EVP_MD_CTX *md_ctx, EVP_PKEY *pkey) { // Make a certificate like signed with |md_ctx|'s settings.' - ScopedX509 cert(CertFromPEM(kLeafPEM)); + bssl::UniquePtr<X509> cert(CertFromPEM(kLeafPEM)); if (!cert || !X509_sign_ctx(cert.get(), md_ctx)) { return false; } @@ -429,7 +432,7 @@ static bool SignatureRoundTrips(EVP_MD_CTX *md_ctx, EVP_PKEY *pkey) { } static bool TestSignCtx() { - ScopedEVP_PKEY pkey(PrivateKeyFromPEM(kRSAKey)); + bssl::UniquePtr<EVP_PKEY> pkey(PrivateKeyFromPEM(kRSAKey)); if (!pkey) { return false; } |