Use std::make_unique when possible We've required C++14 for a while now. As we're mostly C with a little C++, this is less helpful, but may as well avoid bare new where possible. Change-Id: Icf3386e3f3b6f2092bb0089ed874cc50985f1a40 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/61429 Reviewed-by: Bob Beck <bbe@google.com> Commit-Queue: David Benjamin <davidben@google.com>
diff --git a/crypto/chacha/chacha_test.cc b/crypto/chacha/chacha_test.cc index 00683ce..d4e5332 100644 --- a/crypto/chacha/chacha_test.cc +++ b/crypto/chacha/chacha_test.cc
@@ -320,7 +320,7 @@ for (size_t len = 0; len <= sizeof(kInput); len++) { SCOPED_TRACE(len); - std::unique_ptr<uint8_t[]> buf(new uint8_t[len]); + auto buf = std::make_unique<uint8_t[]>(len); CRYPTO_chacha_20(buf.get(), kInput, len, kKey, kNonce, kCounter); EXPECT_EQ(Bytes(kOutput, len), Bytes(buf.get(), len)); @@ -336,7 +336,7 @@ for (size_t len = 0; len <= sizeof(kInput); len++) { SCOPED_TRACE(len); - std::unique_ptr<uint8_t[]> buf(new uint8_t[len]); + auto buf = std::make_unique<uint8_t[]>(len); CRYPTO_chacha_20(buf.get(), kInput, len, kKey, kNonce, kOverflowCounter); EXPECT_EQ(Bytes(kOverflowOutput, len), Bytes(buf.get(), len)); @@ -354,7 +354,7 @@ static const uint32_t kCounterNonce[4] = {0}; - std::unique_ptr<uint8_t[]> buf(new uint8_t[sizeof(kInput)]); + auto buf = std::make_unique<uint8_t[]>(sizeof(kInput)); for (size_t len = 0; len <= 32; len++) { SCOPED_TRACE(len); CHECK_ABI(ChaCha20_ctr32, buf.get(), kInput, len, key, kCounterNonce);
diff --git a/crypto/cipher_extra/aead_test.cc b/crypto/cipher_extra/aead_test.cc index a8d2dbd..64c65e9 100644 --- a/crypto/cipher_extra/aead_test.cc +++ b/crypto/cipher_extra/aead_test.cc
@@ -821,7 +821,7 @@ return; } - std::unique_ptr<uint8_t[]> buf(new uint8_t[1024]); + auto buf = std::make_unique<uint8_t[]>(1024); for (size_t len = 0; len <= 1024; len += 5) { SCOPED_TRACE(len); union chacha20_poly1305_open_data open_ctx = {};
diff --git a/crypto/digest_extra/digest_test.cc b/crypto/digest_extra/digest_test.cc index 12858e2..d15e4d1 100644 --- a/crypto/digest_extra/digest_test.cc +++ b/crypto/digest_extra/digest_test.cc
@@ -167,7 +167,7 @@ for (size_t i = 0; i < test->repeat; i++) { ASSERT_TRUE(EVP_DigestUpdate(ctx.get(), test->input, strlen(test->input))); } - std::unique_ptr<uint8_t[]> digest(new uint8_t[EVP_MD_size(test->md.func())]); + auto digest = std::make_unique<uint8_t[]>(EVP_MD_size(test->md.func())); unsigned digest_len; ASSERT_TRUE(EVP_DigestFinal_ex(ctx.get(), digest.get(), &digest_len)); CompareDigest(test, digest.get(), digest_len);
diff --git a/crypto/fipsmodule/aes/aes_test.cc b/crypto/fipsmodule/aes/aes_test.cc index dd3b374..75a5aed 100644 --- a/crypto/fipsmodule/aes/aes_test.cc +++ b/crypto/fipsmodule/aes/aes_test.cc
@@ -89,7 +89,7 @@ ASSERT_EQ(0, AES_set_encrypt_key(key.data(), 8 * key.size(), &aes_key)); // Test with implicit IV. - std::unique_ptr<uint8_t[]> buf(new uint8_t[ciphertext.size()]); + auto buf = std::make_unique<uint8_t[]>(ciphertext.size()); int len = AES_wrap_key(&aes_key, nullptr /* iv */, buf.get(), plaintext.data(), plaintext.size()); ASSERT_GE(len, 0); @@ -106,7 +106,7 @@ ASSERT_EQ(0, AES_set_decrypt_key(key.data(), 8 * key.size(), &aes_key)); // Test with implicit IV. - buf.reset(new uint8_t[plaintext.size()]); + buf = std::make_unique<uint8_t[]>(plaintext.size()); len = AES_unwrap_key(&aes_key, nullptr /* iv */, buf.get(), ciphertext.data(), ciphertext.size()); ASSERT_GE(len, 0); @@ -133,7 +133,7 @@ // Test encryption. AES_KEY aes_key; ASSERT_EQ(0, AES_set_encrypt_key(key.data(), 8 * key.size(), &aes_key)); - std::unique_ptr<uint8_t[]> buf(new uint8_t[plaintext.size() + 15]); + auto buf = std::make_unique<uint8_t[]>(plaintext.size() + 15); size_t len; ASSERT_TRUE(AES_wrap_key_padded(&aes_key, buf.get(), &len, plaintext.size() + 15, plaintext.data(), @@ -142,7 +142,7 @@ // Test decryption ASSERT_EQ(0, AES_set_decrypt_key(key.data(), 8 * key.size(), &aes_key)); - buf.reset(new uint8_t[ciphertext.size() - 8]); + buf = std::make_unique<uint8_t[]>(ciphertext.size() - 8); ASSERT_TRUE(AES_unwrap_key_padded(&aes_key, buf.get(), &len, ciphertext.size() - 8, ciphertext.data(), ciphertext.size()));
diff --git a/crypto/fipsmodule/bn/bn_test.cc b/crypto/fipsmodule/bn/bn_test.cc index 92da5f2..5bf2e13 100644 --- a/crypto/fipsmodule/bn/bn_test.cc +++ b/crypto/fipsmodule/bn/bn_test.cc
@@ -458,8 +458,8 @@ SCOPED_TRACE(num_a); size_t num_r = 2 * num_a; // Use newly-allocated buffers so ASan will catch out-of-bounds writes. - std::unique_ptr<BN_ULONG[]> a_words(new BN_ULONG[num_a]), - r_words(new BN_ULONG[num_r]); + auto a_words = std::make_unique<BN_ULONG[]>(num_a); + auto r_words = std::make_unique<BN_ULONG[]>(num_r); ASSERT_TRUE(bn_copy_words(a_words.get(), num_a, a.get())); bn_mul_small(r_words.get(), num_r, a_words.get(), num_a, a_words.get(), @@ -525,8 +525,9 @@ SCOPED_TRACE(num_b); size_t num_r = num_a + num_b; // Use newly-allocated buffers so ASan will catch out-of-bounds writes. - std::unique_ptr<BN_ULONG[]> a_words(new BN_ULONG[num_a]), - b_words(new BN_ULONG[num_b]), r_words(new BN_ULONG[num_r]); + auto a_words = std::make_unique<BN_ULONG[]>(num_a); + auto b_words = std::make_unique<BN_ULONG[]>(num_b); + auto r_words = std::make_unique<BN_ULONG[]>(num_r); ASSERT_TRUE(bn_copy_words(a_words.get(), num_a, a.get())); ASSERT_TRUE(bn_copy_words(b_words.get(), num_b, b.get())); @@ -672,8 +673,9 @@ #if !defined(BORINGSSL_SHARED_LIBRARY) size_t m_width = static_cast<size_t>(bn_minimal_width(m.get())); if (m_width <= BN_SMALL_MAX_WORDS) { - std::unique_ptr<BN_ULONG[]> a_words(new BN_ULONG[m_width]), - b_words(new BN_ULONG[m_width]), r_words(new BN_ULONG[m_width]); + auto a_words = std::make_unique<BN_ULONG[]>(m_width); + auto b_words = std::make_unique<BN_ULONG[]>(m_width); + auto r_words = std::make_unique<BN_ULONG[]>(m_width); ASSERT_TRUE(bn_copy_words(a_words.get(), m_width, a.get())); ASSERT_TRUE(bn_copy_words(b_words.get(), m_width, b.get())); bn_to_montgomery_small(a_words.get(), a_words.get(), m_width, mont.get()); @@ -691,7 +693,7 @@ // inputs. Test this by running |bn_from_montgomery_small| on the result // of a product. Note |a_words| * |b_words| has an extra factor of R^2, so // we must reduce twice. - std::unique_ptr<BN_ULONG[]> prod_words(new BN_ULONG[m_width * 2]); + auto prod_words = std::make_unique<BN_ULONG[]>(m_width * 2); bn_mul_small(prod_words.get(), m_width * 2, a_words.get(), m_width, b_words.get(), m_width); bn_from_montgomery_small(r_words.get(), m_width, prod_words.get(), @@ -752,8 +754,9 @@ #if !defined(BORINGSSL_SHARED_LIBRARY) size_t m_width = static_cast<size_t>(bn_minimal_width(m.get())); if (m_width <= BN_SMALL_MAX_WORDS) { - std::unique_ptr<BN_ULONG[]> a_words(new BN_ULONG[m_width]), - a_copy_words(new BN_ULONG[m_width]), r_words(new BN_ULONG[m_width]); + auto a_words = std::make_unique<BN_ULONG[]>(m_width); + auto a_copy_words = std::make_unique<BN_ULONG[]>(m_width); + auto r_words = std::make_unique<BN_ULONG[]>(m_width); ASSERT_TRUE(bn_copy_words(a_words.get(), m_width, a.get())); bn_to_montgomery_small(a_words.get(), a_words.get(), m_width, mont.get()); bn_mod_mul_montgomery_small(r_words.get(), a_words.get(), a_words.get(), @@ -815,8 +818,8 @@ bssl::UniquePtr<BN_MONT_CTX> mont( BN_MONT_CTX_new_for_modulus(m.get(), ctx)); ASSERT_TRUE(mont.get()); - std::unique_ptr<BN_ULONG[]> r_words(new BN_ULONG[m_width]), - a_words(new BN_ULONG[m_width]); + auto r_words = std::make_unique<BN_ULONG[]>(m_width); + auto a_words = std::make_unique<BN_ULONG[]>(m_width); ASSERT_TRUE(bn_copy_words(a_words.get(), m_width, a.get())); bn_to_montgomery_small(a_words.get(), a_words.get(), m_width, mont.get()); bn_mod_exp_mont_small(r_words.get(), a_words.get(), m_width, e->d,
diff --git a/crypto/fipsmodule/rand/ctrdrbg_test.cc b/crypto/fipsmodule/rand/ctrdrbg_test.cc index 50f4297..deed19f 100644 --- a/crypto/fipsmodule/rand/ctrdrbg_test.cc +++ b/crypto/fipsmodule/rand/ctrdrbg_test.cc
@@ -76,7 +76,7 @@ CTR_DRBG_STATE drbg; ASSERT_TRUE(CTR_DRBG_init(&drbg, kSeed, nullptr, 0)); - std::unique_ptr<uint8_t[]> buf(new uint8_t[CTR_DRBG_MAX_GENERATE_LENGTH]); + auto buf = std::make_unique<uint8_t[]>(CTR_DRBG_MAX_GENERATE_LENGTH); ASSERT_TRUE(CTR_DRBG_generate(&drbg, buf.get(), CTR_DRBG_MAX_GENERATE_LENGTH, nullptr, 0));
diff --git a/crypto/hmac_extra/hmac_test.cc b/crypto/hmac_extra/hmac_test.cc index e65cd6a..4c0d2a1 100644 --- a/crypto/hmac_extra/hmac_test.cc +++ b/crypto/hmac_extra/hmac_test.cc
@@ -99,7 +99,7 @@ ASSERT_EQ(EVP_MD_size(digest), output.size()); // Test using the one-shot API. - std::unique_ptr<uint8_t[]> mac(new uint8_t[EVP_MD_size(digest)]); + auto mac = std::make_unique<uint8_t[]>(EVP_MD_size(digest)); unsigned mac_len; ASSERT_TRUE(HMAC(digest, key.data(), key.size(), input.data(), input.size(), mac.get(), &mac_len));
diff --git a/crypto/lhash/lhash_test.cc b/crypto/lhash/lhash_test.cc index 6b4bfad..8514fd2 100644 --- a/crypto/lhash/lhash_test.cc +++ b/crypto/lhash/lhash_test.cc
@@ -36,7 +36,7 @@ static std::unique_ptr<char[]> RandString(void) { unsigned len = 1 + (rand() % 3); - std::unique_ptr<char[]> ret(new char[len + 1]); + auto ret = std::make_unique<char[]>(len + 1); for (unsigned i = 0; i < len; i++) { ret[i] = '0' + (rand() & 7);
diff --git a/crypto/test/file_test.cc b/crypto/test/file_test.cc index d7ef951..7362e4b 100644 --- a/crypto/test/file_test.cc +++ b/crypto/test/file_test.cc
@@ -98,7 +98,7 @@ ClearTest(); static const size_t kBufLen = 8192 * 4; - std::unique_ptr<char[]> buf(new char[kBufLen]); + auto buf = std::make_unique<char[]>(kBufLen); bool in_instruction_block = false; is_at_new_instruction_block_ = false; @@ -409,8 +409,7 @@ } int FileTestMain(const FileTest::Options &opts) { - std::unique_ptr<FileLineReader> reader( - new FileLineReader(opts.path)); + auto reader = std::make_unique<FileLineReader>(opts.path); if (!reader->is_open()) { fprintf(stderr, "Could not open file %s: %s.\n", opts.path, strerror(errno));
diff --git a/crypto/test/file_test_gtest.cc b/crypto/test/file_test_gtest.cc index 8ff7a2b..2cb0896 100644 --- a/crypto/test/file_test_gtest.cc +++ b/crypto/test/file_test_gtest.cc
@@ -66,9 +66,8 @@ }; void FileTestGTest(const char *path, std::function<void(FileTest *)> run_test) { - std::unique_ptr<StringLineReader> reader( - new StringLineReader(GetTestData(path))); - FileTest t(std::move(reader), nullptr, false); + FileTest t(std::make_unique<StringLineReader>(GetTestData(path)), nullptr, + false); while (true) { switch (t.ReadNext()) {
diff --git a/crypto/x509/x509_test.cc b/crypto/x509/x509_test.cc index 404ce5b..68d75d5 100644 --- a/crypto/x509/x509_test.cc +++ b/crypto/x509/x509_test.cc
@@ -2335,7 +2335,7 @@ bssl::UniquePtr<uint8_t> data; ASSERT_TRUE(PEMToDER(&data, &data_len, kRootCAPEM)); - std::unique_ptr<uint8_t[]> trailing_data(new uint8_t[data_len + 1]); + auto trailing_data = std::make_unique<uint8_t[]>(data_len + 1); OPENSSL_memcpy(trailing_data.get(), data.get(), data_len); bssl::UniquePtr<CRYPTO_BUFFER> buf_trailing_data( @@ -2438,7 +2438,7 @@ bssl::UniquePtr<uint8_t> data; ASSERT_TRUE(PEMToDER(&data, &data_len, kRootCAPEM)); - std::unique_ptr<uint8_t[]> data_with_trailing_byte(new uint8_t[data_len + 1]); + auto data_with_trailing_byte = std::make_unique<uint8_t[]>(data_len + 1); OPENSSL_memcpy(data_with_trailing_byte.get(), data.get(), data_len); data_with_trailing_byte[data_len] = 0;
diff --git a/decrepit/cfb/cfb_test.cc b/decrepit/cfb/cfb_test.cc index da9681e..67904c2 100644 --- a/decrepit/cfb/cfb_test.cc +++ b/decrepit/cfb/cfb_test.cc
@@ -87,7 +87,7 @@ SCOPED_TRACE(test_num); const size_t input_len = sizeof(test.plaintext); - std::unique_ptr<uint8_t[]> out(new uint8_t[input_len]); + auto out = std::make_unique<uint8_t[]>(input_len); for (size_t stride = 1; stride <= input_len; stride++) { bssl::ScopedEVP_CIPHER_CTX ctx; @@ -134,7 +134,7 @@ nullptr, test.key, test.iv)); } - std::unique_ptr<uint8_t[]> plaintext(new uint8_t[input_len]); + auto plaintext = std::make_unique<uint8_t[]>(input_len); int num_bytes; ASSERT_TRUE(EVP_DecryptUpdate(decrypt_ctx.get(), plaintext.get(), &num_bytes, out.get(), input_len));
diff --git a/decrepit/ripemd/ripemd_test.cc b/decrepit/ripemd/ripemd_test.cc index 6338fec..a52e743 100644 --- a/decrepit/ripemd/ripemd_test.cc +++ b/decrepit/ripemd/ripemd_test.cc
@@ -90,7 +90,7 @@ } static const size_t kLargeBufSize = 1000000; - std::unique_ptr<uint8_t[]> buf(new uint8_t[kLargeBufSize]); + auto buf = std::make_unique<uint8_t[]>(kLargeBufSize); OPENSSL_memset(buf.get(), 'a', kLargeBufSize); uint8_t digest[RIPEMD160_DIGEST_LENGTH]; RIPEMD160(buf.get(), kLargeBufSize, digest);
diff --git a/ssl/ssl_test.cc b/ssl/ssl_test.cc index b791fc3..73963c9 100644 --- a/ssl/ssl_test.cc +++ b/ssl/ssl_test.cc
@@ -3522,7 +3522,7 @@ const uint8_t *ciphertext = ticket + 16 + 16; size_t len = ticket_len - 16 - 16 - SHA256_DIGEST_LENGTH; - std::unique_ptr<uint8_t[]> plaintext(new uint8_t[len]); + auto plaintext = std::make_unique<uint8_t[]>(len); #if defined(BORINGSSL_UNSAFE_FUZZER_MODE) // Fuzzer-mode tickets are unencrypted. @@ -6299,7 +6299,7 @@ SSL_set_connect_state(client_.get()); SSL_set_accept_state(server_.get()); - transport_.reset(new MockQUICTransportPair); + transport_ = std::make_unique<MockQUICTransportPair>(); if (!ex_data_.Set(client_.get(), transport_->client()) || !ex_data_.Set(server_.get(), transport_->server())) { return false;
diff --git a/ssl/test/bssl_shim.cc b/ssl/test/bssl_shim.cc index 73aa5c6..19b838a 100644 --- a/ssl/test/bssl_shim.cc +++ b/ssl/test/bssl_shim.cc
@@ -243,7 +243,7 @@ } while (RetryAsync(ssl, ret)); if (config->peek_then_read && ret > 0) { - std::unique_ptr<uint8_t[]> buf(new uint8_t[static_cast<size_t>(ret)]); + auto buf = std::make_unique<uint8_t[]>(static_cast<size_t>(ret)); // SSL_peek should synchronously return the same data. int ret2 = SSL_peek(ssl, buf.get(), ret); @@ -790,8 +790,8 @@ SSL_CTX *ssl_ctx, const TestConfig *config, const TestConfig *retry_config, bool is_resume, SSL_SESSION *session, SettingsWriter *writer) { - bssl::UniquePtr<SSL> ssl = config->NewSSL( - ssl_ctx, session, std::unique_ptr<TestState>(new TestState)); + bssl::UniquePtr<SSL> ssl = + config->NewSSL(ssl_ctx, session, std::make_unique<TestState>()); if (!ssl) { return false; } @@ -858,8 +858,8 @@ bio = std::move(async_scoped); } if (config->is_quic) { - GetTestState(ssl.get())->quic_transport.reset( - new MockQuicTransport(std::move(bio), ssl.get())); + GetTestState(ssl.get())->quic_transport = + std::make_unique<MockQuicTransport>(std::move(bio), ssl.get()); } else { SSL_set_bio(ssl.get(), bio.get(), bio.get()); bio.release(); // SSL_set_bio takes ownership. @@ -1144,7 +1144,7 @@ // This mode writes a number of different record sizes in an attempt to // trip up the CBC record splitting code. static const size_t kBufLen = 32769; - std::unique_ptr<uint8_t[]> buf(new uint8_t[kBufLen]); + auto buf = std::make_unique<uint8_t[]>(kBufLen); OPENSSL_memset(buf.get(), 0x42, kBufLen); static const size_t kRecordSizes[] = { 0, 1, 255, 256, 257, 16383, 16384, 16385, 32767, 32768, 32769}; @@ -1194,7 +1194,7 @@ if (config->read_size > 0) { read_size = config->read_size; } - std::unique_ptr<uint8_t[]> buf(new uint8_t[read_size]); + auto buf = std::make_unique<uint8_t[]>(read_size); int n = DoRead(ssl, buf.get(), read_size); int err = SSL_get_error(ssl, n);
diff --git a/ssl/test/handshaker.cc b/ssl/test/handshaker.cc index 72aaaa8..acdfe72 100644 --- a/ssl/test/handshaker.cc +++ b/ssl/test/handshaker.cc
@@ -153,9 +153,8 @@ return false; } - UniquePtr<SSL> ssl = - config->NewSSL(ctx.get(), /*session=*/nullptr, - std::unique_ptr<TestState>(new TestState)); + UniquePtr<SSL> ssl = config->NewSSL(ctx.get(), /*session=*/nullptr, + std::make_unique<TestState>()); if (!ssl) { fprintf(stderr, "Error creating SSL object in handshaker.\n"); ERR_print_errors_fp(stderr);
diff --git a/ssl/test/test_config.cc b/ssl/test/test_config.cc index baff66b..7a188f6 100644 --- a/ssl/test/test_config.cc +++ b/ssl/test/test_config.cc
@@ -139,7 +139,7 @@ bool skip_handshaker = false) { return Flag{name, true, skip_handshaker, [=](TestConfig *config, const char *param) -> bool { - (config->*field).reset(new std::string(param)); + (config->*field) = std::make_unique<std::string>(param); return true; }}; } @@ -972,7 +972,7 @@ return false; } - std::unique_ptr<uint8_t[]> buf(new uint8_t[in.size() / 2]); + auto buf = std::make_unique<uint8_t[]>(in.size() / 2); for (size_t i = 0; i < in.size() / 2; i++) { uint8_t high, low; if (!OPENSSL_fromxdigit(&high, in[i * 2]) || @@ -1584,7 +1584,7 @@ if (uncompressed_len != 2 + in_len) { return 0; } - std::unique_ptr<uint8_t[]> buf(new uint8_t[2 + in_len]); + auto buf = std::make_unique<uint8_t[]>(2 + in_len); buf[0] = 0; buf[1] = 0; OPENSSL_memcpy(&buf[2], in, in_len);
diff --git a/tool/digest.cc b/tool/digest.cc index d810928..e66f013 100644 --- a/tool/digest.cc +++ b/tool/digest.cc
@@ -115,7 +115,7 @@ } static const size_t kBufSize = 8192; - std::unique_ptr<uint8_t[]> buf(new uint8_t[kBufSize]); + auto buf = std::make_unique<uint8_t[]>(kBufSize); bssl::ScopedEVP_MD_CTX ctx; if (!EVP_DigestInit_ex(ctx.get(), md, NULL)) {
diff --git a/tool/pkcs12.cc b/tool/pkcs12.cc index 3d8a1cd..c19fd3a 100644 --- a/tool/pkcs12.cc +++ b/tool/pkcs12.cc
@@ -72,7 +72,7 @@ } const size_t size = st.st_size; - std::unique_ptr<uint8_t[]> contents(new uint8_t[size]); + auto contents = std::make_unique<uint8_t[]>(size); size_t off = 0; while (off < size) { size_t bytes_read;
diff --git a/tool/sign.cc b/tool/sign.cc index a511e8d..038d853 100644 --- a/tool/sign.cc +++ b/tool/sign.cc
@@ -68,7 +68,7 @@ } size_t sig_len = EVP_PKEY_size(key.get()); - std::unique_ptr<uint8_t[]> sig(new uint8_t[sig_len]); + auto sig = std::make_unique<uint8_t[]>(sig_len); if (!EVP_DigestSign(ctx.get(), sig.get(), &sig_len, data.data(), data.size())) { return false;
diff --git a/tool/speed.cc b/tool/speed.cc index 8b4b13c..089a460 100644 --- a/tool/speed.cc +++ b/tool/speed.cc
@@ -476,22 +476,21 @@ const size_t nonce_len = EVP_AEAD_nonce_length(aead); const size_t overhead_len = EVP_AEAD_max_overhead(aead); - std::unique_ptr<uint8_t[]> key(new uint8_t[key_len]); + auto key = std::make_unique<uint8_t[]>(key_len); OPENSSL_memset(key.get(), 0, key_len); - std::unique_ptr<uint8_t[]> nonce(new uint8_t[nonce_len]); + auto nonce = std::make_unique<uint8_t[]>(nonce_len); OPENSSL_memset(nonce.get(), 0, nonce_len); - std::unique_ptr<uint8_t[]> in_storage(new uint8_t[chunk_len + kAlignment]); + auto in_storage = std::make_unique<uint8_t[]>(chunk_len + kAlignment); // N.B. for EVP_AEAD_CTX_seal_scatter the input and output buffers may be the // same size. However, in the direction == evp_aead_open case we still use // non-scattering seal, hence we add overhead_len to the size of this buffer. - std::unique_ptr<uint8_t[]> out_storage( - new uint8_t[chunk_len + overhead_len + kAlignment]); - std::unique_ptr<uint8_t[]> in2_storage( - new uint8_t[chunk_len + overhead_len + kAlignment]); - std::unique_ptr<uint8_t[]> ad(new uint8_t[ad_len]); + auto out_storage = + std::make_unique<uint8_t[]>(chunk_len + overhead_len + kAlignment); + auto in2_storage = + std::make_unique<uint8_t[]>(chunk_len + overhead_len + kAlignment); + auto ad = std::make_unique<uint8_t[]>(ad_len); OPENSSL_memset(ad.get(), 0, ad_len); - std::unique_ptr<uint8_t[]> tag_storage( - new uint8_t[overhead_len + kAlignment]); + auto tag_storage = std::make_unique<uint8_t[]>(overhead_len + kAlignment); uint8_t *const in = @@ -760,7 +759,7 @@ if (peer_value_len == 0) { return false; } - std::unique_ptr<uint8_t[]> peer_value(new uint8_t[peer_value_len]); + auto peer_value = std::make_unique<uint8_t[]>(peer_value_len); peer_value_len = EC_POINT_point2oct( EC_KEY_get0_group(peer_key.get()), EC_KEY_get0_public_key(peer_key.get()), POINT_CONVERSION_UNCOMPRESSED, peer_value.get(), peer_value_len, nullptr);
diff --git a/util/fipstools/acvp/modulewrapper/modulewrapper.cc b/util/fipstools/acvp/modulewrapper/modulewrapper.cc index 0c1359e..5274598 100644 --- a/util/fipstools/acvp/modulewrapper/modulewrapper.cc +++ b/util/fipstools/acvp/modulewrapper/modulewrapper.cc
@@ -75,7 +75,7 @@ // static std::unique_ptr<RequestBuffer> RequestBuffer::New() { - return std::unique_ptr<RequestBuffer>(new RequestBufferImpl); + return std::make_unique<RequestBufferImpl>(); } static bool ReadAll(int fd, void *in_data, size_t data_len) {