Snap for 8403122 from 619b6c1bb1f8573ca56de50cfc6ba23d355670db to emu-31-release
Change-Id: I399f2599335239b88e58120be936aad394f5a066
diff --git a/cc/BUILD.bazel b/cc/BUILD.bazel
index cd95f08..496cec6 100644
--- a/cc/BUILD.bazel
+++ b/cc/BUILD.bazel
@@ -482,6 +482,7 @@
srcs = ["core/version.cc"],
hdrs = [":version_h"],
include_prefix = "tink",
+ visibility = ["//visibility:public"],
)
cc_library(
diff --git a/cc/aead/aead_factory_test.cc b/cc/aead/aead_factory_test.cc
index edb0219..e03942e 100644
--- a/cc/aead/aead_factory_test.cc
+++ b/cc/aead/aead_factory_test.cc
@@ -67,17 +67,17 @@
// Prepare a Keyset.
Keyset keyset;
uint32_t key_id_1 = 1234543;
- AesGcmKey new_key = AesGcmKeyManager().CreateKey(key_format).ValueOrDie();
+ AesGcmKey new_key = AesGcmKeyManager().CreateKey(key_format).value();
AddTinkKey(key_type, key_id_1, new_key, KeyStatusType::ENABLED,
KeyData::SYMMETRIC, &keyset);
uint32_t key_id_2 = 726329;
- new_key = AesGcmKeyManager().CreateKey(key_format).ValueOrDie();
+ new_key = AesGcmKeyManager().CreateKey(key_format).value();
AddRawKey(key_type, key_id_2, new_key, KeyStatusType::ENABLED,
KeyData::SYMMETRIC, &keyset);
uint32_t key_id_3 = 7213743;
- new_key = AesGcmKeyManager().CreateKey(key_format).ValueOrDie();
+ new_key = AesGcmKeyManager().CreateKey(key_format).value();
AddTinkKey(key_type, key_id_3, new_key, KeyStatusType::ENABLED,
KeyData::SYMMETRIC, &keyset);
@@ -90,7 +90,7 @@
auto aead_result =
AeadFactory::GetPrimitive(*TestKeysetHandle::GetKeysetHandle(keyset));
EXPECT_TRUE(aead_result.ok()) << aead_result.status();
- auto aead = std::move(aead_result.ValueOrDie());
+ auto aead = std::move(aead_result.value());
// Test the resulting Aead-instance.
std::string plaintext = "some_plaintext";
@@ -98,14 +98,14 @@
auto encrypt_result = aead->Encrypt(plaintext, aad);
EXPECT_TRUE(encrypt_result.ok()) << encrypt_result.status();
- std::string ciphertext = encrypt_result.ValueOrDie();
+ std::string ciphertext = encrypt_result.value();
std::string prefix =
- CryptoFormat::GetOutputPrefix(KeyInfoFromKey(keyset.key(2))).ValueOrDie();
+ CryptoFormat::GetOutputPrefix(KeyInfoFromKey(keyset.key(2))).value();
EXPECT_PRED_FORMAT2(testing::IsSubstring, prefix, ciphertext);
auto decrypt_result = aead->Decrypt(ciphertext, aad);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
decrypt_result = aead->Decrypt("some bad ciphertext", aad);
EXPECT_FALSE(decrypt_result.ok());
@@ -118,11 +118,11 @@
AesGcmKey raw_key;
EXPECT_TRUE(raw_key.ParseFromString(keyset.key(1).key_data().value()));
auto raw_aead =
- std::move(AesGcmKeyManager().GetPrimitive<Aead>(raw_key).ValueOrDie());
- std::string raw_ciphertext = raw_aead->Encrypt(plaintext, aad).ValueOrDie();
+ std::move(AesGcmKeyManager().GetPrimitive<Aead>(raw_key).value());
+ std::string raw_ciphertext = raw_aead->Encrypt(plaintext, aad).value();
decrypt_result = aead->Decrypt(ciphertext, aad);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
}
} // namespace
diff --git a/cc/aead/aead_key_templates_test.cc b/cc/aead/aead_key_templates_test.cc
index a2894df..83a2046 100644
--- a/cc/aead/aead_key_templates_test.cc
+++ b/cc/aead/aead_key_templates_test.cc
@@ -395,7 +395,7 @@
auto kek_uri_result = test::FakeKmsClient::CreateFakeKeyUri();
EXPECT_TRUE(kek_uri_result.ok()) << kek_uri_result.status();
- std::string kek_uri = kek_uri_result.ValueOrDie();
+ std::string kek_uri = kek_uri_result.value();
auto register_fake_kms_client_status = test::FakeKmsClient::RegisterNewClient(
kek_uri, /* credentials_path= */ "");
@@ -407,19 +407,19 @@
AeadKeyTemplates::KmsEnvelopeAead(kek_uri, dek_template);
auto handle_result1 = KeysetHandle::GenerateNew(key_template1);
EXPECT_TRUE(handle_result1.ok());
- auto handle1 = std::move(handle_result1.ValueOrDie());
+ auto handle1 = std::move(handle_result1.value());
auto aead_result1 = handle1->GetPrimitive<Aead>();
EXPECT_TRUE(aead_result1.ok());
- auto aead1 = std::move(aead_result1.ValueOrDie());
+ auto aead1 = std::move(aead_result1.value());
const KeyTemplate& key_template2 =
AeadKeyTemplates::KmsEnvelopeAead(kek_uri, dek_template);
auto handle_result2 = KeysetHandle::GenerateNew(key_template2);
EXPECT_TRUE(handle_result2.ok());
- auto handle2 = std::move(handle_result2.ValueOrDie());
+ auto handle2 = std::move(handle_result2.value());
auto aead_result2 = handle2->GetPrimitive<Aead>();
EXPECT_TRUE(aead_result2.ok());
- auto aead2 = std::move(aead_result2.ValueOrDie());
+ auto aead2 = std::move(aead_result2.value());
EXPECT_THAT(EncryptThenDecrypt(*aead1, *aead2, "message", "aad"), IsOk());
}
diff --git a/cc/aead/aes_ctr_hmac_aead_key_manager.cc b/cc/aead/aes_ctr_hmac_aead_key_manager.cc
index 0aa10e3..8197e9c 100644
--- a/cc/aead/aes_ctr_hmac_aead_key_manager.cc
+++ b/cc/aead/aes_ctr_hmac_aead_key_manager.cc
@@ -77,7 +77,7 @@
if (!hmac_key_or.status().ok()) {
return hmac_key_or.status();
}
- *aes_ctr_hmac_aead_key.mutable_hmac_key() = hmac_key_or.ValueOrDie();
+ *aes_ctr_hmac_aead_key.mutable_hmac_key() = hmac_key_or.value();
return aes_ctr_hmac_aead_key;
}
@@ -93,12 +93,12 @@
if (!hmac_result.ok()) return hmac_result.status();
auto cipher_res = subtle::EncryptThenAuthenticate::New(
- std::move(aes_ctr_result.ValueOrDie()),
- std::move(hmac_result.ValueOrDie()), key.hmac_key().params().tag_size());
+ std::move(aes_ctr_result.value()), std::move(hmac_result.value()),
+ key.hmac_key().params().tag_size());
if (!cipher_res.ok()) {
return cipher_res.status();
}
- return std::move(cipher_res.ValueOrDie());
+ return std::move(cipher_res.value());
}
Status AesCtrHmacAeadKeyManager::ValidateKey(
diff --git a/cc/aead/aes_ctr_hmac_aead_key_manager_test.cc b/cc/aead/aes_ctr_hmac_aead_key_manager_test.cc
index d7853c8..ecda282 100644
--- a/cc/aead/aes_ctr_hmac_aead_key_manager_test.cc
+++ b/cc/aead/aes_ctr_hmac_aead_key_manager_test.cc
@@ -173,7 +173,7 @@
StatusOr<AesCtrHmacAeadKey> key_or =
AesCtrHmacAeadKeyManager().CreateKey(key_format);
ASSERT_THAT(key_or.status(), IsOk());
- const AesCtrHmacAeadKey& key = key_or.ValueOrDie();
+ const AesCtrHmacAeadKey& key = key_or.value();
EXPECT_THAT(AesCtrHmacAeadKeyManager().ValidateKey(key),
IsOk());
EXPECT_THAT(key.aes_ctr_key().params().iv_size(),
@@ -207,13 +207,11 @@
ASSERT_THAT(direct_hmac_or.status(), IsOk());
auto direct_aead_or = subtle::EncryptThenAuthenticate::New(
- std::move(direct_aes_ctr_or.ValueOrDie()),
- std::move(direct_hmac_or.ValueOrDie()),
+ std::move(direct_aes_ctr_or.value()), std::move(direct_hmac_or.value()),
key.hmac_key().params().tag_size());
ASSERT_THAT(direct_aead_or.status(), IsOk());
- EXPECT_THAT(EncryptThenDecrypt(*aead_or.ValueOrDie(),
- *direct_aead_or.ValueOrDie(),
+ EXPECT_THAT(EncryptThenDecrypt(*aead_or.value(), *direct_aead_or.value(),
"message", "aad"),
IsOk());
}
diff --git a/cc/aead/aes_eax_key_manager_test.cc b/cc/aead/aes_eax_key_manager_test.cc
index 14a06cd..33a8608 100644
--- a/cc/aead/aes_eax_key_manager_test.cc
+++ b/cc/aead/aes_eax_key_manager_test.cc
@@ -104,9 +104,8 @@
format.mutable_params()->set_iv_size(16);
auto key_or = AesEaxKeyManager().CreateKey(format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(), SizeIs(format.key_size()));
- EXPECT_THAT(key_or.ValueOrDie().params().iv_size(),
- Eq(format.params().iv_size()));
+ EXPECT_THAT(key_or.value().key_value(), SizeIs(format.key_size()));
+ EXPECT_THAT(key_or.value().params().iv_size(), Eq(format.params().iv_size()));
}
TEST(AesEaxKeyManagerTest, CreateKeyIsValid) {
@@ -115,7 +114,7 @@
format.mutable_params()->set_iv_size(16);
auto key_or = AesEaxKeyManager().CreateKey(format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(AesEaxKeyManager().ValidateKey(key_or.ValueOrDie()), IsOk());
+ EXPECT_THAT(AesEaxKeyManager().ValidateKey(key_or.value()), IsOk());
}
TEST(AesEaxKeyManagerTest, MultipleCreateCallsCreateDifferentKeys) {
@@ -127,8 +126,7 @@
ASSERT_THAT(key1_or.status(), IsOk());
auto key2_or = manager.CreateKey(format);
ASSERT_THAT(key2_or.status(), IsOk());
- EXPECT_THAT(key1_or.ValueOrDie().key_value(),
- Ne(key2_or.ValueOrDie().key_value()));
+ EXPECT_THAT(key1_or.value().key_value(), Ne(key2_or.value().key_value()));
}
TEST(AesEaxKeyManagerTest, ValidKey) {
@@ -178,18 +176,17 @@
ASSERT_THAT(key_or.status(), IsOk());
StatusOr<std::unique_ptr<Aead>> aead_or =
- AesEaxKeyManager().GetPrimitive<Aead>(key_or.ValueOrDie());
+ AesEaxKeyManager().GetPrimitive<Aead>(key_or.value());
ASSERT_THAT(aead_or.status(), IsOk());
StatusOr<std::unique_ptr<Aead>> boring_ssl_aead_or =
subtle::AesEaxBoringSsl::New(
- util::SecretDataFromStringView(key_or.ValueOrDie().key_value()),
- key_or.ValueOrDie().params().iv_size());
+ util::SecretDataFromStringView(key_or.value().key_value()),
+ key_or.value().params().iv_size());
ASSERT_THAT(boring_ssl_aead_or.status(), IsOk());
- ASSERT_THAT(EncryptThenDecrypt(*aead_or.ValueOrDie(),
- *boring_ssl_aead_or.ValueOrDie(),
+ ASSERT_THAT(EncryptThenDecrypt(*aead_or.value(), *boring_ssl_aead_or.value(),
"message", "aad"),
IsOk());
}
diff --git a/cc/aead/aes_gcm_key_manager.h b/cc/aead/aes_gcm_key_manager.h
index b8f1dd7..bb2a65e 100644
--- a/cc/aead/aes_gcm_key_manager.h
+++ b/cc/aead/aes_gcm_key_manager.h
@@ -55,7 +55,7 @@
auto aes_gcm_result = subtle::AesGcmBoringSsl::New(
util::SecretDataFromStringView(key.key_value()));
if (!aes_gcm_result.ok()) return aes_gcm_result.status();
- return {std::move(aes_gcm_result.ValueOrDie())};
+ return {std::move(aes_gcm_result.value())};
}
};
class CordAeadFactory : public PrimitiveFactory<CordAead> {
@@ -65,7 +65,7 @@
crypto::tink::internal::CordAesGcmBoringSsl::New(
util::SecretDataFromStringView(key.key_value()));
if (!cord_aes_gcm_result.ok()) return cord_aes_gcm_result.status();
- return {std::move(cord_aes_gcm_result.ValueOrDie())};
+ return {std::move(cord_aes_gcm_result.value())};
}
};
@@ -125,7 +125,7 @@
}
google::crypto::tink::AesGcmKey key;
key.set_version(get_version());
- key.set_key_value(randomness.ValueOrDie());
+ key.set_key_value(randomness.value());
return key;
}
diff --git a/cc/aead/aes_gcm_key_manager_test.cc b/cc/aead/aes_gcm_key_manager_test.cc
index fd8945f..525e1a4 100644
--- a/cc/aead/aes_gcm_key_manager_test.cc
+++ b/cc/aead/aes_gcm_key_manager_test.cc
@@ -155,7 +155,7 @@
StatusOr<AesGcmKey> key_or = AesGcmKeyManager().CreateKey(format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value().size(), Eq(format.key_size()));
+ EXPECT_THAT(key_or.value().key_value().size(), Eq(format.key_size()));
}
TEST(AesGcmKeyManagerTest, Create32ByteKey) {
@@ -165,7 +165,7 @@
StatusOr<AesGcmKey> key_or = AesGcmKeyManager().CreateKey(format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value().size(), Eq(format.key_size()));
+ EXPECT_THAT(key_or.value().key_value().size(), Eq(format.key_size()));
}
TEST(AesGcmKeyManagerTest, CreateAead) {
@@ -175,19 +175,18 @@
ASSERT_THAT(key_or.status(), IsOk());
StatusOr<std::unique_ptr<Aead>> aead_or =
- AesGcmKeyManager().GetPrimitive<Aead>(key_or.ValueOrDie());
+ AesGcmKeyManager().GetPrimitive<Aead>(key_or.value());
ASSERT_THAT(aead_or.status(), IsOk());
StatusOr<std::unique_ptr<Aead>> boring_ssl_aead_or =
subtle::AesGcmBoringSsl::New(
- util::SecretDataFromStringView(key_or.ValueOrDie().key_value()));
+ util::SecretDataFromStringView(key_or.value().key_value()));
ASSERT_THAT(boring_ssl_aead_or.status(), IsOk());
- ASSERT_THAT(
- EncryptThenDecrypt(*aead_or.ValueOrDie(),
- *boring_ssl_aead_or.ValueOrDie(), "message", "aad"),
- IsOk());
+ ASSERT_THAT(EncryptThenDecrypt(*aead_or.value(), *boring_ssl_aead_or.value(),
+ "message", "aad"),
+ IsOk());
}
TEST(AesGcmKeyManagerTest, CreateCordAead) {
@@ -197,19 +196,18 @@
ASSERT_THAT(key_or.status(), IsOk());
StatusOr<std::unique_ptr<CordAead>> aead_or =
- AesGcmKeyManager().GetPrimitive<CordAead>(key_or.ValueOrDie());
+ AesGcmKeyManager().GetPrimitive<CordAead>(key_or.value());
ASSERT_THAT(aead_or.status(), IsOk());
StatusOr<std::unique_ptr<CordAead>> boring_ssl_aead_or =
CordAesGcmBoringSsl::New(
- util::SecretDataFromStringView(key_or.ValueOrDie().key_value()));
+ util::SecretDataFromStringView(key_or.value().key_value()));
ASSERT_THAT(boring_ssl_aead_or.status(), IsOk());
- ASSERT_THAT(
- EncryptThenDecrypt(*aead_or.ValueOrDie(),
- *boring_ssl_aead_or.ValueOrDie(), "message", "aad"),
- IsOk());
+ ASSERT_THAT(EncryptThenDecrypt(*aead_or.value(), *boring_ssl_aead_or.value(),
+ "message", "aad"),
+ IsOk());
}
TEST(AesGcmKeyManagerTest, DeriveShortKey) {
@@ -223,7 +221,7 @@
StatusOr<AesGcmKey> key_or =
AesGcmKeyManager().DeriveKey(format, &input_stream);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(), Eq("0123456789abcdef"));
+ EXPECT_THAT(key_or.value().key_value(), Eq("0123456789abcdef"));
}
TEST(AesGcmKeyManagerTest, DeriveLongKey) {
@@ -237,7 +235,7 @@
StatusOr<AesGcmKey> key_or =
AesGcmKeyManager().DeriveKey(format, &input_stream);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(),
+ EXPECT_THAT(key_or.value().key_value(),
Eq("0123456789abcdef0123456789abcdef"));
}
diff --git a/cc/aead/aes_gcm_siv_key_manager_test.cc b/cc/aead/aes_gcm_siv_key_manager_test.cc
index 1e39327..0a3eea5 100644
--- a/cc/aead/aes_gcm_siv_key_manager_test.cc
+++ b/cc/aead/aes_gcm_siv_key_manager_test.cc
@@ -143,7 +143,7 @@
StatusOr<AesGcmSivKey> key_or = AesGcmSivKeyManager().CreateKey(format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value().size(), Eq(format.key_size()));
+ EXPECT_THAT(key_or.value().key_value().size(), Eq(format.key_size()));
}
TEST(AesGcmSivKeyManagerTest, Create32ByteKey) {
@@ -153,7 +153,7 @@
StatusOr<AesGcmSivKey> key_or = AesGcmSivKeyManager().CreateKey(format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value().size(), Eq(format.key_size()));
+ EXPECT_THAT(key_or.value().key_value().size(), Eq(format.key_size()));
}
TEST(AesGcmSivKeyManagerTest, CreateAeadFailsWithOpenSsl) {
diff --git a/cc/aead/cord_aead_wrapper.cc b/cc/aead/cord_aead_wrapper.cc
index 64247b6..9ff00d4 100644
--- a/cc/aead/cord_aead_wrapper.cc
+++ b/cc/aead/cord_aead_wrapper.cc
@@ -68,7 +68,7 @@
if (!encrypt_result.ok()) return encrypt_result.status();
absl::Cord result;
result.Append(aead_set_->get_primary()->get_identifier());
- result.Append(encrypt_result.ValueOrDie());
+ result.Append(encrypt_result.value());
return result;
}
@@ -81,11 +81,11 @@
if (primitives_result.ok()) {
auto raw_ciphertext =
ciphertext.Subcord(key_id.size(), ciphertext.size());
- for (auto& aead_entry : *(primitives_result.ValueOrDie())) {
+ for (auto& aead_entry : *(primitives_result.value())) {
CordAead& aead = aead_entry->get_primitive();
auto decrypt_result = aead.Decrypt(raw_ciphertext, associated_data);
if (decrypt_result.ok()) {
- return std::move(decrypt_result.ValueOrDie());
+ return std::move(decrypt_result.value());
} else {
// LOG that a matching key didn't decrypt the ciphertext.
}
@@ -96,11 +96,11 @@
// No matching key succeeded with decryption, try all RAW keys.
auto raw_primitives_result = aead_set_->get_raw_primitives();
if (raw_primitives_result.ok()) {
- for (auto& aead_entry : *(raw_primitives_result.ValueOrDie())) {
+ for (auto& aead_entry : *(raw_primitives_result.value())) {
CordAead& aead = aead_entry->get_primitive();
auto decrypt_result = aead.Decrypt(ciphertext, associated_data);
if (decrypt_result.ok()) {
- return std::move(decrypt_result.ValueOrDie());
+ return std::move(decrypt_result.value());
}
}
}
diff --git a/cc/aead/cord_aead_wrapper_test.cc b/cc/aead/cord_aead_wrapper_test.cc
index 01d0fe1..59540a9 100644
--- a/cc/aead/cord_aead_wrapper_test.cc
+++ b/cc/aead/cord_aead_wrapper_test.cc
@@ -76,7 +76,7 @@
absl::make_unique<DummyCordAead>(aead_name_0);
auto entry_result =
aead_set->AddPrimitive(std::move(aead), keyset_info.key_info(0));
- auto aead_set_result = aead_set->set_primary(entry_result.ValueOrDie());
+ auto aead_set_result = aead_set->set_primary(entry_result.value());
return aead_set;
}
@@ -86,7 +86,7 @@
CordAeadWrapper wrapper;
auto aead_result = wrapper.Wrap(std::move(aead_set));
ASSERT_THAT(aead_result.status(), IsOk());
- auto aead = std::move(aead_result.ValueOrDie());
+ auto aead = std::move(aead_result.value());
absl::Cord plaintext;
plaintext.Append("some_plaintext");
absl::Cord aad;
@@ -94,11 +94,11 @@
auto encrypt_result = aead->Encrypt(plaintext, aad);
EXPECT_TRUE(encrypt_result.ok()) << encrypt_result.status();
- absl::Cord ciphertext = encrypt_result.ValueOrDie();
+ absl::Cord ciphertext = encrypt_result.value();
auto decrypt_result = aead->Decrypt(ciphertext, aad);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
}
TEST(AeadSetWrapperTest, WrapperEncryptDecryptMultipleKeys) {
@@ -115,7 +115,7 @@
EXPECT_TRUE(encrypt_result.ok()) << encrypt_result.status();
absl::Cord ciphertext;
ciphertext.Append(aead_set->get_primary()->get_identifier());
- ciphertext.Append(encrypt_result.ValueOrDie());
+ ciphertext.Append(encrypt_result.value());
// Add a second key
KeysetInfo::KeyInfo* key_info;
@@ -135,13 +135,13 @@
CordAeadWrapper wrapper;
auto aead_result = wrapper.Wrap(std::move(aead_set));
ASSERT_THAT(aead_result.status(), IsOk());
- aead = std::move(aead_result.ValueOrDie());
+ aead = std::move(aead_result.value());
// Encrypt with the wrapped AEAD and check if result was equal to the
// encryption with the primary key.
auto encrypt_wrap_result = aead->Encrypt(plaintext, aad);
EXPECT_TRUE(encrypt_wrap_result.ok()) << encrypt_wrap_result.status();
- EXPECT_EQ(ciphertext, encrypt_wrap_result.ValueOrDie());
+ EXPECT_EQ(ciphertext, encrypt_wrap_result.value());
}
TEST(AeadSetWrapperTest, WrapperEncryptDecryptManyChunks) {
@@ -150,7 +150,7 @@
CordAeadWrapper wrapper;
auto aead_result = wrapper.Wrap(std::move(aead_set));
ASSERT_THAT(aead_result.status(), IsOk());
- auto aead = std::move(aead_result.ValueOrDie());
+ auto aead = std::move(aead_result.value());
std::string plaintext = "";
for (int i = 0; i < 1000; i++) {
@@ -163,11 +163,11 @@
auto encrypt_result = aead->Encrypt(plaintext_cord, aad);
EXPECT_TRUE(encrypt_result.ok()) << encrypt_result.status();
- absl::Cord ciphertext = encrypt_result.ValueOrDie();
+ absl::Cord ciphertext = encrypt_result.value();
auto decrypt_result = aead->Decrypt(ciphertext, aad);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
}
TEST(AeadSetWrapperTest, WrapperEncryptBadDecrypt) {
@@ -176,7 +176,7 @@
CordAeadWrapper wrapper;
auto aead_result = wrapper.Wrap(std::move(aead_set));
ASSERT_THAT(aead_result.status(), IsOk());
- auto aead = std::move(aead_result.ValueOrDie());
+ auto aead = std::move(aead_result.value());
absl::Cord plaintext;
plaintext.Append("some_plaintext");
absl::Cord aad;
diff --git a/cc/aead/internal/cord_aes_gcm_boringssl.cc b/cc/aead/internal/cord_aes_gcm_boringssl.cc
index 4a15d4a..429b5d1 100644
--- a/cc/aead/internal/cord_aes_gcm_boringssl.cc
+++ b/cc/aead/internal/cord_aes_gcm_boringssl.cc
@@ -89,7 +89,7 @@
std::unique_ptr<CordAead> aead =
absl::WrapUnique(new CordAesGcmBoringSsl(std::move(context)));
- return aead;
+ return std::move(aead);
}
util::StatusOr<absl::Cord> CordAesGcmBoringSsl::Encrypt(
diff --git a/cc/aead/internal/cord_aes_gcm_boringssl_test.cc b/cc/aead/internal/cord_aes_gcm_boringssl_test.cc
index 02f9c95..41f4176 100644
--- a/cc/aead/internal/cord_aes_gcm_boringssl_test.cc
+++ b/cc/aead/internal/cord_aes_gcm_boringssl_test.cc
@@ -118,7 +118,7 @@
subtle::AesGcmBoringSsl::New(key_);
ASSERT_THAT(string_aead.status(), IsOk());
util::StatusOr<std::string> plaintext =
- (*string_aead)->Decrypt(ct.ValueOrDie().Flatten(), aad_cord.Flatten());
+ (*string_aead)->Decrypt(ct.value().Flatten(), aad_cord.Flatten());
ASSERT_THAT(plaintext.status(), IsOk());
EXPECT_EQ(*plaintext, kMessage);
}
@@ -128,7 +128,7 @@
absl::Cord aad = absl::Cord(kAad);
util::StatusOr<absl::Cord> ct = cipher_->Encrypt(message, aad);
ASSERT_THAT(ct.status(), IsOk());
- util::StatusOr<std::string> plaintext = cipher_->Decrypt(*ct, aad);
+ util::StatusOr<absl::Cord> plaintext = cipher_->Decrypt(*ct, aad);
ASSERT_THAT(plaintext.status(), IsOk());
EXPECT_EQ(*plaintext, message);
diff --git a/cc/aead/kms_aead_key_manager.h b/cc/aead/kms_aead_key_manager.h
index 0e66757..507b0ba 100644
--- a/cc/aead/kms_aead_key_manager.h
+++ b/cc/aead/kms_aead_key_manager.h
@@ -44,7 +44,7 @@
const auto& key_uri = kms_aead_key.params().key_uri();
auto kms_client_result = KmsClients::Get(key_uri);
if (!kms_client_result.ok()) return kms_client_result.status();
- return kms_client_result.ValueOrDie()->GetAead(key_uri);
+ return kms_client_result.value()->GetAead(key_uri);
}
};
diff --git a/cc/aead/kms_aead_key_manager_test.cc b/cc/aead/kms_aead_key_manager_test.cc
index 2117d00..e16cbee 100644
--- a/cc/aead/kms_aead_key_manager_test.cc
+++ b/cc/aead/kms_aead_key_manager_test.cc
@@ -100,7 +100,7 @@
key_format.set_key_uri("Some uri");
auto key_or = KmsAeadKeyManager().CreateKey(key_format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().params().key_uri(), Eq(key_format.key_uri()));
+ EXPECT_THAT(key_or.value().params().key_uri(), Eq(key_format.key_uri()));
}
class KmsAeadKeyManagerCreateTest : public ::testing::Test {
@@ -128,9 +128,9 @@
DummyAead direct_aead("prefix1:some_key1");
- EXPECT_THAT(EncryptThenDecrypt(*kms_aead.ValueOrDie(), direct_aead,
- "plaintext", "aad"),
- IsOk());
+ EXPECT_THAT(
+ EncryptThenDecrypt(*kms_aead.value(), direct_aead, "plaintext", "aad"),
+ IsOk());
}
TEST_F(KmsAeadKeyManagerCreateTest, CreateAeadWrongKeyName) {
@@ -161,9 +161,9 @@
DummyAead direct_aead("prefix2:some_key2");
- EXPECT_THAT(EncryptThenDecrypt(*kms_aead.ValueOrDie(), direct_aead,
- "plaintext", "aad"),
- IsOk());
+ EXPECT_THAT(
+ EncryptThenDecrypt(*kms_aead.value(), direct_aead, "plaintext", "aad"),
+ IsOk());
}
} // namespace
diff --git a/cc/aead/kms_envelope_aead.cc b/cc/aead/kms_envelope_aead.cc
index 904ac08..e1dad46 100644
--- a/cc/aead/kms_envelope_aead.cc
+++ b/cc/aead/kms_envelope_aead.cc
@@ -75,7 +75,7 @@
// Generate DEK.
auto dek_result = Registry::NewKeyData(dek_template_);
if (!dek_result.ok()) return dek_result.status();
- auto dek = std::move(dek_result.ValueOrDie());
+ auto dek = std::move(dek_result.value());
// Wrap DEK key values with remote.
auto dek_encrypt_result =
@@ -85,13 +85,13 @@
// Encrypt plaintext using DEK.
auto aead_result = Registry::GetPrimitive<Aead>(*dek);
if (!aead_result.ok()) return aead_result.status();
- auto aead = std::move(aead_result.ValueOrDie());
+ auto aead = std::move(aead_result.value());
auto encrypt_result = aead->Encrypt(plaintext, associated_data);
if (!encrypt_result.ok()) return encrypt_result.status();
// Build and return ciphertext.
- return GetEnvelopeCiphertext(dek_encrypt_result.ValueOrDie(),
- encrypt_result.ValueOrDie());
+ return GetEnvelopeCiphertext(dek_encrypt_result.value(),
+ encrypt_result.value());
}
util::StatusOr<std::string> KmsEnvelopeAead::Decrypt(
@@ -121,13 +121,13 @@
// Create AEAD from DEK.
google::crypto::tink::KeyData dek;
dek.set_type_url(dek_template_.type_url());
- dek.set_value(dek_decrypt_result.ValueOrDie());
+ dek.set_value(dek_decrypt_result.value());
dek.set_key_material_type(google::crypto::tink::KeyData::SYMMETRIC);
// Encrypt plaintext using DEK.
auto aead_result = Registry::GetPrimitive<Aead>(dek);
if (!aead_result.ok()) return aead_result.status();
- auto aead = std::move(aead_result.ValueOrDie());
+ auto aead = std::move(aead_result.value());
return aead->Decrypt(
ciphertext.substr(kEncryptedDekPrefixSize + enc_dek_size),
associated_data);
diff --git a/cc/aead/kms_envelope_aead_key_manager.cc b/cc/aead/kms_envelope_aead_key_manager.cc
index 1091fcf..156503e 100644
--- a/cc/aead/kms_envelope_aead_key_manager.cc
+++ b/cc/aead/kms_envelope_aead_key_manager.cc
@@ -43,10 +43,10 @@
const auto& kek_uri = key.params().kek_uri();
auto kms_client_result = KmsClients::Get(kek_uri);
if (!kms_client_result.ok()) return kms_client_result.status();
- auto aead_result = kms_client_result.ValueOrDie()->GetAead(kek_uri);
+ auto aead_result = kms_client_result.value()->GetAead(kek_uri);
if (!aead_result.ok()) return aead_result.status();
return KmsEnvelopeAead::New(key.params().dek_template(),
- std::move(aead_result.ValueOrDie()));
+ std::move(aead_result.value()));
}
} // namespace tink
diff --git a/cc/aead/kms_envelope_aead_key_manager_test.cc b/cc/aead/kms_envelope_aead_key_manager_test.cc
index 732137f..f6c1e5d 100644
--- a/cc/aead/kms_envelope_aead_key_manager_test.cc
+++ b/cc/aead/kms_envelope_aead_key_manager_test.cc
@@ -127,8 +127,8 @@
*key_format.mutable_dek_template() = AeadKeyTemplates::Aes128Eax();
auto key_or = KmsEnvelopeAeadKeyManager().CreateKey(key_format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().params().kek_uri(), Eq(key_format.kek_uri()));
- EXPECT_THAT(key_or.ValueOrDie().params().dek_template().value(),
+ EXPECT_THAT(key_or.value().params().kek_uri(), Eq(key_format.kek_uri()));
+ EXPECT_THAT(key_or.value().params().dek_template().value(),
Eq(key_format.dek_template().value()));
}
@@ -167,10 +167,9 @@
absl::make_unique<DummyAead>("prefix1:some_key1"));
ASSERT_THAT(direct_aead.status(), IsOk());
- EXPECT_THAT(
- EncryptThenDecrypt(*kms_aead.ValueOrDie(),
- *direct_aead.ValueOrDie(), "plaintext", "aad"),
- IsOk());
+ EXPECT_THAT(EncryptThenDecrypt(*kms_aead.value(), *direct_aead.value(),
+ "plaintext", "aad"),
+ IsOk());
}
TEST_F(KmsEnvelopeAeadKeyManagerCreateTest, CreateAeadWrongKeyName) {
@@ -223,10 +222,9 @@
absl::make_unique<DummyAead>("prefix2:some_key2"));
ASSERT_THAT(direct_aead.status(), IsOk());
- EXPECT_THAT(
- EncryptThenDecrypt(*kms_aead.ValueOrDie(),
- *direct_aead.ValueOrDie(), "plaintext", "aad"),
- IsOk());
+ EXPECT_THAT(EncryptThenDecrypt(*kms_aead.value(), *direct_aead.value(),
+ "plaintext", "aad"),
+ IsOk());
}
} // namespace
diff --git a/cc/aead/kms_envelope_aead_test.cc b/cc/aead/kms_envelope_aead_test.cc
index 4c69ae3..fd31f19 100644
--- a/cc/aead/kms_envelope_aead_test.cc
+++ b/cc/aead/kms_envelope_aead_test.cc
@@ -55,14 +55,14 @@
auto aead_result = KmsEnvelopeAead::New(dek_template, std::move(remote_aead));
EXPECT_THAT(aead_result.status(), IsOk());
- auto aead = std::move(aead_result.ValueOrDie());
+ auto aead = std::move(aead_result.value());
std::string message = "Some data to encrypt.";
std::string aad = "Some data to authenticate.";
auto encrypt_result = aead->Encrypt(message, aad);
EXPECT_THAT(encrypt_result.status(), IsOk());
- auto decrypt_result = aead->Decrypt(encrypt_result.ValueOrDie(), aad);
+ auto decrypt_result = aead->Decrypt(encrypt_result.value(), aad);
EXPECT_THAT(decrypt_result.status(), IsOk());
- EXPECT_EQ(decrypt_result.ValueOrDie(), message);
+ EXPECT_EQ(decrypt_result.value(), message);
}
TEST(KmsEnvelopeAeadTest, NullAead) {
@@ -102,12 +102,12 @@
auto aead_result = KmsEnvelopeAead::New(dek_template, std::move(remote_aead));
EXPECT_THAT(aead_result.status(), IsOk());
- auto aead = std::move(aead_result.ValueOrDie());
+ auto aead = std::move(aead_result.value());
std::string message = "Some data to encrypt.";
std::string aad = "Some data to authenticate.";
auto encrypt_result = aead->Encrypt(message, aad);
EXPECT_THAT(encrypt_result.status(), IsOk());
- auto ct = encrypt_result.ValueOrDie();
+ auto ct = encrypt_result.value();
// Empty ciphertext.
auto decrypt_result = aead->Decrypt("", aad);
@@ -155,12 +155,12 @@
auto aead_result = KmsEnvelopeAead::New(dek_template, std::move(remote_aead));
EXPECT_THAT(aead_result.status(), IsOk());
- auto aead = std::move(aead_result.ValueOrDie());
+ auto aead = std::move(aead_result.value());
std::string message = "Some data to encrypt.";
std::string aad = "Some data to authenticate.";
auto encrypt_result = aead->Encrypt(message, aad);
EXPECT_THAT(encrypt_result.status(), IsOk());
- auto ct = encrypt_result.ValueOrDie();
+ auto ct = encrypt_result.value();
// Recover DEK from ciphertext
auto enc_dek_size =
@@ -172,7 +172,7 @@
// Check if we can deserialize a GCM key proto from the decrypted DEK.
google::crypto::tink::AesGcmKey key;
- EXPECT_THAT(key.ParseFromString(dek_decrypt_result.ValueOrDie()), true);
+ EXPECT_THAT(key.ParseFromString(dek_decrypt_result.value()), true);
EXPECT_THAT(key.key_value().size(), testing::Eq(16));
}
diff --git a/cc/aead/xchacha20_poly1305_key_manager.h b/cc/aead/xchacha20_poly1305_key_manager.h
index 7741cc4..f7d60bd 100644
--- a/cc/aead/xchacha20_poly1305_key_manager.h
+++ b/cc/aead/xchacha20_poly1305_key_manager.h
@@ -112,7 +112,7 @@
}
google::crypto::tink::XChaCha20Poly1305Key key;
key.set_version(get_version());
- key.set_key_value(randomness.ValueOrDie());
+ key.set_key_value(randomness.value());
return key;
}
diff --git a/cc/aead/xchacha20_poly1305_key_manager_test.cc b/cc/aead/xchacha20_poly1305_key_manager_test.cc
index 661be62..486fefe 100644
--- a/cc/aead/xchacha20_poly1305_key_manager_test.cc
+++ b/cc/aead/xchacha20_poly1305_key_manager_test.cc
@@ -106,8 +106,8 @@
XChaCha20Poly1305KeyManager().CreateKey(XChaCha20Poly1305KeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(), SizeIs(32));
- EXPECT_THAT(key_or.ValueOrDie().version(), Eq(0));
+ EXPECT_THAT(key_or.value().key_value(), SizeIs(32));
+ EXPECT_THAT(key_or.value().version(), Eq(0));
}
TEST(XChaCha20Poly1305KeyManagerTest, DeriveKey) {
@@ -119,8 +119,8 @@
XChaCha20Poly1305KeyManager().DeriveKey(format, &input_stream);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(), SizeIs(32));
- EXPECT_THAT(key_or.ValueOrDie().version(), Eq(0));
+ EXPECT_THAT(key_or.value().key_value(), SizeIs(32));
+ EXPECT_THAT(key_or.value().version(), Eq(0));
}
TEST(XChaCha20Poly1305KeyManagerTest, DeriveKeyFromLongSeed) {
@@ -132,7 +132,7 @@
auto key_or = XChaCha20Poly1305KeyManager().DeriveKey(format, &input_stream);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(),
+ EXPECT_THAT(key_or.value().key_value(),
Eq("0123456789abcdef0123456789abcdef"));
}
@@ -166,7 +166,7 @@
XChaCha20Poly1305KeyManager().CreateKey(XChaCha20Poly1305KeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(XChaCha20Poly1305KeyManager().ValidateKey(key_or.ValueOrDie()),
+ EXPECT_THAT(XChaCha20Poly1305KeyManager().ValidateKey(key_or.value()),
IsOk());
}
diff --git a/cc/core/binary_keyset_reader_test.cc b/cc/core/binary_keyset_reader_test.cc
index 59630cd..d23c302 100644
--- a/cc/core/binary_keyset_reader_test.cc
+++ b/cc/core/binary_keyset_reader_test.cc
@@ -107,17 +107,17 @@
{ // Good string.
auto reader_result = BinaryKeysetReader::New(good_serialized_keyset_);
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_result = reader->Read();
EXPECT_TRUE(read_result.ok()) << read_result.status();
- auto keyset = std::move(read_result.ValueOrDie());
+ auto keyset = std::move(read_result.value());
EXPECT_EQ(good_serialized_keyset_, keyset->SerializeAsString());
}
{ // Bad string.
auto reader_result = BinaryKeysetReader::New(bad_serialized_keyset_);
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_result = reader->Read();
EXPECT_FALSE(read_result.ok());
EXPECT_EQ(absl::StatusCode::kInvalidArgument, read_result.status().code());
@@ -130,10 +130,10 @@
std::string(good_serialized_keyset_), std::ios_base::in));
auto reader_result = BinaryKeysetReader::New(std::move(good_keyset_stream));
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_result = reader->Read();
EXPECT_TRUE(read_result.ok()) << read_result.status();
- auto keyset = std::move(read_result.ValueOrDie());
+ auto keyset = std::move(read_result.value());
EXPECT_EQ(good_serialized_keyset_, keyset->SerializeAsString());
}
@@ -142,7 +142,7 @@
std::string(bad_serialized_keyset_), std::ios_base::in));
auto reader_result = BinaryKeysetReader::New(std::move(bad_keyset_stream));
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_result = reader->Read();
EXPECT_FALSE(read_result.ok());
EXPECT_EQ(absl::StatusCode::kInvalidArgument, read_result.status().code());
@@ -154,10 +154,10 @@
auto reader_result =
BinaryKeysetReader::New(good_serialized_encrypted_keyset_);
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_encrypted_result = reader->ReadEncrypted();
EXPECT_TRUE(read_encrypted_result.ok()) << read_encrypted_result.status();
- auto encrypted_keyset = std::move(read_encrypted_result.ValueOrDie());
+ auto encrypted_keyset = std::move(read_encrypted_result.value());
EXPECT_EQ(good_serialized_encrypted_keyset_,
encrypted_keyset->SerializeAsString());
}
@@ -165,7 +165,7 @@
{ // Bad string.
auto reader_result = BinaryKeysetReader::New(bad_serialized_keyset_);
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_encrypted_result = reader->ReadEncrypted();
EXPECT_FALSE(read_encrypted_result.ok());
EXPECT_EQ(absl::StatusCode::kInvalidArgument,
@@ -181,10 +181,10 @@
auto reader_result =
BinaryKeysetReader::New(std::move(good_encrypted_keyset_stream));
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_encrypted_result = reader->ReadEncrypted();
EXPECT_TRUE(read_encrypted_result.ok()) << read_encrypted_result.status();
- auto encrypted_keyset = std::move(read_encrypted_result.ValueOrDie());
+ auto encrypted_keyset = std::move(read_encrypted_result.value());
EXPECT_EQ(good_serialized_encrypted_keyset_,
encrypted_keyset->SerializeAsString());
}
@@ -194,7 +194,7 @@
std::string(bad_serialized_keyset_), std::ios_base::in));
auto reader_result = BinaryKeysetReader::New(std::move(bad_keyset_stream));
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_encrypted_result = reader->ReadEncrypted();
EXPECT_FALSE(read_encrypted_result.ok());
EXPECT_EQ(absl::StatusCode::kInvalidArgument,
diff --git a/cc/core/binary_keyset_writer_test.cc b/cc/core/binary_keyset_writer_test.cc
index 0c026bc..cb0c919 100644
--- a/cc/core/binary_keyset_writer_test.cc
+++ b/cc/core/binary_keyset_writer_test.cc
@@ -86,7 +86,7 @@
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer_result = BinaryKeysetWriter::New(std::move(destination_stream));
ASSERT_TRUE(writer_result.ok()) << writer_result.status();
- auto writer = std::move(writer_result.ValueOrDie());
+ auto writer = std::move(writer_result.value());
auto status = writer->Write(keyset_);
EXPECT_TRUE(status.ok()) << status;
EXPECT_EQ(binary_keyset_, buffer.str());
@@ -97,7 +97,7 @@
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer_result = BinaryKeysetWriter::New(std::move(destination_stream));
ASSERT_TRUE(writer_result.ok()) << writer_result.status();
- auto writer = std::move(writer_result.ValueOrDie());
+ auto writer = std::move(writer_result.value());
auto status = writer->Write(encrypted_keyset_);
EXPECT_TRUE(status.ok()) << status;
EXPECT_EQ(binary_encrypted_keyset_, buffer.str());
@@ -109,7 +109,7 @@
destination_stream->setstate(std::ostream::badbit);
auto writer_result = BinaryKeysetWriter::New(std::move(destination_stream));
ASSERT_TRUE(writer_result.ok()) << writer_result.status();
- auto writer = std::move(writer_result.ValueOrDie());
+ auto writer = std::move(writer_result.value());
{ // Write keyset.
auto status = writer->Write(keyset_);
EXPECT_FALSE(status.ok()) << status;
diff --git a/cc/core/cleartext_keyset_handle.cc b/cc/core/cleartext_keyset_handle.cc
index c9c0514..6aa23a6 100644
--- a/cc/core/cleartext_keyset_handle.cc
+++ b/cc/core/cleartext_keyset_handle.cc
@@ -44,7 +44,7 @@
keyset_result.status().message());
}
std::unique_ptr<KeysetHandle> handle(
- new KeysetHandle(std::move(keyset_result.ValueOrDie())));
+ new KeysetHandle(std::move(keyset_result.value())));
return std::move(handle);
}
diff --git a/cc/core/cleartext_keyset_handle_test.cc b/cc/core/cleartext_keyset_handle_test.cc
index dbc75af..d172ccf 100644
--- a/cc/core/cleartext_keyset_handle_test.cc
+++ b/cc/core/cleartext_keyset_handle_test.cc
@@ -55,18 +55,18 @@
KeyData::SYMMETRIC, &keyset);
keyset.set_primary_key_id(42);
{ // Reader that reads a valid keyset.
- auto reader = std::move(
- BinaryKeysetReader::New(keyset.SerializeAsString()).ValueOrDie());
+ auto reader =
+ std::move(BinaryKeysetReader::New(keyset.SerializeAsString()).value());
auto result = CleartextKeysetHandle::Read(std::move(reader));
EXPECT_TRUE(result.ok()) << result.status();
- auto handle = std::move(result.ValueOrDie());
+ auto handle = std::move(result.value());
EXPECT_EQ(keyset.SerializeAsString(),
TestKeysetHandle::GetKeyset(*handle).SerializeAsString());
}
{ // Reader that fails upon read.
- auto reader = std::move(
- BinaryKeysetReader::New("invalid serialized keyset").ValueOrDie());
+ auto reader =
+ std::move(BinaryKeysetReader::New("invalid serialized keyset").value());
auto result = CleartextKeysetHandle::Read(std::move(reader));
EXPECT_FALSE(result.ok());
EXPECT_EQ(absl::StatusCode::kInvalidArgument, result.status().code());
@@ -87,7 +87,7 @@
std::stringbuf buffer;
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer =
- test::DummyKeysetWriter::New(std::move(destination_stream)).ValueOrDie();
+ test::DummyKeysetWriter::New(std::move(destination_stream)).value();
// Write a valid keyset.
EXPECT_EQ(CleartextKeysetHandle::Write(writer.get(), *(handle.get())),
diff --git a/cc/core/crypto_format_test.cc b/cc/core/crypto_format_test.cc
index c7f5c19..1cf4df7 100644
--- a/cc/core/crypto_format_test.cc
+++ b/cc/core/crypto_format_test.cc
@@ -34,7 +34,7 @@
auto prefix_result =
CryptoFormat::GetOutputPrefix(key_info);
EXPECT_TRUE(prefix_result.ok()) << prefix_result.status();
- auto prefix = prefix_result.ValueOrDie();
+ auto prefix = prefix_result.value();
EXPECT_EQ(prefix_size, prefix.length());
EXPECT_EQ(prefix_first_byte, prefix[0]);
// key_id should follow in BigEndian order
@@ -93,7 +93,7 @@
auto prefix_result =
CryptoFormat::GetOutputPrefix(key_info);
EXPECT_TRUE(prefix_result.ok()) << prefix_result.status();
- auto prefix = prefix_result.ValueOrDie();
+ auto prefix = prefix_result.value();
EXPECT_EQ(CryptoFormat::kRawPrefixSize, prefix.length());
}
diff --git a/cc/core/json_keyset_reader.cc b/cc/core/json_keyset_reader.cc
index 11df1ad..47c194d 100644
--- a/cc/core/json_keyset_reader.cc
+++ b/cc/core/json_keyset_reader.cc
@@ -110,7 +110,7 @@
for (const auto& json_key_info : json_value["keyInfo"].GetArray()) {
auto key_info_result = KeyInfoFromJson(json_key_info);
if (!key_info_result.ok()) return key_info_result.status();
- *(keyset_info->add_key_info()) = *(key_info_result.ValueOrDie());
+ *(keyset_info->add_key_info()) = *(key_info_result.value());
}
return std::move(keyset_info);
}
@@ -133,8 +133,7 @@
if (!keyset_info_result.ok()) {
return keyset_info_result.status();
}
- *(encrypted_keyset->mutable_keyset_info()) =
- *(keyset_info_result.ValueOrDie());
+ *(encrypted_keyset->mutable_keyset_info()) = *(keyset_info_result.value());
}
return std::move(encrypted_keyset);
}
@@ -208,7 +207,7 @@
key->set_status(Enums::KeyStatus(json_value["status"].GetString()));
key->set_output_prefix_type(
Enums::OutputPrefix(json_value["outputPrefixType"].GetString()));
- *(key->mutable_key_data()) = *(key_data_result.ValueOrDie());
+ *(key->mutable_key_data()) = *(key_data_result.value());
return std::move(key);
}
@@ -221,7 +220,7 @@
for (const auto& json_key : json_doc["key"].GetArray()) {
auto key_result = KeyFromJson(json_key);
if (!key_result.ok()) return key_result.status();
- *(keyset->add_key()) = *(key_result.ValueOrDie());
+ *(keyset->add_key()) = *(key_result.value());
}
return std::move(keyset);
}
diff --git a/cc/core/json_keyset_reader_test.cc b/cc/core/json_keyset_reader_test.cc
index 9612458..ef95a98 100644
--- a/cc/core/json_keyset_reader_test.cc
+++ b/cc/core/json_keyset_reader_test.cc
@@ -179,17 +179,17 @@
{ // Good string.
auto reader_result = JsonKeysetReader::New(good_json_keyset_);
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_result = reader->Read();
EXPECT_TRUE(read_result.ok()) << read_result.status();
- auto keyset = std::move(read_result.ValueOrDie());
+ auto keyset = std::move(read_result.value());
EXPECT_EQ(keyset_.SerializeAsString(), keyset->SerializeAsString());
}
{ // Bad string.
auto reader_result = JsonKeysetReader::New(bad_json_keyset_);
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_result = reader->Read();
EXPECT_FALSE(read_result.ok());
EXPECT_EQ(absl::StatusCode::kInvalidArgument, read_result.status().code());
@@ -202,10 +202,10 @@
std::string(good_json_keyset_), std::ios_base::in));
auto reader_result = JsonKeysetReader::New(std::move(good_keyset_stream));
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_result = reader->Read();
EXPECT_TRUE(read_result.ok()) << read_result.status();
- auto keyset = std::move(read_result.ValueOrDie());
+ auto keyset = std::move(read_result.value());
EXPECT_EQ(keyset_.SerializeAsString(), keyset->SerializeAsString());
}
@@ -214,7 +214,7 @@
std::string(bad_json_keyset_), std::ios_base::in));
auto reader_result = JsonKeysetReader::New(std::move(bad_keyset_stream));
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_result = reader->Read();
EXPECT_FALSE(read_result.ok());
EXPECT_EQ(absl::StatusCode::kInvalidArgument, read_result.status().code());
@@ -225,10 +225,10 @@
{ // Good string.
auto reader_result = JsonKeysetReader::New(good_json_encrypted_keyset_);
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_encrypted_result = reader->ReadEncrypted();
EXPECT_TRUE(read_encrypted_result.ok()) << read_encrypted_result.status();
- auto encrypted_keyset = std::move(read_encrypted_result.ValueOrDie());
+ auto encrypted_keyset = std::move(read_encrypted_result.value());
EXPECT_EQ(encrypted_keyset_.SerializeAsString(),
encrypted_keyset->SerializeAsString());
}
@@ -236,7 +236,7 @@
{ // Bad string.
auto reader_result = JsonKeysetReader::New(bad_json_keyset_);
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_encrypted_result = reader->ReadEncrypted();
EXPECT_FALSE(read_encrypted_result.ok());
EXPECT_EQ(absl::StatusCode::kInvalidArgument,
@@ -252,10 +252,10 @@
auto reader_result =
JsonKeysetReader::New(std::move(good_encrypted_keyset_stream));
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_encrypted_result = reader->ReadEncrypted();
EXPECT_TRUE(read_encrypted_result.ok()) << read_encrypted_result.status();
- auto encrypted_keyset = std::move(read_encrypted_result.ValueOrDie());
+ auto encrypted_keyset = std::move(read_encrypted_result.value());
EXPECT_EQ(encrypted_keyset_.SerializeAsString(),
encrypted_keyset->SerializeAsString());
}
@@ -265,7 +265,7 @@
std::string(bad_json_keyset_), std::ios_base::in));
auto reader_result = JsonKeysetReader::New(std::move(bad_keyset_stream));
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_encrypted_result = reader->ReadEncrypted();
EXPECT_FALSE(read_encrypted_result.ok());
EXPECT_EQ(absl::StatusCode::kInvalidArgument,
@@ -305,10 +305,10 @@
absl::Base64Escape(eax_key_.SerializeAsString()));
auto reader_result = JsonKeysetReader::New(json_serialization);
ASSERT_THAT(reader_result.status(), IsOk());
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_result = reader->Read();
ASSERT_THAT(read_result.status(), IsOk());
- auto keyset = std::move(read_result.ValueOrDie());
+ auto keyset = std::move(read_result.value());
EXPECT_THAT(keyset->primary_key_id(), Eq(4294967275));
}
@@ -344,7 +344,7 @@
absl::Base64Escape(eax_key_.SerializeAsString()));
auto reader_result = JsonKeysetReader::New(json_serialization);
ASSERT_THAT(reader_result.status(), IsOk());
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_result = reader->Read();
EXPECT_THAT(read_result.status(), Not(IsOk()));
}
diff --git a/cc/core/json_keyset_writer.cc b/cc/core/json_keyset_writer.cc
index 3949bf2..7c3f19c 100644
--- a/cc/core/json_keyset_writer.cc
+++ b/cc/core/json_keyset_writer.cc
@@ -203,14 +203,14 @@
util::Status JsonKeysetWriter::Write(const Keyset& keyset) {
auto json_string_result = ToJsonString(keyset);
if (!json_string_result.ok()) return json_string_result.status();
- return WriteData(json_string_result.ValueOrDie(), destination_stream_.get());
+ return WriteData(json_string_result.value(), destination_stream_.get());
}
util::Status JsonKeysetWriter::Write(
const EncryptedKeyset& encrypted_keyset) {
auto json_string_result = ToJsonString(encrypted_keyset);
if (!json_string_result.ok()) return json_string_result.status();
- return WriteData(json_string_result.ValueOrDie(), destination_stream_.get());
+ return WriteData(json_string_result.value(), destination_stream_.get());
}
} // namespace tink
diff --git a/cc/core/json_keyset_writer_test.cc b/cc/core/json_keyset_writer_test.cc
index 53a9cdb..4d6b6cb 100644
--- a/cc/core/json_keyset_writer_test.cc
+++ b/cc/core/json_keyset_writer_test.cc
@@ -157,7 +157,7 @@
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer_result = JsonKeysetWriter::New(std::move(destination_stream));
ASSERT_TRUE(writer_result.ok()) << writer_result.status();
- auto writer = std::move(writer_result.ValueOrDie());
+ auto writer = std::move(writer_result.value());
auto status = writer->Write(keyset_);
EXPECT_TRUE(status.ok()) << status;
rapidjson::Document json_keyset(rapidjson::kObjectType);
@@ -170,16 +170,16 @@
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer_result = JsonKeysetWriter::New(std::move(destination_stream));
ASSERT_TRUE(writer_result.ok()) << writer_result.status();
- auto writer = std::move(writer_result.ValueOrDie());
+ auto writer = std::move(writer_result.value());
auto status = writer->Write(keyset_);
EXPECT_TRUE(status.ok()) << status;
auto reader_result = JsonKeysetReader::New(buffer.str());
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_result = reader->Read();
EXPECT_TRUE(read_result.ok()) << read_result.status();
- auto keyset = std::move(read_result.ValueOrDie());
+ auto keyset = std::move(read_result.value());
EXPECT_EQ(keyset_.SerializeAsString(), keyset->SerializeAsString());
}
@@ -188,7 +188,7 @@
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer_result = JsonKeysetWriter::New(std::move(destination_stream));
ASSERT_TRUE(writer_result.ok()) << writer_result.status();
- auto writer = std::move(writer_result.ValueOrDie());
+ auto writer = std::move(writer_result.value());
auto status = writer->Write(encrypted_keyset_);
EXPECT_TRUE(status.ok()) << status;
rapidjson::Document json_encrypted_keyset(rapidjson::kObjectType);
@@ -209,16 +209,16 @@
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer_result = JsonKeysetWriter::New(std::move(destination_stream));
ASSERT_TRUE(writer_result.ok()) << writer_result.status();
- auto writer = std::move(writer_result.ValueOrDie());
+ auto writer = std::move(writer_result.value());
auto status = writer->Write(encrypted_keyset_);
EXPECT_TRUE(status.ok()) << status;
auto reader_result = JsonKeysetReader::New(buffer.str());
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto reader = std::move(reader_result.ValueOrDie());
+ auto reader = std::move(reader_result.value());
auto read_result = reader->ReadEncrypted();
EXPECT_TRUE(read_result.ok()) << read_result.status();
- auto encrypted_keyset = std::move(read_result.ValueOrDie());
+ auto encrypted_keyset = std::move(read_result.value());
EXPECT_EQ(encrypted_keyset_.SerializeAsString(),
encrypted_keyset->SerializeAsString());
}
@@ -229,7 +229,7 @@
destination_stream->setstate(std::ostream::badbit);
auto writer_result = JsonKeysetWriter::New(std::move(destination_stream));
ASSERT_TRUE(writer_result.ok()) << writer_result.status();
- auto writer = std::move(writer_result.ValueOrDie());
+ auto writer = std::move(writer_result.value());
{ // Write keyset.
auto status = writer->Write(keyset_);
EXPECT_FALSE(status.ok()) << status;
@@ -252,7 +252,7 @@
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer_result = JsonKeysetWriter::New(std::move(destination_stream));
ASSERT_THAT(writer_result.status(), IsOk());
- auto writer = std::move(writer_result.ValueOrDie());
+ auto writer = std::move(writer_result.value());
ASSERT_THAT(writer->Write(keyset), IsOk());
EXPECT_THAT(buffer.str(), HasSubstr("\"primaryKeyId\": 4123456789"));
EXPECT_THAT(buffer.str(), HasSubstr("\"keyId\": 4123456789"));
diff --git a/cc/core/key_manager_impl.h b/cc/core/key_manager_impl.h
index bfc01da..ae0de69 100644
--- a/cc/core/key_manager_impl.h
+++ b/cc/core/key_manager_impl.h
@@ -71,7 +71,7 @@
static_cast<const KeyFormatProto&>(key_format));
if (!new_key_result.ok()) return new_key_result.status();
return absl::implicit_cast<std::unique_ptr<portable_proto::MessageLite>>(
- absl::make_unique<KeyProto>(std::move(new_key_result.ValueOrDie())));
+ absl::make_unique<KeyProto>(std::move(new_key_result.value())));
}
crypto::tink::util::StatusOr<std::unique_ptr<portable_proto::MessageLite>>
@@ -94,7 +94,7 @@
NewKeyData(absl::string_view serialized_key_format) const override {
auto new_key_result = NewKey(serialized_key_format);
if (!new_key_result.ok()) return new_key_result.status();
- auto new_key = static_cast<const KeyProto&>(*(new_key_result.ValueOrDie()));
+ auto new_key = static_cast<const KeyProto&>(*(new_key_result.value()));
auto key_data = absl::make_unique<google::crypto::tink::KeyData>();
key_data->set_type_url(
absl::StrCat(kTypeGoogleapisCom, KeyProto().GetTypeName()));
@@ -269,13 +269,13 @@
if (!key_proto_or.ok()) {
return key_proto_or.status();
}
- status = key_type_manager->ValidateKey(key_proto_or.ValueOrDie());
+ status = key_type_manager->ValidateKey(key_proto_or.value());
if (!status.ok()) {
return status;
}
google::crypto::tink::KeyData result;
result.set_type_url(key_type_manager->get_key_type());
- result.set_value(key_proto_or.ValueOrDie().SerializeAsString());
+ result.set_value(key_proto_or.value().SerializeAsString());
result.set_key_material_type(key_type_manager->key_material_type());
return std::move(result);
};
diff --git a/cc/core/key_manager_impl_test.cc b/cc/core/key_manager_impl_test.cc
index 0a9315c..a7e6151 100644
--- a/cc/core/key_manager_impl_test.cc
+++ b/cc/core/key_manager_impl_test.cc
@@ -128,7 +128,7 @@
AesGcmKeyFormat key_format;
key_format.set_key_size(16);
- auto key = key_manager->get_key_factory().NewKey(key_format).ValueOrDie();
+ auto key = key_manager->get_key_factory().NewKey(key_format).value();
EXPECT_THAT(dynamic_cast<AesGcmKey&>(*key).key_value(), SizeIs(16));
}
@@ -142,7 +142,7 @@
key_format.set_key_size(16);
auto key = key_manager->get_key_factory()
.NewKey(key_format.SerializeAsString())
- .ValueOrDie();
+ .value();
EXPECT_THAT(dynamic_cast<AesGcmKey&>(*key).key_value(), SizeIs(16));
}
@@ -156,7 +156,7 @@
key_format.set_key_size(16);
auto key_data = *key_manager->get_key_factory()
.NewKeyData(key_format.SerializeAsString())
- .ValueOrDie();
+ .value();
AesGcmKey key;
key.ParseFromString(key_data.value());
@@ -223,9 +223,9 @@
key_format.set_key_size(16);
auto key_or = deriver(key_format.SerializeAsString(), nullptr);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_material_type(),
+ EXPECT_THAT(key_or.value().key_material_type(),
Eq(ExampleKeyTypeManager().key_material_type()));
- EXPECT_THAT(key_or.ValueOrDie().type_url(),
+ EXPECT_THAT(key_or.value().type_url(),
Eq(ExampleKeyTypeManager().get_key_type()));
}
@@ -244,14 +244,14 @@
return bytes_or.status();
}
AesGcmKey key;
- key.set_key_value(bytes_or.ValueOrDie());
+ key.set_key_value(bytes_or.value());
return key;
});
auto deriver = CreateDeriverFunctionFor(&internal_km);
auto key_or = deriver(key_format.SerializeAsString(), &input_stream);
AesGcmKey result;
- result.ParseFromString(key_or.ValueOrDie().value());
+ result.ParseFromString(key_or.value().value());
// Length 9 prefix of the above string.
EXPECT_THAT(result.key_value(), Eq("012345678"));
}
@@ -299,11 +299,11 @@
auto key_data = *key_manager->get_key_factory()
.NewKeyData(key_format.SerializeAsString())
- .ValueOrDie();
+ .value();
- auto aead = key_manager->GetPrimitive(key_data).ValueOrDie();
- std::string encryption = aead->Encrypt("Hi", "aad").ValueOrDie();
- std::string decryption = aead->Decrypt(encryption, "aad").ValueOrDie();
+ auto aead = key_manager->GetPrimitive(key_data).value();
+ std::string encryption = aead->Encrypt("Hi", "aad").value();
+ std::string decryption = aead->Decrypt(encryption, "aad").value();
EXPECT_THAT(decryption, Eq("Hi"));
}
@@ -316,11 +316,11 @@
key_format.set_key_size(16);
auto key_data = *key_manager->get_key_factory()
.NewKeyData(key_format.SerializeAsString())
- .ValueOrDie();
+ .value();
AesGcmKey key;
key.ParseFromString(key_data.value());
- auto aead_variant = key_manager->GetPrimitive(key_data).ValueOrDie();
+ auto aead_variant = key_manager->GetPrimitive(key_data).value();
EXPECT_THAT(aead_variant->get(), Eq(key.key_value()));
}
@@ -333,11 +333,11 @@
key_format.set_key_size(16);
auto key = key_manager->get_key_factory()
.NewKey(key_format.SerializeAsString())
- .ValueOrDie();
+ .value();
- auto aead = key_manager->GetPrimitive(*key).ValueOrDie();
- std::string encryption = aead->Encrypt("Hi", "aad").ValueOrDie();
- std::string decryption = aead->Decrypt(encryption, "aad").ValueOrDie();
+ auto aead = key_manager->GetPrimitive(*key).value();
+ std::string encryption = aead->Encrypt("Hi", "aad").value();
+ std::string decryption = aead->Decrypt(encryption, "aad").value();
EXPECT_THAT(decryption, Eq("Hi"));
}
@@ -377,7 +377,7 @@
key_format.set_key_size(16);
auto key_data = *key_manager->get_key_factory()
.NewKeyData(key_format.SerializeAsString())
- .ValueOrDie();
+ .value();
AesGcmKey key;
key.ParseFromString(key_data.value());
@@ -399,7 +399,7 @@
key_format.set_key_size(16);
auto key_data = *key_manager->get_key_factory()
.NewKeyData(key_format.SerializeAsString())
- .ValueOrDie();
+ .value();
AesGcmKey key;
key.ParseFromString(key_data.value());
@@ -425,7 +425,7 @@
key_format.set_key_size(16);
auto key_data = *key_manager->get_key_factory()
.NewKeyData(key_format.SerializeAsString())
- .ValueOrDie();
+ .value();
EXPECT_THAT(key_manager->GetPrimitive(key_data).status(),
StatusIs(absl::StatusCode::kInvalidArgument,
@@ -488,13 +488,13 @@
AesGcmKeyFormat key_format;
key_format.set_key_size(16);
- KeyData key_data = test::AsKeyData(
- ExampleKeyTypeManager().CreateKey(key_format).ValueOrDie(),
- KeyData::SYMMETRIC);
+ KeyData key_data =
+ test::AsKeyData(ExampleKeyTypeManager().CreateKey(key_format).value(),
+ KeyData::SYMMETRIC);
- auto aead = key_manager->GetPrimitive(key_data).ValueOrDie();
- std::string encryption = aead->Encrypt("Hi", "aad").ValueOrDie();
- std::string decryption = aead->Decrypt(encryption, "aad").ValueOrDie();
+ auto aead = key_manager->GetPrimitive(key_data).value();
+ std::string encryption = aead->Encrypt("Hi", "aad").value();
+ std::string decryption = aead->Decrypt(encryption, "aad").value();
EXPECT_THAT(decryption, Eq("Hi"));
}
diff --git a/cc/core/key_type_manager_test.cc b/cc/core/key_type_manager_test.cc
index 0cf29b4..921aea5 100644
--- a/cc/core/key_type_manager_test.cc
+++ b/cc/core/key_type_manager_test.cc
@@ -114,21 +114,21 @@
TEST(KeyManagerTest, CreateAead) {
AesGcmKeyFormat key_format;
key_format.set_key_size(16);
- AesGcmKey key = ExampleKeyTypeManager().CreateKey(key_format).ValueOrDie();
+ AesGcmKey key = ExampleKeyTypeManager().CreateKey(key_format).value();
std::unique_ptr<Aead> aead =
- ExampleKeyTypeManager().GetPrimitive<Aead>(key).ValueOrDie();
+ ExampleKeyTypeManager().GetPrimitive<Aead>(key).value();
- std::string encryption = aead->Encrypt("Hi", "aad").ValueOrDie();
- std::string decryption = aead->Decrypt(encryption, "aad").ValueOrDie();
+ std::string encryption = aead->Encrypt("Hi", "aad").value();
+ std::string decryption = aead->Decrypt(encryption, "aad").value();
EXPECT_THAT(decryption, Eq("Hi"));
}
TEST(KeyManagerTest, CreateAeadVariant) {
AesGcmKeyFormat key_format;
key_format.set_key_size(16);
- AesGcmKey key = ExampleKeyTypeManager().CreateKey(key_format).ValueOrDie();
+ AesGcmKey key = ExampleKeyTypeManager().CreateKey(key_format).value();
std::unique_ptr<AeadVariant> aead_variant =
- ExampleKeyTypeManager().GetPrimitive<AeadVariant>(key).ValueOrDie();
+ ExampleKeyTypeManager().GetPrimitive<AeadVariant>(key).value();
EXPECT_THAT(aead_variant->get(), Eq(key.key_value()));
}
@@ -188,22 +188,21 @@
TEST(KeyManagerWithoutFactoryTest, CreateAead) {
AesGcmKeyFormat key_format;
key_format.set_key_size(16);
- AesGcmKey key = ExampleKeyTypeManager().CreateKey(key_format).ValueOrDie();
- std::unique_ptr<Aead> aead = ExampleKeyTypeManagerWithoutFactory()
- .GetPrimitive<Aead>(key)
- .ValueOrDie();
+ AesGcmKey key = ExampleKeyTypeManager().CreateKey(key_format).value();
+ std::unique_ptr<Aead> aead =
+ ExampleKeyTypeManagerWithoutFactory().GetPrimitive<Aead>(key).value();
- std::string encryption = aead->Encrypt("Hi", "aad").ValueOrDie();
- std::string decryption = aead->Decrypt(encryption, "aad").ValueOrDie();
+ std::string encryption = aead->Encrypt("Hi", "aad").value();
+ std::string decryption = aead->Decrypt(encryption, "aad").value();
EXPECT_THAT(decryption, Eq("Hi"));
}
TEST(KeyManagerWithoutFactoryTest, CreateAeadVariant) {
AesGcmKeyFormat key_format;
key_format.set_key_size(16);
- AesGcmKey key = ExampleKeyTypeManager().CreateKey(key_format).ValueOrDie();
+ AesGcmKey key = ExampleKeyTypeManager().CreateKey(key_format).value();
std::unique_ptr<AeadVariant> aead_variant =
- ExampleKeyTypeManager().GetPrimitive<AeadVariant>(key).ValueOrDie();
+ ExampleKeyTypeManager().GetPrimitive<AeadVariant>(key).value();
EXPECT_THAT(aead_variant->get(), Eq(key.key_value()));
}
diff --git a/cc/core/keyset_handle.cc b/cc/core/keyset_handle.cc
index b324e41..9efb91d 100644
--- a/cc/core/keyset_handle.cc
+++ b/cc/core/keyset_handle.cc
@@ -49,7 +49,7 @@
master_key_aead.Encrypt(keyset.SerializeAsString(), associated_data);
if (!encrypt_result.ok()) return encrypt_result.status();
auto enc_keyset = absl::make_unique<EncryptedKeyset>();
- enc_keyset->set_encrypted_keyset(encrypt_result.ValueOrDie());
+ enc_keyset->set_encrypted_keyset(encrypt_result.value());
return std::move(enc_keyset);
}
@@ -60,7 +60,7 @@
master_key_aead.Decrypt(enc_keyset.encrypted_keyset(), associated_data);
if (!decrypt_result.ok()) return decrypt_result.status();
auto keyset = absl::make_unique<Keyset>();
- if (!keyset->ParseFromString(decrypt_result.ValueOrDie())) {
+ if (!keyset->ParseFromString(decrypt_result.value())) {
return util::Status(
absl::StatusCode::kInvalidArgument,
"Could not parse the decrypted data as a Keyset-proto.");
@@ -102,8 +102,8 @@
enc_keyset_result.status().message());
}
- auto keyset_result = Decrypt(*enc_keyset_result.ValueOrDie(), master_key_aead,
- associated_data);
+ auto keyset_result =
+ Decrypt(*enc_keyset_result.value(), master_key_aead, associated_data);
if (!keyset_result.ok()) {
return ToStatusF(absl::StatusCode::kInvalidArgument,
"Error decrypting encrypted keyset: %s",
@@ -111,7 +111,7 @@
}
std::unique_ptr<KeysetHandle> handle(
- new KeysetHandle(std::move(keyset_result.ValueOrDie())));
+ new KeysetHandle(std::move(keyset_result.value())));
return std::move(handle);
}
@@ -146,7 +146,7 @@
"Encryption of the keyset failed: %s",
encrypt_result.status().message());
}
- return writer->Write(*(encrypt_result.ValueOrDie()));
+ return writer->Write(*(encrypt_result.value()));
}
util::Status KeysetHandle::WriteNoSecret(KeysetWriter* writer) const {
@@ -183,7 +183,7 @@
key.key_data().value());
if (!key_data_result.ok()) return key_data_result.status();
auto public_key = absl::make_unique<Keyset::Key>(key);
- public_key->mutable_key_data()->Swap(key_data_result.ValueOrDie().get());
+ public_key->mutable_key_data()->Swap(key_data_result.value().get());
return std::move(public_key);
}
@@ -193,7 +193,7 @@
for (const Keyset::Key& key : get_keyset().key()) {
auto public_key_result = ExtractPublicKey(key);
if (!public_key_result.ok()) return public_key_result.status();
- public_keyset->add_key()->Swap(public_key_result.ValueOrDie().get());
+ public_keyset->add_key()->Swap(public_key_result.value().get());
}
public_keyset->set_primary_key_id(get_keyset().primary_key_id());
std::unique_ptr<KeysetHandle> handle(
@@ -211,7 +211,7 @@
}
auto key_data_result = Registry::NewKeyData(key_template);
if (!key_data_result.ok()) return key_data_result.status();
- auto key_data = std::move(key_data_result.ValueOrDie());
+ auto key_data = std::move(key_data_result.value());
Keyset::Key* key = keyset->add_key();
uint32_t key_id = GenerateUnusedKeyId(*keyset);
*(key->mutable_key_data()) = *key_data;
diff --git a/cc/core/keyset_handle_test.cc b/cc/core/keyset_handle_test.cc
index 2ed9cd5..1381ec6 100644
--- a/cc/core/keyset_handle_test.cc
+++ b/cc/core/keyset_handle_test.cc
@@ -86,14 +86,14 @@
DummyAead aead("dummy aead 42");
std::string keyset_ciphertext =
aead.Encrypt(keyset.SerializeAsString(), /* associated_data= */ "")
- .ValueOrDie();
+ .value();
EncryptedKeyset encrypted_keyset;
encrypted_keyset.set_encrypted_keyset(keyset_ciphertext);
- auto reader = std::move(BinaryKeysetReader::New(
- encrypted_keyset.SerializeAsString()).ValueOrDie());
+ auto reader = std::move(
+ BinaryKeysetReader::New(encrypted_keyset.SerializeAsString()).value());
auto result = KeysetHandle::Read(std::move(reader), aead);
EXPECT_TRUE(result.ok()) << result.status();
- auto handle = std::move(result.ValueOrDie());
+ auto handle = std::move(result.value());
EXPECT_EQ(keyset.SerializeAsString(),
TestKeysetHandle::GetKeyset(*handle).SerializeAsString());
}
@@ -102,11 +102,11 @@
DummyAead aead("dummy aead 42");
std::string keyset_ciphertext =
aead.Encrypt(keyset.SerializeAsString(), /* associated_data= */ "")
- .ValueOrDie();
+ .value();
EncryptedKeyset encrypted_keyset;
encrypted_keyset.set_encrypted_keyset(keyset_ciphertext);
- auto reader = std::move(BinaryKeysetReader::New(
- encrypted_keyset.SerializeAsString()).ValueOrDie());
+ auto reader = std::move(
+ BinaryKeysetReader::New(encrypted_keyset.SerializeAsString()).value());
DummyAead wrong_aead("wrong aead");
auto result = KeysetHandle::Read(std::move(reader), wrong_aead);
EXPECT_FALSE(result.ok());
@@ -117,11 +117,11 @@
DummyAead aead("dummy aead 42");
std::string keyset_ciphertext =
aead.Encrypt("not a serialized keyset", /* associated_data= */ "")
- .ValueOrDie();
+ .value();
EncryptedKeyset encrypted_keyset;
encrypted_keyset.set_encrypted_keyset(keyset_ciphertext);
- auto reader = std::move(BinaryKeysetReader::New(
- encrypted_keyset.SerializeAsString()).ValueOrDie());
+ auto reader = std::move(
+ BinaryKeysetReader::New(encrypted_keyset.SerializeAsString()).value());
auto result = KeysetHandle::Read(std::move(reader), aead);
EXPECT_FALSE(result.ok());
EXPECT_EQ(absl::StatusCode::kInvalidArgument, result.status().code());
@@ -132,8 +132,8 @@
std::string keyset_ciphertext = "totally wrong ciphertext";
EncryptedKeyset encrypted_keyset;
encrypted_keyset.set_encrypted_keyset(keyset_ciphertext);
- auto reader = std::move(BinaryKeysetReader::New(
- encrypted_keyset.SerializeAsString()).ValueOrDie());
+ auto reader = std::move(
+ BinaryKeysetReader::New(encrypted_keyset.SerializeAsString()).value());
auto result = KeysetHandle::Read(std::move(reader), aead);
EXPECT_FALSE(result.ok());
EXPECT_EQ(absl::StatusCode::kInvalidArgument, result.status().code());
@@ -153,7 +153,7 @@
DummyAead aead("dummy aead 42");
std::string keyset_ciphertext =
aead.Encrypt(keyset.SerializeAsString(), /* associated_data= */ "")
- .ValueOrDie();
+ .value();
EncryptedKeyset encrypted_keyset;
encrypted_keyset.set_encrypted_keyset(keyset_ciphertext);
auto* keyset_info = encrypted_keyset.mutable_keyset_info();
@@ -167,15 +167,15 @@
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer_result = JsonKeysetWriter::New(std::move(destination_stream));
ASSERT_TRUE(writer_result.ok()) << writer_result.status();
- auto status = writer_result.ValueOrDie()->Write(encrypted_keyset);
+ auto status = writer_result.value()->Write(encrypted_keyset);
EXPECT_TRUE(status.ok()) << status;
std::string json_serialized_encrypted_keyset = buffer.str();
EXPECT_TRUE(status.ok()) << status;
- auto reader = std::move(JsonKeysetReader::New(
- json_serialized_encrypted_keyset).ValueOrDie());
+ auto reader = std::move(
+ JsonKeysetReader::New(json_serialized_encrypted_keyset).value());
auto result = KeysetHandle::Read(std::move(reader), aead);
EXPECT_TRUE(result.ok()) << result.status();
- auto handle = std::move(result.ValueOrDie());
+ auto handle = std::move(result.value());
EXPECT_EQ(keyset.SerializeAsString(),
TestKeysetHandle::GetKeyset(*handle).SerializeAsString());
}
@@ -184,11 +184,11 @@
DummyAead aead("dummy aead 42");
std::string keyset_ciphertext =
aead.Encrypt(keyset.SerializeAsString(), /* associated_data= */ "")
- .ValueOrDie();
+ .value();
EncryptedKeyset encrypted_keyset;
encrypted_keyset.set_encrypted_keyset(keyset_ciphertext);
- auto reader = std::move(JsonKeysetReader::New(
- encrypted_keyset.SerializeAsString()).ValueOrDie());
+ auto reader = std::move(
+ JsonKeysetReader::New(encrypted_keyset.SerializeAsString()).value());
DummyAead wrong_aead("wrong aead");
auto result = KeysetHandle::Read(std::move(reader), wrong_aead);
EXPECT_FALSE(result.ok());
@@ -199,11 +199,11 @@
DummyAead aead("dummy aead 42");
std::string keyset_ciphertext =
aead.Encrypt("not a serialized keyset", /* associated_data= */ "")
- .ValueOrDie();
+ .value();
EncryptedKeyset encrypted_keyset;
encrypted_keyset.set_encrypted_keyset(keyset_ciphertext);
- auto reader = std::move(JsonKeysetReader::New(
- encrypted_keyset.SerializeAsString()).ValueOrDie());
+ auto reader = std::move(
+ JsonKeysetReader::New(encrypted_keyset.SerializeAsString()).value());
auto result = KeysetHandle::Read(std::move(reader), aead);
EXPECT_FALSE(result.ok());
EXPECT_EQ(absl::StatusCode::kInvalidArgument, result.status().code());
@@ -214,8 +214,8 @@
std::string keyset_ciphertext = "totally wrong ciphertext";
EncryptedKeyset encrypted_keyset;
encrypted_keyset.set_encrypted_keyset(keyset_ciphertext);
- auto reader = std::move(JsonKeysetReader::New(
- encrypted_keyset.SerializeAsString()).ValueOrDie());
+ auto reader = std::move(
+ JsonKeysetReader::New(encrypted_keyset.SerializeAsString()).value());
auto result = KeysetHandle::Read(std::move(reader), aead);
EXPECT_FALSE(result.ok());
EXPECT_EQ(absl::StatusCode::kInvalidArgument, result.status().code());
@@ -231,30 +231,30 @@
AddRawKey("some other key type", 711, key, KeyStatusType::ENABLED,
KeyData::SYMMETRIC, &keyset);
keyset.set_primary_key_id(42);
- auto reader = std::move(
- BinaryKeysetReader::New(keyset.SerializeAsString()).ValueOrDie());
- auto keyset_handle = std::move(
- CleartextKeysetHandle::Read(std::move(reader)).ValueOrDie());
+ auto reader =
+ std::move(BinaryKeysetReader::New(keyset.SerializeAsString()).value());
+ auto keyset_handle =
+ std::move(CleartextKeysetHandle::Read(std::move(reader)).value());
// Prepare a keyset writer.
DummyAead aead("dummy aead 42");
std::stringbuf buffer;
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
- auto writer = std::move(
- JsonKeysetWriter::New(std::move(destination_stream)).ValueOrDie());
+ auto writer =
+ std::move(JsonKeysetWriter::New(std::move(destination_stream)).value());
// Write the keyset handle and check the result.
auto status = keyset_handle->Write(writer.get(), aead);
EXPECT_TRUE(status.ok()) << status;
auto reader_result = JsonKeysetReader::New(buffer.str());
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto read_encrypted_result = reader_result.ValueOrDie()->ReadEncrypted();
+ auto read_encrypted_result = reader_result.value()->ReadEncrypted();
EXPECT_TRUE(read_encrypted_result.ok()) << read_encrypted_result.status();
- auto encrypted_keyset = std::move(read_encrypted_result.ValueOrDie());
+ auto encrypted_keyset = std::move(read_encrypted_result.value());
auto decrypt_result = aead.Decrypt(encrypted_keyset->encrypted_keyset(),
/* associated_data= */ "");
EXPECT_TRUE(decrypt_result.status().ok()) << decrypt_result.status();
- auto decrypted = decrypt_result.ValueOrDie();
+ auto decrypted = decrypt_result.value();
EXPECT_EQ(decrypted, keyset.SerializeAsString());
// Try writing to a null-writer.
@@ -274,16 +274,15 @@
DummyAead aead("dummy aead 42");
std::string keyset_ciphertext =
- aead.Encrypt(keyset.SerializeAsString(), "aad").ValueOrDie();
+ aead.Encrypt(keyset.SerializeAsString(), "aad").value();
EncryptedKeyset encrypted_keyset;
encrypted_keyset.set_encrypted_keyset(keyset_ciphertext);
- std::unique_ptr<KeysetReader> reader =
- std::move(BinaryKeysetReader::New(encrypted_keyset.SerializeAsString())
- .ValueOrDie());
+ std::unique_ptr<KeysetReader> reader = std::move(
+ BinaryKeysetReader::New(encrypted_keyset.SerializeAsString()).value());
util::StatusOr<std::unique_ptr<KeysetHandle>> result =
KeysetHandle::ReadWithAssociatedData(std::move(reader), aead, "aad");
EXPECT_THAT(result.status(), IsOk());
- auto handle = std::move(result.ValueOrDie());
+ auto handle = std::move(result.value());
EXPECT_EQ(keyset.SerializeAsString(),
TestKeysetHandle::GetKeyset(*handle).SerializeAsString());
}
@@ -298,12 +297,11 @@
keyset.set_primary_key_id(42);
DummyAead aead("dummy aead 42");
std::string keyset_ciphertext =
- aead.Encrypt(keyset.SerializeAsString(), "aad").ValueOrDie();
+ aead.Encrypt(keyset.SerializeAsString(), "aad").value();
EncryptedKeyset encrypted_keyset;
encrypted_keyset.set_encrypted_keyset(keyset_ciphertext);
- auto reader =
- std::move(BinaryKeysetReader::New(encrypted_keyset.SerializeAsString())
- .ValueOrDie());
+ auto reader = std::move(
+ BinaryKeysetReader::New(encrypted_keyset.SerializeAsString()).value());
auto result = KeysetHandle::ReadWithAssociatedData(std::move(reader), aead,
"different");
EXPECT_THAT(result.status(), Not(IsOk()));
@@ -320,12 +318,11 @@
keyset.set_primary_key_id(42);
DummyAead aead("dummy aead 42");
std::string keyset_ciphertext =
- aead.Encrypt(keyset.SerializeAsString(), "aad").ValueOrDie();
+ aead.Encrypt(keyset.SerializeAsString(), "aad").value();
EncryptedKeyset encrypted_keyset;
encrypted_keyset.set_encrypted_keyset(keyset_ciphertext);
- auto reader =
- std::move(BinaryKeysetReader::New(encrypted_keyset.SerializeAsString())
- .ValueOrDie());
+ auto reader = std::move(
+ BinaryKeysetReader::New(encrypted_keyset.SerializeAsString()).value());
auto result = KeysetHandle::Read(std::move(reader), aead);
EXPECT_THAT(result.status(), Not(IsOk()));
EXPECT_EQ(absl::StatusCode::kInvalidArgument, result.status().code());
@@ -340,17 +337,17 @@
AddRawKey("some other key type", 711, key, KeyStatusType::ENABLED,
KeyData::SYMMETRIC, &keyset);
keyset.set_primary_key_id(42);
- auto reader = std::move(
- BinaryKeysetReader::New(keyset.SerializeAsString()).ValueOrDie());
+ auto reader =
+ std::move(BinaryKeysetReader::New(keyset.SerializeAsString()).value());
auto keyset_handle =
- std::move(CleartextKeysetHandle::Read(std::move(reader)).ValueOrDie());
+ std::move(CleartextKeysetHandle::Read(std::move(reader)).value());
// Prepare a keyset writer.
DummyAead aead("dummy aead 42");
std::stringbuf buffer;
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
- auto writer = std::move(
- BinaryKeysetWriter::New(std::move(destination_stream)).ValueOrDie());
+ auto writer =
+ std::move(BinaryKeysetWriter::New(std::move(destination_stream)).value());
// Write the keyset handle and check the result.
auto status =
@@ -358,13 +355,13 @@
EXPECT_TRUE(status.ok()) << status;
auto reader_result = BinaryKeysetReader::New(buffer.str());
EXPECT_TRUE(reader_result.ok()) << reader_result.status();
- auto read_encrypted_result = reader_result.ValueOrDie()->ReadEncrypted();
+ auto read_encrypted_result = reader_result.value()->ReadEncrypted();
EXPECT_TRUE(read_encrypted_result.ok()) << read_encrypted_result.status();
- auto encrypted_keyset = std::move(read_encrypted_result.ValueOrDie());
+ auto encrypted_keyset = std::move(read_encrypted_result.value());
auto decrypt_result =
aead.Decrypt(encrypted_keyset->encrypted_keyset(), "aad");
EXPECT_TRUE(decrypt_result.status().ok()) << decrypt_result.status();
- auto decrypted = decrypt_result.ValueOrDie();
+ auto decrypted = decrypt_result.value();
EXPECT_EQ(decrypted, keyset.SerializeAsString());
// Try writing to a null-writer.
@@ -418,12 +415,12 @@
auto handle_result = KeysetHandle::GenerateNew(
SignatureKeyTemplates::EcdsaP256());
ASSERT_TRUE(handle_result.ok()) << handle_result.status();
- auto handle = std::move(handle_result.ValueOrDie());
+ auto handle = std::move(handle_result.value());
auto public_handle_result = handle->GetPublicKeysetHandle();
ASSERT_TRUE(public_handle_result.ok()) << public_handle_result.status();
auto keyset = TestKeysetHandle::GetKeyset(*handle);
auto public_keyset =
- TestKeysetHandle::GetKeyset(*(public_handle_result.ValueOrDie()));
+ TestKeysetHandle::GetKeyset(*(public_handle_result.value()));
EXPECT_EQ(keyset.primary_key_id(), public_keyset.primary_key_id());
EXPECT_EQ(keyset.key_size(), public_keyset.key_size());
CompareKeyMetadata(keyset.key(0), public_keyset.key(0));
@@ -439,26 +436,24 @@
ASSERT_TRUE(
key_format.ParseFromString(SignatureKeyTemplates::EcdsaP256().value()));
AddTinkKey(EcdsaSignKeyManager().get_key_type(),
- /* key_id= */ 623628,
- key_manager.CreateKey(key_format).ValueOrDie(),
+ /* key_id= */ 623628, key_manager.CreateKey(key_format).value(),
KeyStatusType::ENABLED, KeyData::ASYMMETRIC_PRIVATE, &keyset);
ASSERT_TRUE(key_format.ParseFromString(
SignatureKeyTemplates::EcdsaP384Sha384().value()));
AddLegacyKey(EcdsaSignKeyManager().get_key_type(),
- /* key_id= */ 36285,
- key_manager.CreateKey(key_format).ValueOrDie(),
+ /* key_id= */ 36285, key_manager.CreateKey(key_format).value(),
KeyStatusType::DISABLED, KeyData::ASYMMETRIC_PRIVATE, &keyset);
ASSERT_TRUE(key_format.ParseFromString(
SignatureKeyTemplates::EcdsaP384Sha512().value()));
AddRawKey(EcdsaSignKeyManager().get_key_type(),
- /* key_id= */ 42, key_manager.CreateKey(key_format).ValueOrDie(),
+ /* key_id= */ 42, key_manager.CreateKey(key_format).value(),
KeyStatusType::ENABLED, KeyData::ASYMMETRIC_PRIVATE, &keyset);
keyset.set_primary_key_id(42);
auto handle = TestKeysetHandle::GetKeysetHandle(keyset);
auto public_handle_result = handle->GetPublicKeysetHandle();
ASSERT_TRUE(public_handle_result.ok()) << public_handle_result.status();
auto public_keyset =
- TestKeysetHandle::GetKeyset(*(public_handle_result.ValueOrDie()));
+ TestKeysetHandle::GetKeyset(*(public_handle_result.value()));
EXPECT_EQ(keyset.primary_key_id(), public_keyset.primary_key_id());
EXPECT_EQ(keyset.key_size(), public_keyset.key_size());
for (int i = 0; i < key_count; i++) {
@@ -475,7 +470,7 @@
auto handle_result = KeysetHandle::GenerateNew(
AeadKeyTemplates::Aes128Eax());
ASSERT_TRUE(handle_result.ok()) << handle_result.status();
- auto handle = std::move(handle_result.ValueOrDie());
+ auto handle = std::move(handle_result.value());
auto public_handle_result = handle->GetPublicKeysetHandle();
ASSERT_FALSE(public_handle_result.ok());
EXPECT_PRED_FORMAT2(testing::IsSubstring, "ASYMMETRIC_PRIVATE",
@@ -491,11 +486,11 @@
aead_key_format.set_key_size(16);
AddTinkKey(EcdsaSignKeyManager().get_key_type(),
/* key_id= */ 623628,
- EcdsaSignKeyManager().CreateKey(ecdsa_key_format).ValueOrDie(),
+ EcdsaSignKeyManager().CreateKey(ecdsa_key_format).value(),
KeyStatusType::ENABLED, KeyData::ASYMMETRIC_PRIVATE, &keyset);
AddLegacyKey(AesGcmKeyManager().get_key_type(),
/* key_id= */ 42,
- AesGcmKeyManager().CreateKey(aead_key_format).ValueOrDie(),
+ AesGcmKeyManager().CreateKey(aead_key_format).value(),
KeyStatusType::ENABLED,
KeyData::ASYMMETRIC_PRIVATE, // Intentionally wrong setting.
&keyset);
@@ -511,17 +506,17 @@
TEST_F(KeysetHandleTest, GetPrimitive) {
Keyset keyset;
KeyData key_data_0 =
- *Registry::NewKeyData(AeadKeyTemplates::Aes128Gcm()).ValueOrDie();
+ *Registry::NewKeyData(AeadKeyTemplates::Aes128Gcm()).value();
AddKeyData(key_data_0, /*key_id=*/0,
google::crypto::tink::OutputPrefixType::TINK,
KeyStatusType::ENABLED, &keyset);
KeyData key_data_1 =
- *Registry::NewKeyData(AeadKeyTemplates::Aes256Gcm()).ValueOrDie();
+ *Registry::NewKeyData(AeadKeyTemplates::Aes256Gcm()).value();
AddKeyData(key_data_1, /*key_id=*/1,
google::crypto::tink::OutputPrefixType::TINK,
KeyStatusType::ENABLED, &keyset);
KeyData key_data_2 =
- *Registry::NewKeyData(AeadKeyTemplates::Aes256Gcm()).ValueOrDie();
+ *Registry::NewKeyData(AeadKeyTemplates::Aes256Gcm()).value();
AddKeyData(key_data_2, /*key_id=*/2,
google::crypto::tink::OutputPrefixType::RAW,
KeyStatusType::ENABLED, &keyset);
@@ -532,25 +527,25 @@
// Check that encryption with the primary can be decrypted with key_data_1.
auto aead_result = keyset_handle->GetPrimitive<Aead>();
ASSERT_TRUE(aead_result.ok()) << aead_result.status();
- std::unique_ptr<Aead> aead = std::move(aead_result.ValueOrDie());
+ std::unique_ptr<Aead> aead = std::move(aead_result.value());
std::string plaintext = "plaintext";
std::string aad = "aad";
- std::string encryption = aead->Encrypt(plaintext, aad).ValueOrDie();
- EXPECT_EQ(aead->Decrypt(encryption, aad).ValueOrDie(), plaintext);
+ std::string encryption = aead->Encrypt(plaintext, aad).value();
+ EXPECT_EQ(aead->Decrypt(encryption, aad).value(), plaintext);
std::unique_ptr<Aead> raw_aead =
- Registry::GetPrimitive<Aead>(key_data_2).ValueOrDie();
+ Registry::GetPrimitive<Aead>(key_data_2).value();
EXPECT_FALSE(raw_aead->Decrypt(encryption, aad).ok());
- std::string raw_encryption = raw_aead->Encrypt(plaintext, aad).ValueOrDie();
- EXPECT_EQ(aead->Decrypt(raw_encryption, aad).ValueOrDie(), plaintext);
+ std::string raw_encryption = raw_aead->Encrypt(plaintext, aad).value();
+ EXPECT_EQ(aead->Decrypt(raw_encryption, aad).value(), plaintext);
}
// Tests that GetPrimitive(nullptr) fails with a non-ok status.
TEST_F(KeysetHandleTest, GetPrimitiveNullptrKeyManager) {
Keyset keyset;
- AddKeyData(*Registry::NewKeyData(AeadKeyTemplates::Aes128Gcm()).ValueOrDie(),
+ AddKeyData(*Registry::NewKeyData(AeadKeyTemplates::Aes128Gcm()).value(),
/*key_id=*/0, google::crypto::tink::OutputPrefixType::TINK,
KeyStatusType::ENABLED, &keyset);
keyset.set_primary_key_id(0);
@@ -565,7 +560,7 @@
TEST_F(KeysetHandleTest, GetPrimitiveCustomKeyManager) {
auto handle_result = KeysetHandle::GenerateNew(AeadKeyTemplates::Aes128Gcm());
ASSERT_TRUE(handle_result.ok()) << handle_result.status();
- std::unique_ptr<KeysetHandle> handle = std::move(handle_result.ValueOrDie());
+ std::unique_ptr<KeysetHandle> handle = std::move(handle_result.value());
Registry::Reset();
ASSERT_TRUE(
Registry::RegisterPrimitiveWrapper(absl::make_unique<AeadWrapper>())
@@ -583,7 +578,7 @@
TEST_F(KeysetHandleTest, Copiable) {
auto handle_result = KeysetHandle::GenerateNew(AeadKeyTemplates::Aes128Eax());
ASSERT_TRUE(handle_result.ok()) << handle_result.status();
- std::unique_ptr<KeysetHandle> handle = std::move(handle_result.ValueOrDie());
+ std::unique_ptr<KeysetHandle> handle = std::move(handle_result.value());
KeysetHandle handle_copy = *handle;
}
@@ -597,7 +592,7 @@
keyset.set_primary_key_id(42);
auto handle_result = KeysetHandle::ReadNoSecret(keyset.SerializeAsString());
ASSERT_THAT(handle_result.status(), IsOk());
- std::unique_ptr<KeysetHandle>& keyset_handle = handle_result.ValueOrDie();
+ std::unique_ptr<KeysetHandle>& keyset_handle = handle_result.value();
const Keyset& result = CleartextKeysetHandle::GetKeyset(*keyset_handle);
// We check that result equals keyset. For lack of a better method we do this
@@ -679,7 +674,7 @@
std::stringbuf buffer;
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer =
- test::DummyKeysetWriter::New(std::move(destination_stream)).ValueOrDie();
+ test::DummyKeysetWriter::New(std::move(destination_stream)).value();
auto result = handle->WriteNoSecret(writer.get());
EXPECT_TRUE(result.ok());
}
@@ -696,7 +691,7 @@
std::stringbuf buffer;
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer =
- test::DummyKeysetWriter::New(std::move(destination_stream)).ValueOrDie();
+ test::DummyKeysetWriter::New(std::move(destination_stream)).value();
auto result = handle->WriteNoSecret(writer.get());
EXPECT_FALSE(result.ok());
}
@@ -713,7 +708,7 @@
std::stringbuf buffer;
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer =
- test::DummyKeysetWriter::New(std::move(destination_stream)).ValueOrDie();
+ test::DummyKeysetWriter::New(std::move(destination_stream)).value();
auto result = handle->WriteNoSecret(writer.get());
EXPECT_FALSE(result.ok());
}
@@ -730,7 +725,7 @@
std::stringbuf buffer;
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer =
- test::DummyKeysetWriter::New(std::move(destination_stream)).ValueOrDie();
+ test::DummyKeysetWriter::New(std::move(destination_stream)).value();
auto result = handle->WriteNoSecret(writer.get());
EXPECT_FALSE(result.ok());
}
@@ -758,7 +753,7 @@
std::stringbuf buffer;
std::unique_ptr<std::ostream> destination_stream(new std::ostream(&buffer));
auto writer =
- test::DummyKeysetWriter::New(std::move(destination_stream)).ValueOrDie();
+ test::DummyKeysetWriter::New(std::move(destination_stream)).value();
auto result = handle->WriteNoSecret(writer.get());
EXPECT_FALSE(result.ok());
}
diff --git a/cc/core/keyset_manager_test.cc b/cc/core/keyset_manager_test.cc
index 696bdb4..e60838e 100644
--- a/cc/core/keyset_manager_test.cc
+++ b/cc/core/keyset_manager_test.cc
@@ -57,7 +57,7 @@
// Create a keyset manager with a single key.
auto new_result = KeysetManager::New(key_template);
EXPECT_TRUE(new_result.ok()) << new_result.status();
- auto keyset_manager = std::move(new_result.ValueOrDie());
+ auto keyset_manager = std::move(new_result.value());
EXPECT_EQ(1, keyset_manager->KeyCount());
// Verify the keyset.
@@ -77,7 +77,7 @@
auto add_result = keyset_manager->Add(key_template);
EXPECT_TRUE(add_result.ok()) << add_result.status();
EXPECT_EQ(2, keyset_manager->KeyCount());
- auto key_id_1 = add_result.ValueOrDie();
+ auto key_id_1 = add_result.value();
keyset = TestKeysetHandle::GetKeyset(*(keyset_manager->GetKeysetHandle()));
EXPECT_EQ(2, keyset.key().size());
EXPECT_EQ(key_id_0, keyset.primary_key_id());
@@ -94,7 +94,7 @@
auto rotate_result = keyset_manager->Rotate(key_template);
EXPECT_TRUE(rotate_result.ok()) << add_result.status();
EXPECT_EQ(3, keyset_manager->KeyCount());
- auto key_id_2 = rotate_result.ValueOrDie();
+ auto key_id_2 = rotate_result.value();
keyset = TestKeysetHandle::GetKeyset(*(keyset_manager->GetKeysetHandle()));
EXPECT_EQ(3, keyset.key().size());
EXPECT_EQ(key_id_2, keyset.primary_key_id());
@@ -117,8 +117,8 @@
EXPECT_EQ(key_id_1, keyset.primary_key_id());
// Clone a keyset via the manager, and check equality.
- auto keyset_manager_2 = std::move(
- KeysetManager::New(*keyset_manager->GetKeysetHandle()).ValueOrDie());
+ auto keyset_manager_2 =
+ std::move(KeysetManager::New(*keyset_manager->GetKeysetHandle()).value());
auto keyset_2 =
TestKeysetHandle::GetKeyset(*(keyset_manager_2->GetKeysetHandle()));
EXPECT_EQ(keyset.SerializeAsString(), keyset_2.SerializeAsString());
diff --git a/cc/core/kms_clients_test.cc b/cc/core/kms_clients_test.cc
index 45fd2e6..b150ab6 100644
--- a/cc/core/kms_clients_test.cc
+++ b/cc/core/kms_clients_test.cc
@@ -65,8 +65,8 @@
EXPECT_THAT(status, IsOk());
auto client_result = KmsClients::Get(data_1.uri);
EXPECT_THAT(client_result.status(), IsOk());
- EXPECT_TRUE(client_result.ValueOrDie()->DoesSupport(data_1.uri));
- EXPECT_FALSE(client_result.ValueOrDie()->DoesSupport(data_2.uri));
+ EXPECT_TRUE(client_result.value()->DoesSupport(data_1.uri));
+ EXPECT_FALSE(client_result.value()->DoesSupport(data_2.uri));
// Verify there is no client for data_2.
client_result = KmsClients::Get(data_2.uri);
@@ -78,9 +78,8 @@
EXPECT_THAT(status, IsOk());
client_result = KmsClients::Get(data_2.uri);
EXPECT_THAT(client_result.status(), IsOk());
- EXPECT_TRUE(client_result.ValueOrDie()->DoesSupport(data_2.uri));
- EXPECT_FALSE(client_result.ValueOrDie()->DoesSupport(data_1.uri));
-
+ EXPECT_TRUE(client_result.value()->DoesSupport(data_2.uri));
+ EXPECT_FALSE(client_result.value()->DoesSupport(data_1.uri));
// Verify there is no client for data_3.
client_result = KmsClients::Get(data_3.uri);
@@ -92,20 +91,20 @@
EXPECT_THAT(status, IsOk());
client_result = KmsClients::Get(data_3.uri);
EXPECT_THAT(client_result.status(), IsOk());
- EXPECT_TRUE(client_result.ValueOrDie()->DoesSupport(data_3.uri));
- EXPECT_FALSE(client_result.ValueOrDie()->DoesSupport(data_2.uri));
- EXPECT_FALSE(client_result.ValueOrDie()->DoesSupport(data_1.uri));
+ EXPECT_TRUE(client_result.value()->DoesSupport(data_3.uri));
+ EXPECT_FALSE(client_result.value()->DoesSupport(data_2.uri));
+ EXPECT_FALSE(client_result.value()->DoesSupport(data_1.uri));
// Verify that clients for data_1 and data_2 are still present.
client_result = KmsClients::Get(data_1.uri);
EXPECT_THAT(client_result.status(), IsOk());
- EXPECT_TRUE(client_result.ValueOrDie()->DoesSupport(data_1.uri));
- EXPECT_FALSE(client_result.ValueOrDie()->DoesSupport(data_2.uri));
+ EXPECT_TRUE(client_result.value()->DoesSupport(data_1.uri));
+ EXPECT_FALSE(client_result.value()->DoesSupport(data_2.uri));
client_result = KmsClients::Get(data_2.uri);
EXPECT_THAT(client_result.status(), IsOk());
- EXPECT_TRUE(client_result.ValueOrDie()->DoesSupport(data_2.uri));
- EXPECT_FALSE(client_result.ValueOrDie()->DoesSupport(data_1.uri));
+ EXPECT_TRUE(client_result.value()->DoesSupport(data_2.uri));
+ EXPECT_FALSE(client_result.value()->DoesSupport(data_1.uri));
}
diff --git a/cc/core/primitive_set_test.cc b/cc/core/primitive_set_test.cc
index 161e5c4..94c936c 100644
--- a/cc/core/primitive_set_test.cc
+++ b/cc/core/primitive_set_test.cc
@@ -68,10 +68,10 @@
key_info.set_output_prefix_type(OutputPrefixType::TINK);
key_info.set_key_id(key_id);
key_info.set_status(KeyStatusType::ENABLED);
- std::string prefix = CryptoFormat::GetOutputPrefix(key_info).ValueOrDie();
+ std::string prefix = CryptoFormat::GetOutputPrefix(key_info).value();
auto get_result = primitive_set->get_primitives(prefix);
EXPECT_TRUE(get_result.ok()) << get_result.status();
- EXPECT_GE(get_result.ValueOrDie()->size(), 1);
+ EXPECT_GE(get_result.value()->size(), 1);
}
}
@@ -99,10 +99,10 @@
key_info.set_output_prefix_type(OutputPrefixType::TINK);
key_info.set_key_id(key_id);
key_info.set_status(KeyStatusType::ENABLED);
- std::string prefix = CryptoFormat::GetOutputPrefix(key_info).ValueOrDie();
+ std::string prefix = CryptoFormat::GetOutputPrefix(key_info).value();
auto get_result = mac_set.get_primitives(prefix);
EXPECT_TRUE(get_result.ok()) << get_result.status();
- auto macs = get_result.ValueOrDie();
+ auto macs = get_result.value();
if (key_id >= offset_b && key_id < offset_a + count) {
EXPECT_EQ(2, macs->size()); // overlapping key_id range
} else {
@@ -178,8 +178,7 @@
add_primitive_result = primitive_set.AddPrimitive(std::move(mac_3), key_3);
EXPECT_TRUE(add_primitive_result.ok()) << add_primitive_result.status();
- EXPECT_THAT(primitive_set.set_primary(add_primitive_result.ValueOrDie()),
- IsOk());
+ EXPECT_THAT(primitive_set.set_primary(add_primitive_result.value()), IsOk());
add_primitive_result = primitive_set.AddPrimitive(std::move(mac_4), key_4);
EXPECT_TRUE(add_primitive_result.ok()) << add_primitive_result.status();
@@ -202,58 +201,58 @@
auto primary = primitive_set.get_primary();
EXPECT_FALSE(primary == nullptr);
EXPECT_EQ(KeyStatusType::ENABLED, primary->get_status());
- EXPECT_EQ(DummyMac(mac_name_3).ComputeMac(data).ValueOrDie(),
- primary->get_primitive().ComputeMac(data).ValueOrDie());
+ EXPECT_EQ(DummyMac(mac_name_3).ComputeMac(data).value(),
+ primary->get_primitive().ComputeMac(data).value());
}
{ // Check raw primitives.
- auto& primitives = *(primitive_set.get_raw_primitives().ValueOrDie());
+ auto& primitives = *(primitive_set.get_raw_primitives().value());
EXPECT_EQ(2, primitives.size());
- EXPECT_EQ(DummyMac(mac_name_4).ComputeMac(data).ValueOrDie(),
- primitives[0]->get_primitive().ComputeMac(data).ValueOrDie());
+ EXPECT_EQ(DummyMac(mac_name_4).ComputeMac(data).value(),
+ primitives[0]->get_primitive().ComputeMac(data).value());
EXPECT_EQ(KeyStatusType::ENABLED, primitives[0]->get_status());
EXPECT_EQ(key_4.key_id(), primitives[0]->get_key_id());
EXPECT_EQ(OutputPrefixType::RAW, primitives[0]->get_output_prefix_type());
- EXPECT_EQ(DummyMac(mac_name_5).ComputeMac(data).ValueOrDie(),
- primitives[1]->get_primitive().ComputeMac(data).ValueOrDie());
+ EXPECT_EQ(DummyMac(mac_name_5).ComputeMac(data).value(),
+ primitives[1]->get_primitive().ComputeMac(data).value());
EXPECT_EQ(KeyStatusType::ENABLED, primitives[1]->get_status());
EXPECT_EQ(key_5.key_id(), primitives[1]->get_key_id());
EXPECT_EQ(OutputPrefixType::RAW, primitives[1]->get_output_prefix_type());
}
{ // Check Tink primitives.
- std::string prefix = CryptoFormat::GetOutputPrefix(key_1).ValueOrDie();
- auto& primitives = *(primitive_set.get_primitives(prefix).ValueOrDie());
+ std::string prefix = CryptoFormat::GetOutputPrefix(key_1).value();
+ auto& primitives = *(primitive_set.get_primitives(prefix).value());
EXPECT_EQ(2, primitives.size());
- EXPECT_EQ(DummyMac(mac_name_1).ComputeMac(data).ValueOrDie(),
- primitives[0]->get_primitive().ComputeMac(data).ValueOrDie());
+ EXPECT_EQ(DummyMac(mac_name_1).ComputeMac(data).value(),
+ primitives[0]->get_primitive().ComputeMac(data).value());
EXPECT_EQ(KeyStatusType::ENABLED, primitives[0]->get_status());
EXPECT_EQ(key_1.key_id(), primitives[0]->get_key_id());
EXPECT_EQ(OutputPrefixType::TINK, primitives[0]->get_output_prefix_type());
- EXPECT_EQ(DummyMac(mac_name_6).ComputeMac(data).ValueOrDie(),
- primitives[1]->get_primitive().ComputeMac(data).ValueOrDie());
+ EXPECT_EQ(DummyMac(mac_name_6).ComputeMac(data).value(),
+ primitives[1]->get_primitive().ComputeMac(data).value());
EXPECT_EQ(KeyStatusType::ENABLED, primitives[1]->get_status());
EXPECT_EQ(key_1.key_id(), primitives[1]->get_key_id());
EXPECT_EQ(OutputPrefixType::TINK, primitives[1]->get_output_prefix_type());
}
{ // Check another Tink primitive.
- std::string prefix = CryptoFormat::GetOutputPrefix(key_3).ValueOrDie();
- auto& primitives = *(primitive_set.get_primitives(prefix).ValueOrDie());
+ std::string prefix = CryptoFormat::GetOutputPrefix(key_3).value();
+ auto& primitives = *(primitive_set.get_primitives(prefix).value());
EXPECT_EQ(1, primitives.size());
- EXPECT_EQ(DummyMac(mac_name_3).ComputeMac(data).ValueOrDie(),
- primitives[0]->get_primitive().ComputeMac(data).ValueOrDie());
+ EXPECT_EQ(DummyMac(mac_name_3).ComputeMac(data).value(),
+ primitives[0]->get_primitive().ComputeMac(data).value());
EXPECT_EQ(KeyStatusType::ENABLED, primitives[0]->get_status());
EXPECT_EQ(key_3.key_id(), primitives[0]->get_key_id());
EXPECT_EQ(OutputPrefixType::TINK, primitives[0]->get_output_prefix_type());
}
{ // Check legacy primitive.
- std::string prefix = CryptoFormat::GetOutputPrefix(key_2).ValueOrDie();
- auto& primitives = *(primitive_set.get_primitives(prefix).ValueOrDie());
+ std::string prefix = CryptoFormat::GetOutputPrefix(key_2).value();
+ auto& primitives = *(primitive_set.get_primitives(prefix).value());
EXPECT_EQ(1, primitives.size());
- EXPECT_EQ(DummyMac(mac_name_2).ComputeMac(data).ValueOrDie(),
- primitives[0]->get_primitive().ComputeMac(data).ValueOrDie());
+ EXPECT_EQ(DummyMac(mac_name_2).ComputeMac(data).value(),
+ primitives[0]->get_primitive().ComputeMac(data).value());
EXPECT_EQ(KeyStatusType::ENABLED, primitives[0]->get_status());
EXPECT_EQ(key_2.key_id(), primitives[0]->get_key_id());
EXPECT_EQ(OutputPrefixType::LEGACY,
@@ -287,12 +286,12 @@
auto add_primitive_result =
primitive_set.AddPrimitive(std::move(mac_1), key_info_1);
EXPECT_TRUE(add_primitive_result.ok()) << add_primitive_result.status();
- ASSERT_THAT(primitive_set.set_primary(add_primitive_result.ValueOrDie()),
+ ASSERT_THAT(primitive_set.set_primary(add_primitive_result.value()),
IsOk());
std::string identifier = "";
const auto& primitives =
- *(primitive_set.get_primitives(identifier).ValueOrDie());
+ *(primitive_set.get_primitives(identifier).value());
EXPECT_EQ(1, primitives.size());
EXPECT_EQ(primitive_set.get_primary(), primitives[0].get());
@@ -316,13 +315,12 @@
auto add_primitive_result =
primitive_set.AddPrimitive(std::move(mac_1), key_info_1);
EXPECT_TRUE(add_primitive_result.ok()) << add_primitive_result.status();
- ASSERT_THAT(primitive_set.set_primary(add_primitive_result.ValueOrDie()),
+ ASSERT_THAT(primitive_set.set_primary(add_primitive_result.value()),
IsOk());
- std::string identifier =
- CryptoFormat::GetOutputPrefix(key_info_1).ValueOrDie();
+ std::string identifier = CryptoFormat::GetOutputPrefix(key_info_1).value();
const auto& primitives =
- *(primitive_set.get_primitives(identifier).ValueOrDie());
+ *(primitive_set.get_primitives(identifier).value());
EXPECT_EQ(1, primitives.size());
EXPECT_EQ(primitive_set.get_primary(), primitives[0].get());
@@ -346,13 +344,12 @@
auto add_primitive_result =
primitive_set.AddPrimitive(std::move(mac_1), key_info_1);
EXPECT_TRUE(add_primitive_result.ok()) << add_primitive_result.status();
- ASSERT_THAT(primitive_set.set_primary(add_primitive_result.ValueOrDie()),
+ ASSERT_THAT(primitive_set.set_primary(add_primitive_result.value()),
IsOk());
- std::string identifier =
- CryptoFormat::GetOutputPrefix(key_info_1).ValueOrDie();
+ std::string identifier = CryptoFormat::GetOutputPrefix(key_info_1).value();
const auto& primitives =
- *(primitive_set.get_primitives(identifier).ValueOrDie());
+ *(primitive_set.get_primitives(identifier).value());
EXPECT_EQ(1, primitives.size());
EXPECT_EQ(primitive_set.get_primary(), primitives[0].get());
@@ -410,7 +407,7 @@
absl::make_unique<DummyMac>("MAC3"),
CreateKey(0x02020202, OutputPrefixType::TINK, KeyStatusType::ENABLED));
ASSERT_THAT(entry_or.status(), IsOk());
- EXPECT_THAT(pset.set_primary(entry_or.ValueOrDie()), IsOk());
+ EXPECT_THAT(pset.set_primary(entry_or.value()), IsOk());
EXPECT_THAT(pset.AddPrimitive(absl::make_unique<DummyMac>("MAC4"),
CreateKey(0x02020202, OutputPrefixType::RAW,
@@ -428,7 +425,7 @@
for (auto* entry : pset.get_all()) {
auto mac_or = entry->get_primitive().ComputeMac("");
ASSERT_THAT(mac_or.status(), IsOk());
- mac_and_id.push_back({mac_or.ValueOrDie(), entry->get_identifier()});
+ mac_and_id.push_back({mac_or.value(), entry->get_identifier()});
}
// In the following id part, the first byte is 1 for Tink.
diff --git a/cc/core/private_key_manager_impl.h b/cc/core/private_key_manager_impl.h
index d855777..5d2d6ae 100644
--- a/cc/core/private_key_manager_impl.h
+++ b/cc/core/private_key_manager_impl.h
@@ -84,7 +84,7 @@
private_key_manager_->GetPublicKey(private_key);
if (!public_key_result.ok()) return public_key_result.status();
key_data->set_type_url(public_key_type_);
- key_data->set_value(public_key_result.ValueOrDie().SerializeAsString());
+ key_data->set_value(public_key_result.value().SerializeAsString());
key_data->set_key_material_type(public_key_material_type_);
return std::move(key_data);
}
diff --git a/cc/core/private_key_manager_impl_test.cc b/cc/core/private_key_manager_impl_test.cc
index c8970ef..512531e 100644
--- a/cc/core/private_key_manager_impl_test.cc
+++ b/cc/core/private_key_manager_impl_test.cc
@@ -145,7 +145,7 @@
EcdsaKeyFormat key_format;
key_format.mutable_params()->set_encoding(EcdsaSignatureEncoding::DER);
- auto key = key_manager->get_key_factory().NewKey(key_format).ValueOrDie();
+ auto key = key_manager->get_key_factory().NewKey(key_format).value();
EXPECT_THAT(
dynamic_cast<EcdsaPrivateKey&>(*key).public_key().params().encoding(),
Eq(EcdsaSignatureEncoding::DER));
@@ -164,7 +164,7 @@
auto key_data =
dynamic_cast<const PrivateKeyFactory&>(key_manager->get_key_factory())
.GetPublicKeyData(private_key.SerializeAsString())
- .ValueOrDie();
+ .value();
ASSERT_THAT(key_data->type_url(), Eq(public_km.get_key_type()));
EcdsaPublicKey public_key;
public_key.ParseFromString(key_data->value());
@@ -201,7 +201,7 @@
EcdsaKeyFormat key_format;
key_format.mutable_params()->set_encoding(EcdsaSignatureEncoding::DER);
- auto key = key_manager->get_key_factory().NewKey(key_format).ValueOrDie();
+ auto key = key_manager->get_key_factory().NewKey(key_format).value();
EXPECT_THAT(
dynamic_cast<EcdsaPrivateKey&>(*key).public_key().params().encoding(),
Eq(EcdsaSignatureEncoding::DER));
diff --git a/cc/daead/aes_siv_key_manager.h b/cc/daead/aes_siv_key_manager.h
index 930f8d4..4d2429c 100644
--- a/cc/daead/aes_siv_key_manager.h
+++ b/cc/daead/aes_siv_key_manager.h
@@ -104,7 +104,7 @@
}
google::crypto::tink::AesSivKey key;
key.set_version(get_version());
- key.set_key_value(randomness.ValueOrDie());
+ key.set_key_value(randomness.value());
return key;
}
diff --git a/cc/daead/aes_siv_key_manager_test.cc b/cc/daead/aes_siv_key_manager_test.cc
index 1e1eec5..b0e2411 100644
--- a/cc/daead/aes_siv_key_manager_test.cc
+++ b/cc/daead/aes_siv_key_manager_test.cc
@@ -85,8 +85,8 @@
format.set_key_size(64);
auto key_or = AesSivKeyManager().CreateKey(format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(), SizeIs(format.key_size()));
- EXPECT_THAT(key_or.ValueOrDie().version(), Eq(0));
+ EXPECT_THAT(key_or.value().key_value(), SizeIs(format.key_size()));
+ EXPECT_THAT(key_or.value().version(), Eq(0));
}
TEST(AesSivKeyManagerTest, CreateKeyIsValid) {
@@ -94,7 +94,7 @@
format.set_key_size(64);
auto key_or = AesSivKeyManager().CreateKey(format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(AesSivKeyManager().ValidateKey(key_or.ValueOrDie()), IsOk());
+ EXPECT_THAT(AesSivKeyManager().ValidateKey(key_or.value()), IsOk());
}
TEST(AesSivKeyManagerTest, MultipleCreateCallsCreateDifferentKeys) {
@@ -105,8 +105,7 @@
ASSERT_THAT(key1_or.status(), IsOk());
auto key2_or = manager.CreateKey(format);
ASSERT_THAT(key2_or.status(), IsOk());
- EXPECT_THAT(key1_or.ValueOrDie().key_value(),
- Ne(key2_or.ValueOrDie().key_value()));
+ EXPECT_THAT(key1_or.value().key_value(), Ne(key2_or.value().key_value()));
}
TEST(AesSivKeyManagerTest, DeriveKey) {
@@ -118,8 +117,8 @@
auto key_or = AesSivKeyManager().DeriveKey(format, &input_stream);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(), SizeIs(64));
- EXPECT_THAT(key_or.ValueOrDie().version(), Eq(0));
+ EXPECT_THAT(key_or.value().key_value(), SizeIs(64));
+ EXPECT_THAT(key_or.value().version(), Eq(0));
}
TEST(AesSivKeyManagerTest, DeriveKeyFromLongSeed) {
@@ -133,7 +132,7 @@
ASSERT_THAT(key_or.status(), IsOk());
EXPECT_THAT(
- key_or.ValueOrDie().key_value(),
+ key_or.value().key_value(),
Eq("0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"));
}
@@ -193,21 +192,20 @@
auto key_or = AesSivKeyManager().CreateKey(format);
ASSERT_THAT(key_or.status(), IsOk());
auto daead_or =
- AesSivKeyManager().GetPrimitive<DeterministicAead>(key_or.ValueOrDie());
+ AesSivKeyManager().GetPrimitive<DeterministicAead>(key_or.value());
ASSERT_THAT(daead_or.status(), IsOk());
auto direct_daead_or = subtle::AesSivBoringSsl::New(
- util::SecretDataFromStringView(key_or.ValueOrDie().key_value()));
+ util::SecretDataFromStringView(key_or.value().key_value()));
ASSERT_THAT(direct_daead_or.status(), IsOk());
auto encryption_or =
- daead_or.ValueOrDie()->EncryptDeterministically("123", "abcd");
+ daead_or.value()->EncryptDeterministically("123", "abcd");
ASSERT_THAT(encryption_or.status(), IsOk());
auto direct_encryption_or =
- direct_daead_or.ValueOrDie()->EncryptDeterministically("123", "abcd");
+ direct_daead_or.value()->EncryptDeterministically("123", "abcd");
ASSERT_THAT(direct_encryption_or.status(), IsOk());
- ASSERT_THAT(encryption_or.ValueOrDie(),
- Eq(direct_encryption_or.ValueOrDie()));
+ ASSERT_THAT(encryption_or.value(), Eq(direct_encryption_or.value()));
}
} // namespace
diff --git a/cc/daead/deterministic_aead_config_test.cc b/cc/daead/deterministic_aead_config_test.cc
index fc280cd..1a59d14 100644
--- a/cc/daead/deterministic_aead_config_test.cc
+++ b/cc/daead/deterministic_aead_config_test.cc
@@ -82,24 +82,24 @@
primitive_set
->AddPrimitive(absl::make_unique<DummyDeterministicAead>("dummy"),
key_info)
- .ValueOrDie()),
+ .value()),
IsOk());
auto registry_wrapped = Registry::Wrap(std::move(primitive_set));
ASSERT_TRUE(registry_wrapped.ok()) << registry_wrapped.status();
auto encryption_result =
- registry_wrapped.ValueOrDie()->EncryptDeterministically("secret", "");
+ registry_wrapped.value()->EncryptDeterministically("secret", "");
ASSERT_TRUE(encryption_result.ok());
auto decryption_result =
DummyDeterministicAead("dummy").DecryptDeterministically(
- encryption_result.ValueOrDie(), "");
+ encryption_result.value(), "");
ASSERT_TRUE(decryption_result.status().ok());
- EXPECT_THAT(decryption_result.ValueOrDie(), Eq("secret"));
+ EXPECT_THAT(decryption_result.value(), Eq("secret"));
decryption_result = DummyDeterministicAead("dummy").DecryptDeterministically(
- encryption_result.ValueOrDie(), "wrong");
+ encryption_result.value(), "wrong");
EXPECT_FALSE(decryption_result.status().ok());
}
diff --git a/cc/daead/deterministic_aead_factory_test.cc b/cc/daead/deterministic_aead_factory_test.cc
index a2d8126..78cc363 100644
--- a/cc/daead/deterministic_aead_factory_test.cc
+++ b/cc/daead/deterministic_aead_factory_test.cc
@@ -70,17 +70,17 @@
// Prepare a Keyset.
Keyset keyset;
uint32_t key_id_1 = 1234543;
- auto new_key = std::move(key_factory.NewKey(key_format).ValueOrDie());
+ auto new_key = std::move(key_factory.NewKey(key_format).value());
AddTinkKey(key_type, key_id_1, *new_key, KeyStatusType::ENABLED,
KeyData::SYMMETRIC, &keyset);
uint32_t key_id_2 = 726329;
- new_key = std::move(key_factory.NewKey(key_format).ValueOrDie());
+ new_key = std::move(key_factory.NewKey(key_format).value());
AddRawKey(key_type, key_id_2, *new_key, KeyStatusType::ENABLED,
KeyData::SYMMETRIC, &keyset);
uint32_t key_id_3 = 7213743;
- new_key = std::move(key_factory.NewKey(key_format).ValueOrDie());
+ new_key = std::move(key_factory.NewKey(key_format).value());
AddTinkKey(key_type, key_id_3, *new_key, KeyStatusType::ENABLED,
KeyData::SYMMETRIC, &keyset);
@@ -93,7 +93,7 @@
auto daead_result = DeterministicAeadFactory::GetPrimitive(
*TestKeysetHandle::GetKeysetHandle(keyset));
EXPECT_TRUE(daead_result.ok()) << daead_result.status();
- auto daead = std::move(daead_result.ValueOrDie());
+ auto daead = std::move(daead_result.value());
// Test the resulting DeterministicAead-instance.
std::string plaintext = "some_plaintext";
@@ -101,14 +101,14 @@
auto encrypt_result = daead->EncryptDeterministically(plaintext, aad);
EXPECT_TRUE(encrypt_result.ok()) << encrypt_result.status();
- std::string ciphertext = encrypt_result.ValueOrDie();
+ std::string ciphertext = encrypt_result.value();
std::string prefix =
- CryptoFormat::GetOutputPrefix(KeyInfoFromKey(keyset.key(2))).ValueOrDie();
+ CryptoFormat::GetOutputPrefix(KeyInfoFromKey(keyset.key(2))).value();
EXPECT_PRED_FORMAT2(testing::IsSubstring, prefix, ciphertext);
auto decrypt_result = daead->DecryptDeterministically(ciphertext, aad);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
decrypt_result = daead->DecryptDeterministically("some bad ciphertext", aad);
EXPECT_FALSE(decrypt_result.ok());
@@ -119,13 +119,13 @@
// Create raw ciphertext with 2nd key, and decrypt
// with DeterministicAead-instance.
- auto raw_daead = std::move(
- key_manager->GetPrimitive(keyset.key(1).key_data()).ValueOrDie());
+ auto raw_daead =
+ std::move(key_manager->GetPrimitive(keyset.key(1).key_data()).value());
std::string raw_ciphertext =
- raw_daead->EncryptDeterministically(plaintext, aad).ValueOrDie();
+ raw_daead->EncryptDeterministically(plaintext, aad).value();
decrypt_result = daead->DecryptDeterministically(ciphertext, aad);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
}
} // namespace
diff --git a/cc/daead/deterministic_aead_wrapper.cc b/cc/daead/deterministic_aead_wrapper.cc
index 685850d..f72edaf 100644
--- a/cc/daead/deterministic_aead_wrapper.cc
+++ b/cc/daead/deterministic_aead_wrapper.cc
@@ -77,7 +77,7 @@
plaintext, associated_data);
if (!encrypt_result.ok()) return encrypt_result.status();
const std::string& key_id = daead_set_->get_primary()->get_identifier();
- return key_id + encrypt_result.ValueOrDie();
+ return key_id + encrypt_result.value();
}
util::StatusOr<std::string>
@@ -94,12 +94,12 @@
if (primitives_result.ok()) {
absl::string_view raw_ciphertext =
ciphertext.substr(CryptoFormat::kNonRawPrefixSize);
- for (auto& daead_entry : *(primitives_result.ValueOrDie())) {
+ for (auto& daead_entry : *(primitives_result.value())) {
DeterministicAead& daead = daead_entry->get_primitive();
auto decrypt_result =
daead.DecryptDeterministically(raw_ciphertext, associated_data);
if (decrypt_result.ok()) {
- return std::move(decrypt_result.ValueOrDie());
+ return std::move(decrypt_result.value());
} else {
// LOG that a matching key didn't decrypt the ciphertext.
}
@@ -110,12 +110,12 @@
// No matching key succeeded with decryption, try all RAW keys.
auto raw_primitives_result = daead_set_->get_raw_primitives();
if (raw_primitives_result.ok()) {
- for (auto& daead_entry : *(raw_primitives_result.ValueOrDie())) {
+ for (auto& daead_entry : *(raw_primitives_result.value())) {
DeterministicAead& daead = daead_entry->get_primitive();
auto decrypt_result =
daead.DecryptDeterministically(ciphertext, associated_data);
if (decrypt_result.ok()) {
- return std::move(decrypt_result.ValueOrDie());
+ return std::move(decrypt_result.value());
}
}
}
diff --git a/cc/daead/deterministic_aead_wrapper_test.cc b/cc/daead/deterministic_aead_wrapper_test.cc
index e268d65..327ac13 100644
--- a/cc/daead/deterministic_aead_wrapper_test.cc
+++ b/cc/daead/deterministic_aead_wrapper_test.cc
@@ -108,24 +108,24 @@
daead_set->AddPrimitive(std::move(daead), keyset_info.key_info(2));
ASSERT_TRUE(entry_result.ok());
// The last key is the primary.
- ASSERT_THAT(daead_set->set_primary(entry_result.ValueOrDie()), IsOk());
+ ASSERT_THAT(daead_set->set_primary(entry_result.value()), IsOk());
// Wrap daead_set and test the resulting DeterministicAead.
auto daead_result =
DeterministicAeadWrapper().Wrap(std::move(daead_set));
EXPECT_TRUE(daead_result.ok()) << daead_result.status();
- daead = std::move(daead_result.ValueOrDie());
+ daead = std::move(daead_result.value());
std::string plaintext = "some_plaintext";
std::string aad = "some_aad";
auto encrypt_result = daead->EncryptDeterministically(plaintext, aad);
EXPECT_TRUE(encrypt_result.ok()) << encrypt_result.status();
- std::string ciphertext = encrypt_result.ValueOrDie();
+ std::string ciphertext = encrypt_result.value();
EXPECT_PRED_FORMAT2(testing::IsSubstring, daead_name_2, ciphertext);
auto decrypt_result = daead->DecryptDeterministically(ciphertext, aad);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
decrypt_result =
daead->DecryptDeterministically("some bad ciphertext", aad);
diff --git a/cc/daead/subtle/aead_or_daead_test.cc b/cc/daead/subtle/aead_or_daead_test.cc
index d407f1a..8244b72 100644
--- a/cc/daead/subtle/aead_or_daead_test.cc
+++ b/cc/daead/subtle/aead_or_daead_test.cc
@@ -41,9 +41,9 @@
aead_or_daead.Encrypt(message, associated_data);
if (!encryption_or.status().ok()) return encryption_or.status();
StatusOr<std::string> decryption_or =
- aead_or_daead.Decrypt(encryption_or.ValueOrDie(), associated_data);
+ aead_or_daead.Decrypt(encryption_or.value(), associated_data);
if (!decryption_or.status().ok()) return decryption_or.status();
- if (decryption_or.ValueOrDie() != message) {
+ if (decryption_or.value() != message) {
return crypto::tink::util::Status(absl::StatusCode::kInternal,
"Message/Decryption mismatch");
}
diff --git a/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_dem_helper.cc b/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_dem_helper.cc
index 8393ce7..043899e 100644
--- a/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_dem_helper.cc
+++ b/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_dem_helper.cc
@@ -61,11 +61,11 @@
auto key_or = internal::RegistryImpl::GlobalInstance().DeriveKey(
key_template_, &input_stream);
if (!key_or.ok()) return key_or.status();
- auto key = std::move(key_or).ValueOrDie();
+ auto key = std::move(key_or).value();
util::StatusOr<std::unique_ptr<EncryptionPrimitive>> primitive_or =
Registry::GetPrimitive<EncryptionPrimitive>(key);
if (!primitive_or.ok()) return primitive_or.status();
- return absl::make_unique<AeadOrDaead>(std::move(primitive_or.ValueOrDie()));
+ return absl::make_unique<AeadOrDaead>(std::move(primitive_or.value()));
}
crypto::tink::util::StatusOr<uint32_t> GetKeyMaterialSize() const override {
diff --git a/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_dem_helper_test.cc b/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_dem_helper_test.cc
index 51dfedf..dc73408 100644
--- a/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_dem_helper_test.cc
+++ b/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_dem_helper_test.cc
@@ -48,9 +48,9 @@
StatusOr<std::string> encryption_or = dem.Encrypt(message, associated_data);
if (!encryption_or.status().ok()) return encryption_or.status();
StatusOr<std::string> decryption_or =
- dem.Decrypt(encryption_or.ValueOrDie(), associated_data);
+ dem.Decrypt(encryption_or.value(), associated_data);
if (!decryption_or.status().ok()) return decryption_or.status();
- if (decryption_or.ValueOrDie() != message) {
+ if (decryption_or.value() != message) {
return crypto::tink::util::Status(absl::StatusCode::kInternal,
"Message/Decryption mismatch");
}
@@ -80,7 +80,7 @@
auto dem_helper_or = Cecpq2AeadHkdfDemHelper::New(dem_key_template);
ASSERT_THAT(dem_helper_or.status(), IsOk());
- auto dem_helper = std::move(dem_helper_or.ValueOrDie());
+ auto dem_helper = std::move(dem_helper_or.value());
util::SecretData seed_32_bytes = util::SecretDataFromStringView(
test::HexDecodeOrDie("000102030405060708090a0b0c0d0e0f"
@@ -89,7 +89,7 @@
dem_helper->GetAeadOrDaead(seed_32_bytes);
ASSERT_THAT(aead_or_daead_result_or.status(), IsOk());
- auto aead_or_daead = std::move(aead_or_daead_result_or.ValueOrDie());
+ auto aead_or_daead = std::move(aead_or_daead_result_or.value());
EXPECT_THAT(EncryptThenDecrypt(*aead_or_daead, "test_plaintext", "test_ad"),
IsOk());
}
@@ -108,7 +108,7 @@
auto dem_helper_or = Cecpq2AeadHkdfDemHelper::New(dem_key_template);
ASSERT_THAT(dem_helper_or.status(), IsOk());
- auto dem_helper = std::move(dem_helper_or.ValueOrDie());
+ auto dem_helper = std::move(dem_helper_or.value());
util::SecretData seed_64_bytes = util::SecretDataFromStringView(
test::HexDecodeOrDie("000102030405060708090a0b0c0d0e0f"
@@ -119,7 +119,7 @@
dem_helper->GetAeadOrDaead(seed_64_bytes);
ASSERT_THAT(aead_or_daead_result_or.status(), IsOk());
- auto aead_or_daead = std::move(aead_or_daead_result_or.ValueOrDie());
+ auto aead_or_daead = std::move(aead_or_daead_result_or.value());
EXPECT_THAT(EncryptThenDecrypt(*aead_or_daead, "test_plaintext", "test_ad"),
IsOk());
}
@@ -137,7 +137,7 @@
auto dem_helper_or = Cecpq2AeadHkdfDemHelper::New(dem_key_template);
ASSERT_THAT(dem_helper_or.status(), IsOk());
- auto dem_helper = std::move(dem_helper_or.ValueOrDie());
+ auto dem_helper = std::move(dem_helper_or.value());
util::SecretData seed_32_bytes = util::SecretDataFromStringView(
test::HexDecodeOrDie("000102030405060708090a0b0c0d0e0f"
@@ -146,7 +146,7 @@
dem_helper->GetAeadOrDaead(seed_32_bytes);
ASSERT_THAT(aead_or_daead_result_or.status(), IsOk());
- auto aead_or_daead = std::move(aead_or_daead_result_or.ValueOrDie());
+ auto aead_or_daead = std::move(aead_or_daead_result_or.value());
EXPECT_THAT(EncryptThenDecrypt(*aead_or_daead, "test_plaintext", "test_ad"),
IsOk());
}
@@ -164,11 +164,11 @@
auto dem_helper_or = Cecpq2AeadHkdfDemHelper::New(dem_key_template);
ASSERT_THAT(dem_helper_or.status(), IsOk());
- auto dem_helper = std::move(dem_helper_or.ValueOrDie());
+ auto dem_helper = std::move(dem_helper_or.value());
auto key_material_size_or = dem_helper->GetKeyMaterialSize();
ASSERT_THAT(key_material_size_or.status(), IsOk());
- ASSERT_EQ(key_material_size_or.ValueOrDie(), 32);
+ ASSERT_EQ(key_material_size_or.value(), 32);
}
TEST(Cecpq2AeadHkdfDemHelperTest, DemHelperKeyMaterialAesGcm) {
@@ -184,11 +184,11 @@
auto dem_helper_or = Cecpq2AeadHkdfDemHelper::New(dem_key_template);
ASSERT_THAT(dem_helper_or.status(), IsOk());
- auto dem_helper = std::move(dem_helper_or.ValueOrDie());
+ auto dem_helper = std::move(dem_helper_or.value());
auto key_material_size_or = dem_helper->GetKeyMaterialSize();
ASSERT_THAT(key_material_size_or.status(), IsOk());
- ASSERT_EQ(key_material_size_or.ValueOrDie(), 32);
+ ASSERT_EQ(key_material_size_or.value(), 32);
}
TEST(Cecpq2AeadHkdfDemHelperTest, DemHelperKeyMaterialAesSiv) {
@@ -204,11 +204,11 @@
auto dem_helper_or = Cecpq2AeadHkdfDemHelper::New(dem_key_template);
ASSERT_THAT(dem_helper_or.status(), IsOk());
- auto dem_helper = std::move(dem_helper_or.ValueOrDie());
+ auto dem_helper = std::move(dem_helper_or.value());
auto key_material_size_or = dem_helper->GetKeyMaterialSize();
ASSERT_THAT(key_material_size_or.status(), IsOk());
- ASSERT_EQ(key_material_size_or.ValueOrDie(), 64);
+ ASSERT_EQ(key_material_size_or.value(), 64);
}
} // namespace
diff --git a/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_private_key_manager.cc b/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_private_key_manager.cc
index 3be8ea7..07434fe 100644
--- a/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_private_key_manager.cc
+++ b/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_private_key_manager.cc
@@ -60,7 +60,7 @@
auto cecpq2_key_pair_or =
pqc::GenerateCecpq2Keypair(subtle::EllipticCurveType::CURVE25519);
if (!cecpq2_key_pair_or.ok()) return cecpq2_key_pair_or.status();
- auto cecpq2_key_pair = std::move(cecpq2_key_pair_or.ValueOrDie());
+ auto cecpq2_key_pair = std::move(cecpq2_key_pair_or.value());
// Build Cecpq2AeadHkdfPrivateKey
Cecpq2AeadHkdfPrivateKey cecpq2_private_key;
diff --git a/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_private_key_manager_test.cc b/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_private_key_manager_test.cc
index 3eedcf2..fb89991 100644
--- a/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_private_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_private_key_manager_test.cc
@@ -122,7 +122,7 @@
ASSERT_THAT(Cecpq2AeadHkdfPrivateKeyManager().CreateKey(key_format).status(),
IsOk());
Cecpq2AeadHkdfPrivateKey key =
- Cecpq2AeadHkdfPrivateKeyManager().CreateKey(key_format).ValueOrDie();
+ Cecpq2AeadHkdfPrivateKeyManager().CreateKey(key_format).value();
EXPECT_THAT(key.public_key().params().kem_params().curve_type(),
Eq(key_format.params().kem_params().curve_type()));
EXPECT_THAT(key.public_key().params().kem_params().hkdf_hash_type(),
@@ -145,7 +145,7 @@
Cecpq2AeadHkdfPrivateKey CreateValidKey() {
return Cecpq2AeadHkdfPrivateKeyManager()
.CreateKey(CreateValidKeyFormat())
- .ValueOrDie();
+ .value();
}
TEST(Cecpq2AeadHkdfPrivateKeyManagerTest, ValidateKeyEmpty) {
@@ -211,7 +211,7 @@
ASSERT_THAT(Cecpq2AeadHkdfPrivateKeyManager().GetPublicKey(key).status(),
IsOk());
Cecpq2AeadHkdfPublicKey public_key =
- Cecpq2AeadHkdfPrivateKeyManager().GetPublicKey(key).ValueOrDie();
+ Cecpq2AeadHkdfPrivateKeyManager().GetPublicKey(key).value();
EXPECT_THAT(public_key.params().kem_params().curve_type(),
Eq(key.public_key().params().kem_params().curve_type()));
EXPECT_THAT(public_key.params().kem_params().hkdf_hash_type(),
@@ -237,7 +237,7 @@
Cecpq2AeadHkdfPrivateKey private_key = CreateValidKey();
Cecpq2AeadHkdfPublicKey public_key =
- Cecpq2AeadHkdfPrivateKeyManager().GetPublicKey(private_key).ValueOrDie();
+ Cecpq2AeadHkdfPrivateKeyManager().GetPublicKey(private_key).value();
auto decrypt_or =
Cecpq2AeadHkdfPrivateKeyManager().GetPrimitive<HybridDecrypt>(
@@ -248,12 +248,12 @@
std::string plaintext = "some text";
std::string context_info = "some aad";
- auto ciphertext = encrypt_or.ValueOrDie()->Encrypt(plaintext, context_info);
+ auto ciphertext = encrypt_or.value()->Encrypt(plaintext, context_info);
ASSERT_THAT(ciphertext.status(), IsOk());
auto decryption =
- decrypt_or.ValueOrDie()->Decrypt(ciphertext.ValueOrDie(), context_info);
+ decrypt_or.value()->Decrypt(ciphertext.value(), context_info);
ASSERT_THAT(decryption.status(), IsOk());
- ASSERT_EQ(decryption.ValueOrDie(), plaintext);
+ ASSERT_EQ(decryption.value(), plaintext);
}
TEST(Cecpq2AeadHkdfPrivateKeyManagerTest, CreateDifferentKey) {
@@ -263,9 +263,8 @@
Cecpq2AeadHkdfPrivateKey private_key = CreateValidKey();
// Note: we create a new private key in the next line.
- Cecpq2AeadHkdfPublicKey public_key = Cecpq2AeadHkdfPrivateKeyManager()
- .GetPublicKey(CreateValidKey())
- .ValueOrDie();
+ Cecpq2AeadHkdfPublicKey public_key =
+ Cecpq2AeadHkdfPrivateKeyManager().GetPublicKey(CreateValidKey()).value();
auto decrypt_or =
Cecpq2AeadHkdfPrivateKeyManager().GetPrimitive<HybridDecrypt>(
@@ -276,10 +275,10 @@
std::string plaintext = "some text";
std::string context_info = "some aad";
- auto ciphertext = encrypt_or.ValueOrDie()->Encrypt(plaintext, context_info);
+ auto ciphertext = encrypt_or.value()->Encrypt(plaintext, context_info);
ASSERT_THAT(ciphertext.status(), IsOk());
auto decryption =
- decrypt_or.ValueOrDie()->Decrypt(ciphertext.ValueOrDie(), context_info);
+ decrypt_or.value()->Decrypt(ciphertext.value(), context_info);
ASSERT_THAT(decryption.status(), Not(IsOk()));
}
diff --git a/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_public_key_manager_test.cc b/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_public_key_manager_test.cc
index 95af139..cb12c3c 100644
--- a/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_public_key_manager_test.cc
+++ b/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_aead_hkdf_public_key_manager_test.cc
@@ -76,7 +76,7 @@
auto private_key_manager = Cecpq2AeadHkdfPrivateKeyManager();
return private_key_manager
.GetPublicKey(private_key_manager.CreateKey(key_format).ValueOrDie())
- .ValueOrDie();
+ .value();
}
TEST(Cecpq2AeadHkdfPublicKeyManagerTest, ValidateParams) {
diff --git a/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_hybrid_config_test.cc b/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_hybrid_config_test.cc
index 5d1e27a..708fb26 100644
--- a/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_hybrid_config_test.cc
+++ b/cc/experimental/pqcrypto/cecpq2/hybrid/cecpq2_hybrid_config_test.cc
@@ -92,21 +92,20 @@
primitive_set
->AddPrimitive(absl::make_unique<DummyHybridEncrypt>("dummy"),
key_info)
- .ValueOrDie()),
+ .value()),
IsOk());
auto wrapped = Registry::Wrap(std::move(primitive_set));
ASSERT_THAT(wrapped.status(), IsOk());
- auto encryption_result = wrapped.ValueOrDie()->Encrypt("secret", "");
+ auto encryption_result = wrapped.value()->Encrypt("secret", "");
ASSERT_THAT(encryption_result.status(), IsOk());
- std::string prefix = CryptoFormat::GetOutputPrefix(key_info).ValueOrDie();
+ std::string prefix = CryptoFormat::GetOutputPrefix(key_info).value();
EXPECT_EQ(
- encryption_result.ValueOrDie(),
- absl::StrCat(
- prefix,
- DummyHybridEncrypt("dummy").Encrypt("secret", "").ValueOrDie()));
+ encryption_result.value(),
+ absl::StrCat(prefix,
+ DummyHybridEncrypt("dummy").Encrypt("secret", "").value()));
}
// Tests that the HybridDecrypt wrapper has been properly registered and we
@@ -128,20 +127,20 @@
primitive_set
->AddPrimitive(absl::make_unique<DummyHybridDecrypt>("dummy"),
key_info)
- .ValueOrDie()),
+ .value()),
IsOk());
auto wrapped = Registry::Wrap(std::move(primitive_set));
ASSERT_THAT(wrapped.status(), IsOk());
- std::string prefix = CryptoFormat::GetOutputPrefix(key_info).ValueOrDie();
+ std::string prefix = CryptoFormat::GetOutputPrefix(key_info).value();
std::string encryption =
- DummyHybridEncrypt("dummy").Encrypt("secret", "").ValueOrDie();
+ DummyHybridEncrypt("dummy").Encrypt("secret", "").value();
ASSERT_EQ(wrapped.ValueOrDie()
->Decrypt(absl::StrCat(prefix, encryption), "")
- .ValueOrDie(),
+ .value(),
"secret");
}
diff --git a/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_decrypt.cc b/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_decrypt.cc
index 9ca040c..c1ac533 100644
--- a/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_decrypt.cc
+++ b/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_decrypt.cc
@@ -85,8 +85,8 @@
if (!dem_result.ok()) return dem_result.status();
return {absl::WrapUnique(new Cecpq2AeadHkdfHybridDecrypt(
- private_key.public_key().params(), std::move(kem_result).ValueOrDie(),
- std::move(dem_result).ValueOrDie()))};
+ private_key.public_key().params(), std::move(kem_result).value(),
+ std::move(dem_result).value()))};
}
util::StatusOr<std::string> Cecpq2AeadHkdfHybridDecrypt::Decrypt(
@@ -111,7 +111,7 @@
util::StatusOr<uint32_t> key_material_size_or =
dem_helper_->GetKeyMaterialSize();
if (!key_material_size_or.ok()) return key_material_size_or.status();
- uint32_t key_material_size = key_material_size_or.ValueOrDie();
+ uint32_t key_material_size = key_material_size_or.value();
// Use KEM to get a symmetric key.
util::StatusOr<util::SecretData> symmetric_key_result =
@@ -124,21 +124,21 @@
util::Enums::ProtoToSubtle(
recipient_key_params_.kem_params().ec_point_format()));
if (!symmetric_key_result.ok()) return symmetric_key_result.status();
- util::SecretData symmetric_key = std::move(symmetric_key_result.ValueOrDie());
+ util::SecretData symmetric_key = std::move(symmetric_key_result.value());
// Use the symmetric key to get an AEAD-primitive.
util::StatusOr<std::unique_ptr<crypto::tink::subtle::AeadOrDaead>>
aead_or_daead_result = dem_helper_->GetAeadOrDaead(symmetric_key);
if (!aead_or_daead_result.ok()) return aead_or_daead_result.status();
std::unique_ptr<crypto::tink::subtle::AeadOrDaead> aead_or_daead =
- std::move(aead_or_daead_result.ValueOrDie());
+ std::move(aead_or_daead_result.value());
// Do the actual decryption using the AEAD-primitive.
util::StatusOr<std::string> decrypt_result = aead_or_daead->Decrypt(
ciphertext.substr(cecpq2_header_size), ""); // empty aad
if (!decrypt_result.ok()) return decrypt_result.status();
- return decrypt_result.ValueOrDie();
+ return decrypt_result.value();
}
} // namespace tink
diff --git a/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_decrypt_test.cc b/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_decrypt_test.cc
index 2b6e338..bd21b47 100644
--- a/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_decrypt_test.cc
+++ b/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_decrypt_test.cc
@@ -86,11 +86,9 @@
auto result = Cecpq2AeadHkdfHybridDecrypt::New(cecpq2_key);
if (!result.ok()) return result.status();
- std::unique_ptr<HybridDecrypt> hybrid_decrypt(
- std::move(result.ValueOrDie()));
- std::unique_ptr<HybridEncrypt> hybrid_encrypt(
- std::move(Cecpq2AeadHkdfHybridEncrypt::New(cecpq2_key.public_key())
- .ValueOrDie()));
+ std::unique_ptr<HybridDecrypt> hybrid_decrypt(std::move(result.value()));
+ std::unique_ptr<HybridEncrypt> hybrid_encrypt(std::move(
+ Cecpq2AeadHkdfHybridEncrypt::New(cecpq2_key.public_key()).value()));
std::string context_info = "some context info";
for (uint32_t plaintext_size : {0, 1, 10, 100, 1000}) {
@@ -98,13 +96,13 @@
std::string plaintext = Random::GetRandomBytes(plaintext_size);
auto ciphertext_or = hybrid_encrypt->Encrypt(plaintext, context_info);
if (!ciphertext_or.ok()) return ciphertext_or.status();
- auto ciphertext = ciphertext_or.ValueOrDie();
+ auto ciphertext = ciphertext_or.value();
{ // Regular decryption
auto decrypt_result = hybrid_decrypt->Decrypt(ciphertext, context_info);
if (!decrypt_result.ok()) {
return decrypt_result.status();
}
- if (plaintext != decrypt_result.ValueOrDie())
+ if (plaintext != decrypt_result.value())
return crypto::tink::util::Status(
absl::StatusCode::kInternal,
"Regular Encryption-Decryption failed:"
@@ -113,14 +111,14 @@
{ // Encryption and decryption with empty context info
const absl::string_view empty_context_info;
auto ciphertext =
- hybrid_encrypt->Encrypt(plaintext, empty_context_info).ValueOrDie();
+ hybrid_encrypt->Encrypt(plaintext, empty_context_info).value();
auto decrypt_result =
hybrid_decrypt->Decrypt(ciphertext, empty_context_info);
if (!decrypt_result.ok()) {
return decrypt_result.status();
}
- if (plaintext != decrypt_result.ValueOrDie())
+ if (plaintext != decrypt_result.value())
return crypto::tink::util::Status(
absl::StatusCode::kInternal,
"Empty Context Info Encryption-Decryption failed:"
@@ -131,13 +129,13 @@
const absl::string_view empty_context_info;
auto ciphertext =
hybrid_encrypt->Encrypt(empty_plaintext, empty_context_info)
- .ValueOrDie();
+ .value();
auto decrypt_result =
hybrid_decrypt->Decrypt(ciphertext, empty_context_info);
if (!decrypt_result.ok()) {
return decrypt_result.status();
}
- if (empty_plaintext != decrypt_result.ValueOrDie())
+ if (empty_plaintext != decrypt_result.value())
return crypto::tink::util::Status(
absl::StatusCode::kInternal,
"Empty Context Info and Message Encryption-Decryption failed:"
@@ -180,7 +178,7 @@
auto cecp2_key_pair = crypto::tink::pqc::GenerateCecpq2Keypair(
subtle::EllipticCurveType::CURVE25519)
- .ValueOrDie();
+ .value();
recipient_key.set_x25519_private_key(std::string(
util::SecretDataAsStringView(cecp2_key_pair.x25519_key_pair.priv)));
@@ -322,7 +320,7 @@
key_params.hash_type, ":", aes_gcm_key_size));
auto cecpq2_key_pair_or_status =
pqc::GenerateCecpq2Keypair(key_params.ec_curve);
- auto cecpq2_key_pair = std::move(cecpq2_key_pair_or_status.ValueOrDie());
+ auto cecpq2_key_pair = std::move(cecpq2_key_pair_or_status.value());
google::crypto::tink::Cecpq2AeadHkdfPrivateKey cecpq2_key;
cecpq2_key.set_hrss_private_key_seed(
std::string(util::SecretDataAsStringView(
@@ -380,7 +378,7 @@
key_params.hash_type));
auto cecpq2_key_pair_or_status =
pqc::GenerateCecpq2Keypair(key_params.ec_curve);
- auto cecpq2_key_pair = std::move(cecpq2_key_pair_or_status.ValueOrDie());
+ auto cecpq2_key_pair = std::move(cecpq2_key_pair_or_status.value());
google::crypto::tink::Cecpq2AeadHkdfPrivateKey cecpq2_key;
cecpq2_key.set_hrss_private_key_seed(
std::string(util::SecretDataAsStringView(
@@ -434,7 +432,7 @@
for (auto key_params : GetCommonHybridKeyParamsList()) {
auto cecpq2_key_pair_or_status =
pqc::GenerateCecpq2Keypair(key_params.ec_curve);
- auto cecpq2_key_pair = std::move(cecpq2_key_pair_or_status.ValueOrDie());
+ auto cecpq2_key_pair = std::move(cecpq2_key_pair_or_status.value());
google::crypto::tink::Cecpq2AeadHkdfPrivateKey cecpq2_key;
cecpq2_key.set_hrss_private_key_seed(
std::string(util::SecretDataAsStringView(
diff --git a/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_encrypt.cc b/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_encrypt.cc
index 6ccc76a..f66d5b4 100644
--- a/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_encrypt.cc
+++ b/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_encrypt.cc
@@ -74,8 +74,8 @@
if (!dem_result.ok()) return dem_result.status();
return {absl::WrapUnique(new Cecpq2AeadHkdfHybridEncrypt(
- recipient_key, std::move(kem_result).ValueOrDie(),
- std::move(dem_result).ValueOrDie()))};
+ recipient_key, std::move(kem_result).value(),
+ std::move(dem_result).value()))};
}
util::StatusOr<std::string> Cecpq2AeadHkdfHybridEncrypt::Encrypt(
@@ -84,7 +84,7 @@
util::StatusOr<uint32_t> key_material_size_or =
dem_helper_->GetKeyMaterialSize();
if (!key_material_size_or.ok()) return key_material_size_or.status();
- uint32_t key_material_size = key_material_size_or.ValueOrDie();
+ uint32_t key_material_size = key_material_size_or.value();
// Use KEM to get a symmetric key
util::StatusOr<
@@ -98,7 +98,7 @@
recipient_key_.params().kem_params().ec_point_format()));
if (!kem_key_result.ok()) return kem_key_result.status();
std::unique_ptr<const subtle::Cecpq2HkdfSenderKemBoringSsl::KemKey> kem_key =
- std::move(kem_key_result.ValueOrDie());
+ std::move(kem_key_result.value());
// Use the symmetric key to get an AEAD-primitive
util::StatusOr<std::unique_ptr<crypto::tink::subtle::AeadOrDaead>>
@@ -106,7 +106,7 @@
dem_helper_->GetAeadOrDaead(kem_key->get_symmetric_key());
if (!aead_or_daead_result.ok()) return aead_or_daead_result.status();
std::unique_ptr<crypto::tink::subtle::AeadOrDaead> aead_or_daead =
- std::move(aead_or_daead_result.ValueOrDie());
+ std::move(aead_or_daead_result.value());
// Do the actual encryption using the AEAD-primitive
util::StatusOr<std::string> encrypt_result =
@@ -115,7 +115,7 @@
// Prepend AEAD-ciphertext with a KEM component
std::string ciphertext =
- absl::StrCat(kem_key->get_kem_bytes(), encrypt_result.ValueOrDie());
+ absl::StrCat(kem_key->get_kem_bytes(), encrypt_result.value());
return ciphertext;
}
diff --git a/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_encrypt_test.cc b/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_encrypt_test.cc
index e6fde6f..418eee6 100644
--- a/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_encrypt_test.cc
+++ b/cc/experimental/pqcrypto/cecpq2/hybrid/internal/cecpq2_aead_hkdf_hybrid_encrypt_test.cc
@@ -47,7 +47,7 @@
google::crypto::tink::Cecpq2AeadHkdfPublicKey CreateValidKey() {
auto cecp2_key_pair = crypto::tink::pqc::GenerateCecpq2Keypair(
subtle::EllipticCurveType::CURVE25519)
- .ValueOrDie();
+ .value();
google::crypto::tink::Cecpq2AeadHkdfPublicKey sender_key;
sender_key.set_hrss_public_key_marshalled(
cecp2_key_pair.hrss_key_pair.hrss_public_key_marshaled);
@@ -100,7 +100,7 @@
auto status_or_cecpq2_key =
pqc::GenerateCecpq2Keypair(subtle::EllipticCurveType::CURVE25519);
ASSERT_THAT(status_or_cecpq2_key.status(), IsOk());
- auto cecpq2_key_pair = std::move(status_or_cecpq2_key).ValueOrDie();
+ auto cecpq2_key_pair = std::move(status_or_cecpq2_key).value();
google::crypto::tink::Cecpq2AeadHkdfPublicKey sender_key = CreateValidKey();
sender_key.mutable_params()
@@ -155,7 +155,7 @@
auto key_or = Cecpq2AeadHkdfHybridEncrypt::New(cecpq2_key);
ASSERT_THAT(key_or.status(), IsOk());
std::unique_ptr<HybridEncrypt> hybrid_encrypt(
- std::move(key_or.ValueOrDie()));
+ std::move(key_or.value()));
// Use the primitive
auto encrypt_result =
hybrid_encrypt->Encrypt(plaintext, context_info);
diff --git a/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_recipient_kem_boringssl.cc b/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_recipient_kem_boringssl.cc
index 7d3cf0c..54391cb 100644
--- a/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_recipient_kem_boringssl.cc
+++ b/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_recipient_kem_boringssl.cc
@@ -129,7 +129,7 @@
if (!symmetric_key_or.ok()) {
return symmetric_key_or.status();
}
- util::SecretData symmetric_key = symmetric_key_or.ValueOrDie();
+ util::SecretData symmetric_key = symmetric_key_or.value();
return symmetric_key;
}
diff --git a/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_recipient_kem_boringssl_test.cc b/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_recipient_kem_boringssl_test.cc
index 2db12fb..49e6b76 100644
--- a/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_recipient_kem_boringssl_test.cc
+++ b/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_recipient_kem_boringssl_test.cc
@@ -186,7 +186,7 @@
test::HexDecodeOrDie(kCecpq2X25519PrivateKeyHex)),
std::move(hrss_private_key_seed));
ASSERT_THAT(cecpq2_recipient_kem_or.status(), IsOk());
- auto cecpq2_recipient_kem = std::move(cecpq2_recipient_kem_or).ValueOrDie();
+ auto cecpq2_recipient_kem = std::move(cecpq2_recipient_kem_or).value();
// Recovering the symmetric key
auto kem_key_or = cecpq2_recipient_kem->GenerateKey(
@@ -213,7 +213,7 @@
test::HexDecodeOrDie(kCecpq2X25519PrivateKeyHex)),
std::move(hrss_private_key_seed));
ASSERT_THAT(cecpq2_recipient_kem_or.status(), IsOk());
- auto cecpq2_recipient_kem = std::move(cecpq2_recipient_kem_or).ValueOrDie();
+ auto cecpq2_recipient_kem = std::move(cecpq2_recipient_kem_or).value();
// Recovering the symmetric key
auto kem_key_or = cecpq2_recipient_kem->GenerateKey(
@@ -223,9 +223,8 @@
ASSERT_THAT(kem_key_or.status(), IsOk());
// The generated symmetric key should match the expected one
- EXPECT_EQ(
- kCorrectSharedSecret,
- test::HexEncode(util::SecretDataAsStringView(kem_key_or.ValueOrDie())));
+ EXPECT_EQ(kCorrectSharedSecret,
+ test::HexEncode(util::SecretDataAsStringView(kem_key_or.value())));
}
TEST(Cecpq2HkdfRecipientKemBoringSslTest, TestRecipientFlowFailure) {
@@ -251,7 +250,7 @@
test::HexDecodeOrDie(kCecpq2X25519PrivateKeyHex)),
std::move(hrss_private_key_seed));
ASSERT_THAT(cecpq2_recipient_kem_or.status(), IsOk());
- auto cecpq2_recipient_kem = std::move(cecpq2_recipient_kem_or).ValueOrDie();
+ auto cecpq2_recipient_kem = std::move(cecpq2_recipient_kem_or).value();
// Recovering the symmetric key
auto kem_key_or = cecpq2_recipient_kem->GenerateKey(
@@ -261,9 +260,8 @@
// The produced symmetric key should match the one produced by CECPQ2 in case
// of HRSS decapsulation failure for the altered HRSS kem_bytes
- EXPECT_EQ(
- kFailSharedSecret,
- test::HexEncode(util::SecretDataAsStringView(kem_key_or.ValueOrDie())));
+ EXPECT_EQ(kFailSharedSecret,
+ test::HexEncode(util::SecretDataAsStringView(kem_key_or.value())));
}
} // namespace
diff --git a/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_sender_kem_boringssl.cc b/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_sender_kem_boringssl.cc
index 177a427..811e3a1 100644
--- a/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_sender_kem_boringssl.cc
+++ b/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_sender_kem_boringssl.cc
@@ -167,7 +167,7 @@
if (!symmetric_key_or.ok()) {
return symmetric_key_or.status();
}
- util::SecretData symmetric_key = symmetric_key_or.ValueOrDie();
+ util::SecretData symmetric_key = symmetric_key_or.value();
// Return the produced pair kem_bytes and symmetric_key
return absl::make_unique<const KemKey>(kem_bytes, symmetric_key);
diff --git a/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_sender_kem_boringssl_test.cc b/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_sender_kem_boringssl_test.cc
index 2242123..d7ebaa0 100644
--- a/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_sender_kem_boringssl_test.cc
+++ b/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_hkdf_sender_kem_boringssl_test.cc
@@ -58,7 +58,7 @@
auto status_or_cecpq2_key =
pqc::GenerateCecpq2Keypair(EllipticCurveType::CURVE25519);
ASSERT_TRUE(status_or_cecpq2_key.ok());
- auto cecpq2_key_pair = std::move(status_or_cecpq2_key).ValueOrDie();
+ auto cecpq2_key_pair = std::move(status_or_cecpq2_key).value();
// Creating an instance of Cecpq2HkdfSenderKemBoringSsl specifying an unknown
// curve
@@ -84,7 +84,7 @@
auto status_or_cecpq2_key =
pqc::GenerateCecpq2Keypair(EllipticCurveType::CURVE25519);
ASSERT_TRUE(status_or_cecpq2_key.ok());
- auto cecpq2_key_pair = std::move(status_or_cecpq2_key).ValueOrDie();
+ auto cecpq2_key_pair = std::move(status_or_cecpq2_key).value();
// Creating an instance of Cecpq2HkdfSenderKemBoringSsl specifying a
// unsupported curve
@@ -115,7 +115,7 @@
auto status_or_cecpq2_key =
pqc::GenerateCecpq2Keypair(EllipticCurveType::CURVE25519);
ASSERT_TRUE(status_or_cecpq2_key.ok());
- auto cecpq2_key_pair = std::move(status_or_cecpq2_key).ValueOrDie();
+ auto cecpq2_key_pair = std::move(status_or_cecpq2_key).value();
// Creating an instance of Cecpq2HkdfSenderKemBoringSsl
auto status_or_sender_kem = Cecpq2HkdfSenderKemBoringSsl::New(
@@ -123,7 +123,7 @@
cecpq2_key_pair.x25519_key_pair.pub_y,
cecpq2_key_pair.hrss_key_pair.hrss_public_key_marshaled);
ASSERT_THAT(status_or_sender_kem.status(), IsOk());
- auto sender_kem = std::move(status_or_sender_kem.ValueOrDie());
+ auto sender_kem = std::move(status_or_sender_kem.value());
// Generating a symmetric key
auto status_or_kem_key = sender_kem->GenerateKey(
@@ -149,7 +149,7 @@
auto status_or_cecpq2_key =
pqc::GenerateCecpq2Keypair(EllipticCurveType::CURVE25519);
ASSERT_TRUE(status_or_cecpq2_key.ok());
- auto cecpq2_key_pair = std::move(status_or_cecpq2_key).ValueOrDie();
+ auto cecpq2_key_pair = std::move(status_or_cecpq2_key).value();
// Creating an instance of Cecpq2HkdfSenderKemBoringSsl
auto status_or_sender_kem = Cecpq2HkdfSenderKemBoringSsl::New(
@@ -157,7 +157,7 @@
cecpq2_key_pair.x25519_key_pair.pub_y,
cecpq2_key_pair.hrss_key_pair.hrss_public_key_marshaled);
ASSERT_THAT(status_or_sender_kem.status(), IsOk());
- auto sender_kem = std::move(status_or_sender_kem.ValueOrDie());
+ auto sender_kem = std::move(status_or_sender_kem.value());
// Generating a symmetric key
auto status_or_kem_key = sender_kem->GenerateKey(
@@ -166,7 +166,7 @@
// Asserting that the symmetric key has been successfully generated
ASSERT_THAT(status_or_kem_key.status(), IsOk());
- auto kem_key = std::move(status_or_kem_key.ValueOrDie());
+ auto kem_key = std::move(status_or_kem_key.value());
EXPECT_FALSE(kem_key->get_kem_bytes().empty());
EXPECT_EQ(kem_key->get_symmetric_key().size(), out_len);
}
@@ -187,7 +187,7 @@
auto status_or_cecpq2_key =
pqc::GenerateCecpq2Keypair(EllipticCurveType::CURVE25519);
ASSERT_TRUE(status_or_cecpq2_key.ok());
- auto cecpq2_key_pair = std::move(status_or_cecpq2_key).ValueOrDie();
+ auto cecpq2_key_pair = std::move(status_or_cecpq2_key).value();
// Creating an instance of Cecpq2HkdfSenderKemBoringSsl
auto status_or_sender_kem = Cecpq2HkdfSenderKemBoringSsl::New(
@@ -195,21 +195,21 @@
cecpq2_key_pair.x25519_key_pair.pub_y,
cecpq2_key_pair.hrss_key_pair.hrss_public_key_marshaled);
ASSERT_TRUE(status_or_sender_kem.ok());
- auto sender_kem = std::move(status_or_sender_kem.ValueOrDie());
+ auto sender_kem = std::move(status_or_sender_kem.value());
// Generating sender's shared secret
auto status_or_kem_key = sender_kem->GenerateKey(
HashType::SHA256, test::HexDecodeOrDie(salt_hex),
test::HexDecodeOrDie(info_hex), out_len, EcPointFormat::COMPRESSED);
ASSERT_TRUE(status_or_kem_key.ok());
- auto kem_key = std::move(status_or_kem_key.ValueOrDie());
+ auto kem_key = std::move(status_or_kem_key.value());
// Initializing recipient's KEM data structure using recipient's private keys
auto status_or_recipient_kem = Cecpq2HkdfRecipientKemBoringSsl::New(
EllipticCurveType::CURVE25519, cecpq2_key_pair.x25519_key_pair.priv,
std::move(cecpq2_key_pair.hrss_key_pair.hrss_private_key_seed));
ASSERT_TRUE(status_or_recipient_kem.ok());
- auto recipient_kem = std::move(status_or_recipient_kem.ValueOrDie());
+ auto recipient_kem = std::move(status_or_recipient_kem.value());
// Generating recipient's shared secret
auto status_or_shared_secret = recipient_kem->GenerateKey(
@@ -221,8 +221,8 @@
// Asserting that both shared secrets match
EXPECT_EQ(test::HexEncode(
util::SecretDataAsStringView(kem_key->get_symmetric_key())),
- test::HexEncode(util::SecretDataAsStringView(
- status_or_shared_secret.ValueOrDie())));
+ test::HexEncode(
+ util::SecretDataAsStringView(status_or_shared_secret.value())));
}
// This test evaluates the whole KEM flow as in
@@ -244,7 +244,7 @@
auto status_or_cecpq2_key =
pqc::GenerateCecpq2Keypair(EllipticCurveType::CURVE25519);
ASSERT_TRUE(status_or_cecpq2_key.ok());
- auto cecpq2_key_pair = std::move(status_or_cecpq2_key).ValueOrDie();
+ auto cecpq2_key_pair = std::move(status_or_cecpq2_key).value();
// Creating an instance of Cecpq2HkdfSenderKemBoringSsl
auto status_or_sender_kem = Cecpq2HkdfSenderKemBoringSsl::New(
@@ -252,7 +252,7 @@
cecpq2_key_pair.x25519_key_pair.pub_y,
cecpq2_key_pair.hrss_key_pair.hrss_public_key_marshaled);
ASSERT_THAT(status_or_sender_kem.status(), IsOk());
- auto sender_kem = std::move(status_or_sender_kem.ValueOrDie());
+ auto sender_kem = std::move(status_or_sender_kem.value());
// Erasing caller's public key buffers
cecpq2_key_pair.x25519_key_pair.pub_x.clear();
@@ -264,14 +264,14 @@
HashType::SHA256, test::HexDecodeOrDie(salt_hex),
test::HexDecodeOrDie(info_hex), out_len, EcPointFormat::COMPRESSED);
ASSERT_THAT(status_or_kem_key.status(), IsOk());
- auto kem_key = std::move(status_or_kem_key.ValueOrDie());
+ auto kem_key = std::move(status_or_kem_key.value());
// Initializing recipient's KEM data structure using recipient's private keys
auto status_or_recipient_kem = Cecpq2HkdfRecipientKemBoringSsl::New(
EllipticCurveType::CURVE25519, cecpq2_key_pair.x25519_key_pair.priv,
std::move(cecpq2_key_pair.hrss_key_pair.hrss_private_key_seed));
ASSERT_THAT(status_or_recipient_kem.status(), IsOk());
- auto recipient_kem = std::move(status_or_recipient_kem.ValueOrDie());
+ auto recipient_kem = std::move(status_or_recipient_kem.value());
// Generating recipient's shared secret
auto status_or_shared_secret = recipient_kem->GenerateKey(
@@ -283,8 +283,8 @@
// Asserting that both shared secrets match
EXPECT_EQ(test::HexEncode(
util::SecretDataAsStringView(kem_key->get_symmetric_key())),
- test::HexEncode(util::SecretDataAsStringView(
- status_or_shared_secret.ValueOrDie())));
+ test::HexEncode(
+ util::SecretDataAsStringView(status_or_shared_secret.value())));
}
// This test evaluates the whole KEM flow: from Sender to Recipient. This test
@@ -304,7 +304,7 @@
auto status_or_cecpq2_key =
pqc::GenerateCecpq2Keypair(EllipticCurveType::CURVE25519);
ASSERT_TRUE(status_or_cecpq2_key.ok());
- auto cecpq2_key_pair = std::move(status_or_cecpq2_key).ValueOrDie();
+ auto cecpq2_key_pair = std::move(status_or_cecpq2_key).value();
// Initializing sender's KEM data structure using recipient's public keys
auto status_or_sender_kem = Cecpq2HkdfSenderKemBoringSsl::New(
@@ -312,21 +312,21 @@
cecpq2_key_pair.x25519_key_pair.pub_y,
cecpq2_key_pair.hrss_key_pair.hrss_public_key_marshaled);
ASSERT_THAT(status_or_sender_kem.status(), IsOk());
- auto sender_kem = std::move(status_or_sender_kem.ValueOrDie());
+ auto sender_kem = std::move(status_or_sender_kem.value());
// Generating sender's shared secret (using salt_hex1)
auto status_or_kem_key = sender_kem->GenerateKey(
HashType::SHA256, test::HexDecodeOrDie(salt_hex),
test::HexDecodeOrDie(info_hex), out_len, EcPointFormat::COMPRESSED);
ASSERT_THAT(status_or_kem_key.status(), IsOk());
- auto kem_key = std::move(status_or_kem_key.ValueOrDie());
+ auto kem_key = std::move(status_or_kem_key.value());
// Initializing recipient's KEM data structure using recipient's private keys
auto status_or_recipient_kem = Cecpq2HkdfRecipientKemBoringSsl::New(
EllipticCurveType::CURVE25519, cecpq2_key_pair.x25519_key_pair.priv,
std::move(cecpq2_key_pair.hrss_key_pair.hrss_private_key_seed));
ASSERT_THAT(status_or_recipient_kem.status(), IsOk());
- auto recipient_kem = std::move(status_or_recipient_kem.ValueOrDie());
+ auto recipient_kem = std::move(status_or_recipient_kem.value());
// Here, we corrupt kem_bytes (we change all bytes to "a") so that
// the HRSS shared secret is not successfully recovered
@@ -342,8 +342,8 @@
// With very high probability, the shared secrets should not match
EXPECT_NE(test::HexEncode(
util::SecretDataAsStringView(kem_key->get_symmetric_key())),
- test::HexEncode(util::SecretDataAsStringView(
- status_or_shared_secret.ValueOrDie())));
+ test::HexEncode(
+ util::SecretDataAsStringView(status_or_shared_secret.value())));
}
} // namespace
diff --git a/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_subtle_boringssl_util.cc b/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_subtle_boringssl_util.cc
index e15d6c5..6867850 100644
--- a/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_subtle_boringssl_util.cc
+++ b/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_subtle_boringssl_util.cc
@@ -69,8 +69,7 @@
util::SecretData generate_hrss_key_entropy =
crypto::tink::subtle::Random::GetRandomKeyBytes(HRSS_GENERATE_KEY_BYTES);
auto hrss_key_pair_or_status = GenerateHrssKeyPair(generate_hrss_key_entropy);
- cecpq2_key_pair.hrss_key_pair =
- std::move(hrss_key_pair_or_status.ValueOrDie());
+ cecpq2_key_pair.hrss_key_pair = std::move(hrss_key_pair_or_status.value());
return cecpq2_key_pair;
}
diff --git a/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_subtle_boringssl_util_test.cc b/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_subtle_boringssl_util_test.cc
index 8f6c89a..8fe392e 100644
--- a/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_subtle_boringssl_util_test.cc
+++ b/cc/experimental/pqcrypto/cecpq2/subtle/cecpq2_subtle_boringssl_util_test.cc
@@ -115,11 +115,11 @@
std::string keypair1_pub_marsh_str(
reinterpret_cast<const char*>(
- keypair1.ValueOrDie().hrss_public_key_marshaled.data()),
+ keypair1.value().hrss_public_key_marshaled.data()),
HRSS_PUBLIC_KEY_BYTES);
std::string keypair2_pub_marsh_str(
reinterpret_cast<const char*>(
- keypair2.ValueOrDie().hrss_public_key_marshaled.data()),
+ keypair2.value().hrss_public_key_marshaled.data()),
HRSS_PUBLIC_KEY_BYTES);
// the two HRSS key pairs should be different with very high probability
@@ -137,7 +137,7 @@
auto keypair = crypto::tink::pqc::GenerateHrssKeyPair(hrss_key_gen_entropy);
// Checking that the generated HRSS public key matched the test vector one
- EXPECT_EQ(test::HexEncode(keypair.ValueOrDie().hrss_public_key_marshaled),
+ EXPECT_EQ(test::HexEncode(keypair.value().hrss_public_key_marshaled),
kExpectedPub);
}
diff --git a/cc/experimental/pqcrypto/cecpq2/util/test_util.cc b/cc/experimental/pqcrypto/cecpq2/util/test_util.cc
index 4217f5a..dc1e014 100644
--- a/cc/experimental/pqcrypto/cecpq2/util/test_util.cc
+++ b/cc/experimental/pqcrypto/cecpq2/util/test_util.cc
@@ -45,7 +45,7 @@
auto cecpq2_key_pair_or_status =
pqc::GenerateCecpq2Keypair(util::Enums::ProtoToSubtle(curve_type));
- auto cecpq2_key_pair = std::move(cecpq2_key_pair_or_status.ValueOrDie());
+ auto cecpq2_key_pair = std::move(cecpq2_key_pair_or_status.value());
std::string hrss_priv_key_seed_str(
reinterpret_cast<const char *>(
diff --git a/cc/hybrid/ecies_aead_hkdf_dem_helper.cc b/cc/hybrid/ecies_aead_hkdf_dem_helper.cc
index 4408b95..f6778e8 100644
--- a/cc/hybrid/ecies_aead_hkdf_dem_helper.cc
+++ b/cc/hybrid/ecies_aead_hkdf_dem_helper.cc
@@ -65,8 +65,7 @@
"No manager for DEM key type '%s' found in the registry.",
dem_type_url);
}
- const KeyManager<EncryptionPrimitive>* key_manager =
- key_manager_or.ValueOrDie();
+ const KeyManager<EncryptionPrimitive>* key_manager = key_manager_or.value();
return {absl::make_unique<EciesAeadHkdfDemHelperImpl<EncryptionPrimitive>>(
key_manager, dem_key_template, key_params)};
}
@@ -88,7 +87,7 @@
}
auto key_or = key_manager_->get_key_factory().NewKey(key_template_.value());
if (!key_or.ok()) return key_or.status();
- auto key = std::move(key_or).ValueOrDie();
+ auto key = std::move(key_or).value();
if (!ReplaceKeyBytes(symmetric_key_value, key.get())) {
return util::Status(absl::StatusCode::kInternal,
"Generation of DEM-key failed.");
@@ -99,7 +98,7 @@
ZeroKeyBytes(key.get());
if (!primitive_or.ok()) return primitive_or.status();
- return absl::make_unique<AeadOrDaead>(std::move(primitive_or.ValueOrDie()));
+ return absl::make_unique<AeadOrDaead>(std::move(primitive_or.value()));
}
private:
@@ -156,7 +155,7 @@
EciesAeadHkdfDemHelper::New(const KeyTemplate& dem_key_template) {
auto key_params_or = GetKeyParams(dem_key_template);
if (!key_params_or.ok()) return key_params_or.status();
- DemKeyParams key_params = key_params_or.ValueOrDie();
+ DemKeyParams key_params = key_params_or.value();
const std::string& dem_type_url = dem_key_template.type_url();
if (key_params.key_type == AES_SIV_KEY) {
diff --git a/cc/hybrid/ecies_aead_hkdf_dem_helper_test.cc b/cc/hybrid/ecies_aead_hkdf_dem_helper_test.cc
index e8a6f72..4fa018f 100644
--- a/cc/hybrid/ecies_aead_hkdf_dem_helper_test.cc
+++ b/cc/hybrid/ecies_aead_hkdf_dem_helper_test.cc
@@ -46,9 +46,9 @@
StatusOr<std::string> encryption_or = dem.Encrypt(message, associated_data);
if (!encryption_or.status().ok()) return encryption_or.status();
StatusOr<std::string> decryption_or =
- dem.Decrypt(encryption_or.ValueOrDie(), associated_data);
+ dem.Decrypt(encryption_or.value(), associated_data);
if (!decryption_or.status().ok()) return decryption_or.status();
- if (decryption_or.ValueOrDie() != message) {
+ if (decryption_or.value() != message) {
return crypto::tink::util::Status(absl::StatusCode::kInternal,
"Message/Decryption mismatch");
}
@@ -78,7 +78,7 @@
auto dem_helper_or = EciesAeadHkdfDemHelper::New(dem_key_template);
ASSERT_THAT(dem_helper_or.status(), IsOk());
- auto dem_helper = std::move(dem_helper_or.ValueOrDie());
+ auto dem_helper = std::move(dem_helper_or.value());
util::SecretData key128 = util::SecretDataFromStringView(
test::HexDecodeOrDie("000102030405060708090a0b0c0d0e0f"));
@@ -86,7 +86,7 @@
dem_helper->GetAeadOrDaead(key128);
ASSERT_THAT(aead_or_daead_result_or.status(), IsOk());
- auto aead_or_daead = std::move(aead_or_daead_result_or.ValueOrDie());
+ auto aead_or_daead = std::move(aead_or_daead_result_or.value());
EXPECT_THAT(EncryptThenDecrypt(*aead_or_daead, "test_plaintext", "test_ad"),
IsOk());
}
@@ -105,7 +105,7 @@
auto dem_helper_or = EciesAeadHkdfDemHelper::New(dem_key_template);
ASSERT_THAT(dem_helper_or.status(), IsOk());
- auto dem_helper = std::move(dem_helper_or.ValueOrDie());
+ auto dem_helper = std::move(dem_helper_or.value());
util::SecretData key128 = util::SecretDataFromStringView(test::HexDecodeOrDie(
"000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f00010203"
@@ -114,7 +114,7 @@
dem_helper->GetAeadOrDaead(key128);
ASSERT_THAT(aead_or_daead_result_or.status(), IsOk());
- auto aead_or_daead = std::move(aead_or_daead_result_or.ValueOrDie());
+ auto aead_or_daead = std::move(aead_or_daead_result_or.value());
EXPECT_THAT(EncryptThenDecrypt(*aead_or_daead, "test_plaintext", "test_ad"),
IsOk());
}
diff --git a/cc/hybrid/ecies_aead_hkdf_hybrid_decrypt.cc b/cc/hybrid/ecies_aead_hkdf_hybrid_decrypt.cc
index ef424d2..497b95f 100644
--- a/cc/hybrid/ecies_aead_hkdf_hybrid_decrypt.cc
+++ b/cc/hybrid/ecies_aead_hkdf_hybrid_decrypt.cc
@@ -79,8 +79,8 @@
if (!dem_result.ok()) return dem_result.status();
return {absl::WrapUnique(new EciesAeadHkdfHybridDecrypt(
- recipient_key.public_key().params(), std::move(kem_result).ValueOrDie(),
- std::move(dem_result).ValueOrDie()))};
+ recipient_key.public_key().params(), std::move(kem_result).value(),
+ std::move(dem_result).value()))};
}
util::StatusOr<std::string> EciesAeadHkdfHybridDecrypt::Decrypt(
@@ -91,7 +91,7 @@
recipient_key_params_.kem_params().curve_type()),
util::Enums::ProtoToSubtle(recipient_key_params_.ec_point_format()));
if (!header_size_result.ok()) return header_size_result.status();
- auto header_size = header_size_result.ValueOrDie();
+ auto header_size = header_size_result.value();
if (ciphertext.size() < header_size) {
return util::Status(absl::StatusCode::kInvalidArgument,
"ciphertext too short");
@@ -106,19 +106,19 @@
dem_helper_->dem_key_size_in_bytes(),
util::Enums::ProtoToSubtle(recipient_key_params_.ec_point_format()));
if (!symmetric_key_result.ok()) return symmetric_key_result.status();
- auto symmetric_key = std::move(symmetric_key_result.ValueOrDie());
+ auto symmetric_key = std::move(symmetric_key_result.value());
// Use the symmetric key to get an AEAD-primitive.
auto aead_or_daead_result = dem_helper_->GetAeadOrDaead(symmetric_key);
if (!aead_or_daead_result.ok()) return aead_or_daead_result.status();
- auto aead_or_daead = std::move(aead_or_daead_result.ValueOrDie());
+ auto aead_or_daead = std::move(aead_or_daead_result.value());
// Do the actual decryption using the AEAD-primitive.
auto decrypt_result =
aead_or_daead->Decrypt(ciphertext.substr(header_size), ""); // empty aad
if (!decrypt_result.ok()) return decrypt_result.status();
- return decrypt_result.ValueOrDie();
+ return decrypt_result.value();
}
} // namespace tink
diff --git a/cc/hybrid/ecies_aead_hkdf_hybrid_decrypt_test.cc b/cc/hybrid/ecies_aead_hkdf_hybrid_decrypt_test.cc
index 61c7960..44b79c2 100644
--- a/cc/hybrid/ecies_aead_hkdf_hybrid_decrypt_test.cc
+++ b/cc/hybrid/ecies_aead_hkdf_hybrid_decrypt_test.cc
@@ -97,42 +97,41 @@
void TestValidKey(const EciesAeadHkdfPrivateKey& ecies_key) {
auto result(EciesAeadHkdfHybridDecrypt::New(ecies_key));
ASSERT_TRUE(result.ok()) << result.status() << ecies_key.DebugString();
- std::unique_ptr<HybridDecrypt> hybrid_decrypt(
- std::move(result.ValueOrDie()));
+ std::unique_ptr<HybridDecrypt> hybrid_decrypt(std::move(result.value()));
std::unique_ptr<HybridEncrypt> hybrid_encrypt(std::move(
- EciesAeadHkdfHybridEncrypt::New(ecies_key.public_key()).ValueOrDie()));
+ EciesAeadHkdfHybridEncrypt::New(ecies_key.public_key()).value()));
std::string context_info = "some context info";
for (uint32_t plaintext_size : {0, 1, 10, 100, 1000}) {
// Use the primitive.
std::string plaintext = Random::GetRandomBytes(plaintext_size);
auto ciphertext =
- hybrid_encrypt->Encrypt(plaintext, context_info).ValueOrDie();
+ hybrid_encrypt->Encrypt(plaintext, context_info).value();
{ // Regular decryption.
auto decrypt_result = hybrid_decrypt->Decrypt(ciphertext, context_info);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
}
{ // Encryption and decryption with empty context info.
const absl::string_view empty_context_info;
auto ciphertext =
- hybrid_encrypt->Encrypt(plaintext, empty_context_info).ValueOrDie();
+ hybrid_encrypt->Encrypt(plaintext, empty_context_info).value();
auto decrypt_result =
hybrid_decrypt->Decrypt(ciphertext, empty_context_info);
ASSERT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
}
{ // Encryption and decryption w/ empty msg & context info.
const absl::string_view empty_plaintext;
const absl::string_view empty_context_info;
auto ciphertext =
hybrid_encrypt->Encrypt(empty_plaintext, empty_context_info)
- .ValueOrDie();
+ .value();
auto decrypt_result =
hybrid_decrypt->Decrypt(ciphertext, empty_context_info);
ASSERT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(empty_plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(empty_plaintext, decrypt_result.value());
}
{ // Short bad ciphertext.
auto decrypt_result =
@@ -197,7 +196,7 @@
{ // Unsupported DEM key type.
EllipticCurveType curve = EllipticCurveType::NIST_P256;
auto test_key =
- internal::NewEcKey(util::Enums::ProtoToSubtle(curve)).ValueOrDie();
+ internal::NewEcKey(util::Enums::ProtoToSubtle(curve)).value();
EciesAeadHkdfPrivateKey recipient_key;
recipient_key.set_version(0);
recipient_key.set_key_value("some key value bytes");
@@ -506,7 +505,7 @@
for (const TestVector& test_vector : hybrid_decryption_test_vectors) {
std::unique_ptr<HybridDecrypt> hybrid_decrypt =
- EciesAeadHkdfHybridDecrypt::New(test_vector.private_key).ValueOrDie();
+ EciesAeadHkdfHybridDecrypt::New(test_vector.private_key).value();
EXPECT_THAT(hybrid_decrypt->Decrypt(test_vector.ciphertext,
test_vector.context_info),
IsOkAndHolds(Eq(test_vector.plaintext)));
diff --git a/cc/hybrid/ecies_aead_hkdf_hybrid_encrypt.cc b/cc/hybrid/ecies_aead_hkdf_hybrid_encrypt.cc
index e425719..2f70a7c 100644
--- a/cc/hybrid/ecies_aead_hkdf_hybrid_encrypt.cc
+++ b/cc/hybrid/ecies_aead_hkdf_hybrid_encrypt.cc
@@ -77,8 +77,8 @@
if (!dem_result.ok()) return dem_result.status();
return {absl::WrapUnique(new EciesAeadHkdfHybridEncrypt(
- recipient_key, std::move(kem_result).ValueOrDie(),
- std::move(dem_result).ValueOrDie()))};
+ recipient_key, std::move(kem_result).value(),
+ std::move(dem_result).value()))};
}
util::StatusOr<std::string> EciesAeadHkdfHybridEncrypt::Encrypt(
@@ -93,13 +93,13 @@
util::Enums::ProtoToSubtle(
recipient_key_.params().ec_point_format()));
if (!kem_key_result.ok()) return kem_key_result.status();
- auto kem_key = std::move(kem_key_result.ValueOrDie());
+ auto kem_key = std::move(kem_key_result.value());
// Use the symmetric key to get an AEAD-primitive.
auto aead_or_daead_result =
dem_helper_->GetAeadOrDaead(kem_key->get_symmetric_key());
if (!aead_or_daead_result.ok()) return aead_or_daead_result.status();
- auto aead_or_daead = std::move(aead_or_daead_result.ValueOrDie());
+ auto aead_or_daead = std::move(aead_or_daead_result.value());
// Do the actual encryption using the AEAD-primitive.
auto encrypt_result = aead_or_daead->Encrypt(plaintext, ""); // empty aad
@@ -107,7 +107,7 @@
// Prepend AEAD-ciphertext with a KEM component.
std::string ciphertext =
- absl::StrCat(kem_key->get_kem_bytes(), encrypt_result.ValueOrDie());
+ absl::StrCat(kem_key->get_kem_bytes(), encrypt_result.value());
return ciphertext;
}
diff --git a/cc/hybrid/ecies_aead_hkdf_hybrid_encrypt_test.cc b/cc/hybrid/ecies_aead_hkdf_hybrid_encrypt_test.cc
index c640ba6..f2c4277 100644
--- a/cc/hybrid/ecies_aead_hkdf_hybrid_encrypt_test.cc
+++ b/cc/hybrid/ecies_aead_hkdf_hybrid_encrypt_test.cc
@@ -86,8 +86,8 @@
{ // Unsupported DEM key type.
EllipticCurveType curve = EllipticCurveType::NIST_P256;
- auto test_key = internal::NewEcKey(
- util::Enums::ProtoToSubtle(curve)).ValueOrDie();
+ auto test_key =
+ internal::NewEcKey(util::Enums::ProtoToSubtle(curve)).value();
EciesAeadHkdfPublicKey recipient_key;
recipient_key.set_version(0);
recipient_key.set_x(test_key.pub_x);
@@ -141,7 +141,7 @@
ASSERT_TRUE(result.ok()) << result.status()
<< ecies_key.SerializeAsString();
std::unique_ptr<HybridEncrypt> hybrid_encrypt(
- std::move(result.ValueOrDie()));
+ std::move(result.value()));
// Use the primitive.
auto encrypt_result =
diff --git a/cc/hybrid/ecies_aead_hkdf_private_key_manager_test.cc b/cc/hybrid/ecies_aead_hkdf_private_key_manager_test.cc
index 310e9a5..b195dca 100644
--- a/cc/hybrid/ecies_aead_hkdf_private_key_manager_test.cc
+++ b/cc/hybrid/ecies_aead_hkdf_private_key_manager_test.cc
@@ -122,7 +122,7 @@
ASSERT_THAT(EciesAeadHkdfPrivateKeyManager().CreateKey(key_format).status(),
IsOk());
EciesAeadHkdfPrivateKey key =
- EciesAeadHkdfPrivateKeyManager().CreateKey(key_format).ValueOrDie();
+ EciesAeadHkdfPrivateKeyManager().CreateKey(key_format).value();
EXPECT_THAT(key.public_key().params().kem_params().curve_type(),
Eq(key_format.params().kem_params().curve_type()));
EXPECT_THAT(key.public_key().params().kem_params().hkdf_hash_type(),
@@ -143,7 +143,7 @@
EciesAeadHkdfPrivateKey CreateValidKey() {
return EciesAeadHkdfPrivateKeyManager()
.CreateKey(CreateValidKeyFormat())
- .ValueOrDie();
+ .value();
}
TEST(EciesAeadHkdfPrivateKeyManagerTest, ValidateKeyEmpty) {
@@ -207,7 +207,7 @@
ASSERT_THAT(EciesAeadHkdfPrivateKeyManager().GetPublicKey(key).status(),
IsOk());
EciesAeadHkdfPublicKey public_key =
- EciesAeadHkdfPrivateKeyManager().GetPublicKey(key).ValueOrDie();
+ EciesAeadHkdfPrivateKeyManager().GetPublicKey(key).value();
EXPECT_THAT(public_key.params().kem_params().curve_type(),
Eq(key.public_key().params().kem_params().curve_type()));
EXPECT_THAT(public_key.params().kem_params().hkdf_hash_type(),
@@ -233,7 +233,7 @@
EciesAeadHkdfPrivateKey private_key = CreateValidKey();
EciesAeadHkdfPublicKey public_key =
- EciesAeadHkdfPrivateKeyManager().GetPublicKey(private_key).ValueOrDie();
+ EciesAeadHkdfPrivateKeyManager().GetPublicKey(private_key).value();
auto decrypt_or =
EciesAeadHkdfPrivateKeyManager().GetPrimitive<HybridDecrypt>(private_key);
@@ -241,9 +241,9 @@
auto encrypt_or = EciesAeadHkdfHybridEncrypt::New(public_key);
ASSERT_THAT(encrypt_or.status(), IsOk());
- ASSERT_THAT(HybridEncryptThenDecrypt(encrypt_or.ValueOrDie().get(),
- decrypt_or.ValueOrDie().get(),
- "some text", "some aad"),
+ ASSERT_THAT(HybridEncryptThenDecrypt(encrypt_or.value().get(),
+ decrypt_or.value().get(), "some text",
+ "some aad"),
IsOk());
}
@@ -253,9 +253,8 @@
EciesAeadHkdfPrivateKey private_key = CreateValidKey();
// Note: we create a new private key in the next line.
- EciesAeadHkdfPublicKey public_key = EciesAeadHkdfPrivateKeyManager()
- .GetPublicKey(CreateValidKey())
- .ValueOrDie();
+ EciesAeadHkdfPublicKey public_key =
+ EciesAeadHkdfPrivateKeyManager().GetPublicKey(CreateValidKey()).value();
auto decrypt_or =
EciesAeadHkdfPrivateKeyManager().GetPrimitive<HybridDecrypt>(private_key);
@@ -263,9 +262,9 @@
auto encrypt_or = EciesAeadHkdfHybridEncrypt::New(public_key);
ASSERT_THAT(encrypt_or.status(), IsOk());
- ASSERT_THAT(HybridEncryptThenDecrypt(encrypt_or.ValueOrDie().get(),
- decrypt_or.ValueOrDie().get(),
- "some text", "some aad"),
+ ASSERT_THAT(HybridEncryptThenDecrypt(encrypt_or.value().get(),
+ decrypt_or.value().get(), "some text",
+ "some aad"),
Not(IsOk()));
}
diff --git a/cc/hybrid/ecies_aead_hkdf_public_key_manager_test.cc b/cc/hybrid/ecies_aead_hkdf_public_key_manager_test.cc
index 9080bd1..c155fce 100644
--- a/cc/hybrid/ecies_aead_hkdf_public_key_manager_test.cc
+++ b/cc/hybrid/ecies_aead_hkdf_public_key_manager_test.cc
@@ -73,9 +73,8 @@
kem_params->set_hkdf_salt("");
auto private_key_manager = EciesAeadHkdfPrivateKeyManager();
return private_key_manager
- .GetPublicKey(
- private_key_manager.CreateKey(key_format).ValueOrDie())
- .ValueOrDie();
+ .GetPublicKey(private_key_manager.CreateKey(key_format).ValueOrDie())
+ .value();
}
TEST(EciesAeadHkdfPublicKeyManagerTest, ValidateParams) {
diff --git a/cc/hybrid/hybrid_config_test.cc b/cc/hybrid/hybrid_config_test.cc
index 5505198..bb9a0a0 100644
--- a/cc/hybrid/hybrid_config_test.cc
+++ b/cc/hybrid/hybrid_config_test.cc
@@ -93,21 +93,20 @@
primitive_set
->AddPrimitive(absl::make_unique<DummyHybridEncrypt>("dummy"),
key_info)
- .ValueOrDie()),
+ .value()),
IsOk());
auto wrapped = Registry::Wrap(std::move(primitive_set));
ASSERT_TRUE(wrapped.ok()) << wrapped.status();
- auto encryption_result = wrapped.ValueOrDie()->Encrypt("secret", "");
+ auto encryption_result = wrapped.value()->Encrypt("secret", "");
ASSERT_TRUE(encryption_result.ok());
- std::string prefix = CryptoFormat::GetOutputPrefix(key_info).ValueOrDie();
+ std::string prefix = CryptoFormat::GetOutputPrefix(key_info).value();
EXPECT_EQ(
- encryption_result.ValueOrDie(),
- absl::StrCat(
- prefix,
- DummyHybridEncrypt("dummy").Encrypt("secret", "").ValueOrDie()));
+ encryption_result.value(),
+ absl::StrCat(prefix,
+ DummyHybridEncrypt("dummy").Encrypt("secret", "").value()));
}
// Tests that the HybridDecryptWrapper has been properly registered and we
@@ -129,20 +128,20 @@
primitive_set
->AddPrimitive(absl::make_unique<DummyHybridDecrypt>("dummy"),
key_info)
- .ValueOrDie()),
+ .value()),
IsOk());
auto wrapped = Registry::Wrap(std::move(primitive_set));
ASSERT_TRUE(wrapped.ok()) << wrapped.status();
- std::string prefix = CryptoFormat::GetOutputPrefix(key_info).ValueOrDie();
+ std::string prefix = CryptoFormat::GetOutputPrefix(key_info).value();
std::string encryption =
- DummyHybridEncrypt("dummy").Encrypt("secret", "").ValueOrDie();
+ DummyHybridEncrypt("dummy").Encrypt("secret", "").value();
ASSERT_EQ(wrapped.ValueOrDie()
->Decrypt(absl::StrCat(prefix, encryption), "")
- .ValueOrDie(),
+ .value(),
"secret");
}
diff --git a/cc/hybrid/hybrid_decrypt_factory_test.cc b/cc/hybrid/hybrid_decrypt_factory_test.cc
index 6c95146..2dce36a 100644
--- a/cc/hybrid/hybrid_decrypt_factory_test.cc
+++ b/cc/hybrid/hybrid_decrypt_factory_test.cc
@@ -99,39 +99,37 @@
auto ecies_key_manager = absl::make_unique<EciesAeadHkdfPublicKeyManager>();
std::unique_ptr<HybridEncrypt> ecies_1 = std::move(
ecies_key_manager->GetPrimitive<HybridEncrypt>(ecies_key_1.public_key())
- .ValueOrDie());
+ .value());
std::unique_ptr<HybridEncrypt> ecies_2 = std::move(
ecies_key_manager->GetPrimitive<HybridEncrypt>(ecies_key_2.public_key())
- .ValueOrDie());
+ .value());
// Create a KeysetHandle and use it with the factory.
auto hybrid_decrypt_result = HybridDecryptFactory::GetPrimitive(
*TestKeysetHandle::GetKeysetHandle(keyset));
EXPECT_TRUE(hybrid_decrypt_result.ok()) << hybrid_decrypt_result.status();
- auto hybrid_decrypt = std::move(hybrid_decrypt_result.ValueOrDie());
+ auto hybrid_decrypt = std::move(hybrid_decrypt_result.value());
// Test the resulting HybridDecrypt-instance.
std::string plaintext = "some plaintext";
std::string context_info = "some context info";
auto ciphertext_1 =
- CryptoFormat::GetOutputPrefix(KeyInfoFromKey(keyset.key(0)))
- .ValueOrDie() +
- ecies_1->Encrypt(plaintext, context_info).ValueOrDie();
+ CryptoFormat::GetOutputPrefix(KeyInfoFromKey(keyset.key(0))).value() +
+ ecies_1->Encrypt(plaintext, context_info).value();
auto ciphertext_2 =
- CryptoFormat::GetOutputPrefix(KeyInfoFromKey(keyset.key(1)))
- .ValueOrDie() +
- ecies_2->Encrypt(plaintext, context_info).ValueOrDie();
+ CryptoFormat::GetOutputPrefix(KeyInfoFromKey(keyset.key(1))).value() +
+ ecies_2->Encrypt(plaintext, context_info).value();
{ // Regular decryption with key_1.
auto decrypt_result = hybrid_decrypt->Decrypt(ciphertext_1, context_info);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
}
{ // Regular decryption with key_2.
auto decrypt_result = hybrid_decrypt->Decrypt(ciphertext_2, context_info);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
}
{ // Wrong context_info.
diff --git a/cc/hybrid/hybrid_decrypt_wrapper.cc b/cc/hybrid/hybrid_decrypt_wrapper.cc
index c7c22ad..39eb2e8 100644
--- a/cc/hybrid/hybrid_decrypt_wrapper.cc
+++ b/cc/hybrid/hybrid_decrypt_wrapper.cc
@@ -61,12 +61,12 @@
if (primitives_result.ok()) {
absl::string_view raw_ciphertext =
ciphertext.substr(CryptoFormat::kNonRawPrefixSize);
- for (auto& hybrid_decrypt_entry : *(primitives_result.ValueOrDie())) {
+ for (auto& hybrid_decrypt_entry : *(primitives_result.value())) {
HybridDecrypt& hybrid_decrypt = hybrid_decrypt_entry->get_primitive();
auto decrypt_result =
hybrid_decrypt.Decrypt(raw_ciphertext, context_info);
if (decrypt_result.ok()) {
- return std::move(decrypt_result.ValueOrDie());
+ return std::move(decrypt_result.value());
} else {
// LOG that a matching key didn't decrypt the ciphertext.
}
@@ -77,11 +77,11 @@
// No matching key succeeded with decryption, try all RAW keys.
auto raw_primitives_result = hybrid_decrypt_set_->get_raw_primitives();
if (raw_primitives_result.ok()) {
- for (auto& hybrid_decrypt_entry : *(raw_primitives_result.ValueOrDie())) {
+ for (auto& hybrid_decrypt_entry : *(raw_primitives_result.value())) {
HybridDecrypt& hybrid_decrypt = hybrid_decrypt_entry->get_primitive();
auto decrypt_result = hybrid_decrypt.Decrypt(ciphertext, context_info);
if (decrypt_result.ok()) {
- return std::move(decrypt_result.ValueOrDie());
+ return std::move(decrypt_result.value());
}
}
}
diff --git a/cc/hybrid/hybrid_decrypt_wrapper_test.cc b/cc/hybrid/hybrid_decrypt_wrapper_test.cc
index 60c8c18..9ae03ad 100644
--- a/cc/hybrid/hybrid_decrypt_wrapper_test.cc
+++ b/cc/hybrid/hybrid_decrypt_wrapper_test.cc
@@ -106,30 +106,29 @@
entry_result = hybrid_decrypt_set->AddPrimitive(std::move(hybrid_decrypt),
keyset.key_info(1));
ASSERT_TRUE(entry_result.ok());
- std::string prefix_id_1 = entry_result.ValueOrDie()->get_identifier();
+ std::string prefix_id_1 = entry_result.value()->get_identifier();
hybrid_decrypt.reset(new DummyHybridDecrypt(hybrid_name_2));
entry_result = hybrid_decrypt_set->AddPrimitive(std::move(hybrid_decrypt),
keyset.key_info(2));
ASSERT_TRUE(entry_result.ok());
// The last key is the primary.
- ASSERT_THAT(hybrid_decrypt_set->set_primary(entry_result.ValueOrDie()),
- IsOk());
+ ASSERT_THAT(hybrid_decrypt_set->set_primary(entry_result.value()), IsOk());
// Wrap hybrid_decrypt_set and test the resulting HybridDecrypt.
auto hybrid_decrypt_result = HybridDecryptWrapper().Wrap(
std::move(hybrid_decrypt_set));
EXPECT_TRUE(hybrid_decrypt_result.ok()) << hybrid_decrypt_result.status();
- hybrid_decrypt = std::move(hybrid_decrypt_result.ValueOrDie());
+ hybrid_decrypt = std::move(hybrid_decrypt_result.value());
std::string plaintext = "some_plaintext";
std::string context_info = "some_context";
{ // RAW key
std::string ciphertext = DummyHybridEncrypt(hybrid_name_0)
.Encrypt(plaintext, context_info)
- .ValueOrDie();
+ .value();
auto decrypt_result = hybrid_decrypt->Decrypt(ciphertext, context_info);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
}
{ // No ciphertext prefix.
@@ -146,10 +145,10 @@
std::string ciphertext =
prefix_id_1 + DummyHybridEncrypt(hybrid_name_1)
.Encrypt(plaintext, context_info)
- .ValueOrDie();
+ .value();
auto decrypt_result = hybrid_decrypt->Decrypt(ciphertext, context_info);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
}
{ // Bad ciphertext.
diff --git a/cc/hybrid/hybrid_encrypt_factory_test.cc b/cc/hybrid/hybrid_encrypt_factory_test.cc
index cfaa53b..415c786 100644
--- a/cc/hybrid/hybrid_encrypt_factory_test.cc
+++ b/cc/hybrid/hybrid_encrypt_factory_test.cc
@@ -95,7 +95,7 @@
auto hybrid_encrypt_result = HybridEncryptFactory::GetPrimitive(
*TestKeysetHandle::GetKeysetHandle(keyset));
EXPECT_TRUE(hybrid_encrypt_result.ok()) << hybrid_encrypt_result.status();
- auto hybrid_encrypt = std::move(hybrid_encrypt_result.ValueOrDie());
+ auto hybrid_encrypt = std::move(hybrid_encrypt_result.value());
// Test the resulting HybridEncrypt-instance.
std::string plaintext = "some plaintext";
diff --git a/cc/hybrid/hybrid_encrypt_wrapper.cc b/cc/hybrid/hybrid_encrypt_wrapper.cc
index 97ff1b4..e4fe558 100644
--- a/cc/hybrid/hybrid_encrypt_wrapper.cc
+++ b/cc/hybrid/hybrid_encrypt_wrapper.cc
@@ -75,7 +75,7 @@
primary->get_primitive().Encrypt(plaintext, context_info);
if (!encrypt_result.ok()) return encrypt_result.status();
const std::string& key_id = primary->get_identifier();
- return key_id + encrypt_result.ValueOrDie();
+ return key_id + encrypt_result.value();
}
} // anonymous namespace
diff --git a/cc/hybrid/hybrid_encrypt_wrapper_test.cc b/cc/hybrid/hybrid_encrypt_wrapper_test.cc
index d987ff8..98aa8e7 100644
--- a/cc/hybrid/hybrid_encrypt_wrapper_test.cc
+++ b/cc/hybrid/hybrid_encrypt_wrapper_test.cc
@@ -110,20 +110,19 @@
keyset_info.key_info(2));
ASSERT_TRUE(entry_result.ok());
// The last key is the primary.
- ASSERT_THAT(hybrid_encrypt_set->set_primary(entry_result.ValueOrDie()),
- IsOk());
+ ASSERT_THAT(hybrid_encrypt_set->set_primary(entry_result.value()), IsOk());
// Wrap hybrid_encrypt_set and test the resulting HybridEncrypt.
auto hybrid_encrypt_result = HybridEncryptWrapper().Wrap(
std::move(hybrid_encrypt_set));
EXPECT_TRUE(hybrid_encrypt_result.ok()) << hybrid_encrypt_result.status();
- hybrid_encrypt = std::move(hybrid_encrypt_result.ValueOrDie());
+ hybrid_encrypt = std::move(hybrid_encrypt_result.value());
std::string plaintext = "some_plaintext";
std::string context_info = "some_context";
auto encrypt_result = hybrid_encrypt->Encrypt(plaintext, context_info);
EXPECT_TRUE(encrypt_result.ok()) << encrypt_result.status();
- std::string ciphertext = encrypt_result.ValueOrDie();
+ std::string ciphertext = encrypt_result.value();
EXPECT_PRED_FORMAT2(testing::IsSubstring,
hybrid_name_2, ciphertext);
}
diff --git a/cc/hybrid/internal/hpke_decrypt_boringssl.cc b/cc/hybrid/internal/hpke_decrypt_boringssl.cc
index 19e19c3..d865aa8 100644
--- a/cc/hybrid/internal/hpke_decrypt_boringssl.cc
+++ b/cc/hybrid/internal/hpke_decrypt_boringssl.cc
@@ -46,7 +46,7 @@
if (!status.ok()) {
return status;
}
- return hpke_decrypt;
+ return std::move(hpke_decrypt);
}
util::Status HpkeDecryptBoringSsl::Init(const HpkeParams& params,
diff --git a/cc/hybrid/internal/hpke_encrypt_boringssl.cc b/cc/hybrid/internal/hpke_encrypt_boringssl.cc
index eee9a2d..dba34ef 100644
--- a/cc/hybrid/internal/hpke_encrypt_boringssl.cc
+++ b/cc/hybrid/internal/hpke_encrypt_boringssl.cc
@@ -46,7 +46,7 @@
if (!status.ok()) {
return status;
}
- return hpke_encrypt;
+ return std::move(hpke_encrypt);
}
util::StatusOr<std::unique_ptr<HpkeEncryptBoringSsl>>
@@ -60,7 +60,7 @@
if (!status.ok()) {
return status;
}
- return hpke_encrypt;
+ return std::move(hpke_encrypt);
}
util::Status HpkeEncryptBoringSsl::Init(
diff --git a/cc/hybrid/internal/hpke_key_boringssl.cc b/cc/hybrid/internal/hpke_key_boringssl.cc
index 8d675fd..a7b4d63 100644
--- a/cc/hybrid/internal/hpke_key_boringssl.cc
+++ b/cc/hybrid/internal/hpke_key_boringssl.cc
@@ -41,7 +41,7 @@
if (!status.ok()) {
return status;
}
- return hpke_key;
+ return std::move(hpke_key);
}
util::Status HpkeKeyBoringSsl::Init(absl::string_view recipient_private_key) {
diff --git a/cc/integration/gcpkms/BUILD.bazel b/cc/integration/gcpkms/BUILD.bazel
index b29114a..5be39c9 100644
--- a/cc/integration/gcpkms/BUILD.bazel
+++ b/cc/integration/gcpkms/BUILD.bazel
@@ -10,8 +10,6 @@
visibility = ["//visibility:public"],
deps = [
"//:aead",
- "//:version",
- "//util:errors",
"//util:status",
"//util:statusor",
"@com_github_grpc_grpc//:grpc++",
@@ -28,9 +26,10 @@
visibility = ["//visibility:public"],
deps = [
":gcp_kms_aead",
+ "//:aead",
"//:kms_client",
"//:kms_clients",
- "//util:errors",
+ "//:version",
"//util:status",
"//util:statusor",
"@com_github_grpc_grpc//:grpc++",
@@ -48,7 +47,6 @@
srcs = ["gcp_kms_aead_test.cc"],
deps = [
":gcp_kms_aead",
- "//util:errors",
"//util:status",
"//util:statusor",
"@com_google_googletest//:gtest_main",
@@ -62,7 +60,6 @@
data = ["@tink_base//testdata:credentials"],
deps = [
":gcp_kms_client",
- "//util:errors",
"//util:status",
"//util:statusor",
"//util:test_matchers",
diff --git a/cc/integration/gcpkms/gcp_kms_aead.cc b/cc/integration/gcpkms/gcp_kms_aead.cc
index 4b50c4c..ae57ff1 100644
--- a/cc/integration/gcpkms/gcp_kms_aead.cc
+++ b/cc/integration/gcpkms/gcp_kms_aead.cc
@@ -26,7 +26,6 @@
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "tink/aead.h"
-#include "tink/util/errors.h"
#include "tink/util/status.h"
#include "tink/util/statusor.h"
@@ -55,11 +54,11 @@
std::shared_ptr<KeyManagementService::Stub> kms_stub) {
if (key_name.empty()) {
return Status(absl::StatusCode::kInvalidArgument,
- "Key URI cannot be empty.");
+ "Key URI cannot be empty.");
}
if (kms_stub == nullptr) {
return Status(absl::StatusCode::kInvalidArgument,
- "KMS stub cannot be null.");
+ "KMS stub cannot be null.");
}
std::unique_ptr<Aead> aead(new GcpKmsAead(key_name, kms_stub));
return std::move(aead);
@@ -80,8 +79,9 @@
auto status = kms_stub_->Encrypt(&context, req, &resp);
if (status.ok()) return resp.ciphertext();
- return ToStatusF(absl::StatusCode::kInvalidArgument,
- "GCP KMS encryption failed: %s", status.error_message());
+ return Status(
+ absl::StatusCode::kInvalidArgument,
+ absl::StrCat("GCP KMS encryption failed: ", status.error_message()));
}
StatusOr<std::string> GcpKmsAead::Decrypt(
@@ -99,8 +99,9 @@
auto status = kms_stub_->Decrypt(&context, req, &resp);
if (status.ok()) return resp.plaintext();
- return ToStatusF(absl::StatusCode::kInvalidArgument,
- "GCP KMS encryption failed: %s", status.error_message());
+ return Status(
+ absl::StatusCode::kInvalidArgument,
+ absl::StrCat("GCP KMS encryption failed: ", status.error_message()));
}
} // namespace gcpkms
diff --git a/cc/integration/gcpkms/gcp_kms_client.cc b/cc/integration/gcpkms/gcp_kms_client.cc
index 4b4234c..c90572c 100644
--- a/cc/integration/gcpkms/gcp_kms_client.cc
+++ b/cc/integration/gcpkms/gcp_kms_client.cc
@@ -32,7 +32,6 @@
#include "absl/strings/string_view.h"
#include "tink/integration/gcpkms/gcp_kms_aead.h"
#include "tink/kms_clients.h"
-#include "tink/util/errors.h"
#include "tink/util/status.h"
#include "tink/util/statusor.h"
#include "tink/version.h"
@@ -44,7 +43,6 @@
namespace {
-using crypto::tink::ToStatusF;
using crypto::tink::Version;
using crypto::tink::util::Status;
using crypto::tink::util::StatusOr;
@@ -60,8 +58,8 @@
std::ifstream input_stream;
input_stream.open(std::string(filename), std::ifstream::in);
if (!input_stream.is_open()) {
- return ToStatusF(absl::StatusCode::kInvalidArgument,
- "Error reading file %s", filename);
+ return Status(absl::StatusCode::kInvalidArgument,
+ absl::StrCat("Error reading file ", filename));
}
std::stringstream input;
input << input_stream.rdbuf();
@@ -83,16 +81,17 @@
// Try reading credentials from a file.
auto json_creds_result = ReadFile(credentials_path);
if (!json_creds_result.ok()) return json_creds_result.status();
- auto creds = grpc::ServiceAccountJWTAccessCredentials(
- json_creds_result.ValueOrDie());
+ auto creds =
+ grpc::ServiceAccountJWTAccessCredentials(json_creds_result.value());
if (creds != nullptr) {
// Creating "empty" 'channel_creds', to convert 'creds'
// to ChannelCredentials via CompositeChannelCredentials().
auto channel_creds = grpc::SslCredentials(grpc::SslCredentialsOptions());
return grpc::CompositeChannelCredentials(channel_creds, creds);
}
- return ToStatusF(absl::StatusCode::kInvalidArgument,
- "Could not load credentials from file %s", credentials_path);
+ return Status(
+ absl::StatusCode::kInvalidArgument,
+ absl::StrCat("Could not load credentials from file ", credentials_path));
}
// Returns GCP KMS key name contained in 'key_uri'.
@@ -105,17 +104,16 @@
} // namespace
// static
-StatusOr<std::unique_ptr<GcpKmsClient>>
-GcpKmsClient::New(absl::string_view key_uri,
- absl::string_view credentials_path) {
+StatusOr<std::unique_ptr<GcpKmsClient>> GcpKmsClient::New(
+ absl::string_view key_uri, absl::string_view credentials_path) {
std::unique_ptr<GcpKmsClient> client(new GcpKmsClient());
// If a specific key is given, create a GCP KMSClient.
if (!key_uri.empty()) {
client->key_name_ = GetKeyName(key_uri);
if (client->key_name_.empty()) {
- return ToStatusF(absl::StatusCode::kInvalidArgument,
- "Key '%s' not supported", key_uri);
+ return Status(absl::StatusCode::kInvalidArgument,
+ absl::StrCat("Key '", key_uri, "' not supported"));
}
}
// Read credentials.
@@ -128,8 +126,8 @@
ChannelArguments args;
args.SetUserAgentPrefix(
absl::StrCat(kTinkUserAgentPrefix, Version::kTinkVersion, " CPP-Python"));
- client->kms_stub_ = KeyManagementService::NewStub(grpc::CreateCustomChannel(
- kGcpKmsServer, creds_result.ValueOrDie(), args));
+ client->kms_stub_ = KeyManagementService::NewStub(
+ grpc::CreateCustomChannel(kGcpKmsServer, creds_result.value(), args));
return std::move(client);
}
@@ -140,16 +138,16 @@
return !GetKeyName(key_uri).empty();
}
-StatusOr<std::unique_ptr<Aead>>
-GcpKmsClient::GetAead(absl::string_view key_uri) const {
+StatusOr<std::unique_ptr<Aead>> GcpKmsClient::GetAead(
+ absl::string_view key_uri) const {
if (!DoesSupport(key_uri)) {
if (!key_name_.empty()) {
- return ToStatusF(absl::StatusCode::kInvalidArgument,
- "This client is bound to '%s', and cannot use key '%s'.",
- key_name_, key_uri);
+ return Status(absl::StatusCode::kInvalidArgument,
+ absl::StrCat("This client is bound to ", key_name_,
+ " and cannot use key ", key_uri));
} else {
- return ToStatusF(absl::StatusCode::kInvalidArgument,
- "This client does not support key '%s'.", key_uri);
+ return Status(absl::StatusCode::kInvalidArgument,
+ absl::StrCat("This client does not support key ", key_uri));
}
}
if (!key_name_.empty()) { // This client is bound to a specific key.
@@ -167,7 +165,7 @@
return client_result.status();
}
- return KmsClients::Add(std::move(client_result.ValueOrDie()));
+ return KmsClients::Add(std::move(client_result.value()));
}
} // namespace gcpkms
diff --git a/cc/internal/ec_util.cc b/cc/internal/ec_util.cc
index 38f6b37..1559275 100644
--- a/cc/internal/ec_util.cc
+++ b/cc/internal/ec_util.cc
@@ -424,7 +424,7 @@
if (!res.ok()) {
return res;
}
- return key;
+ return std::move(key);
}
EcKey EcKeyFromX25519Key(const X25519Key *x25519_key) {
diff --git a/cc/internal/keyset_wrapper_impl.h b/cc/internal/keyset_wrapper_impl.h
index 6877021..9db1b43 100644
--- a/cc/internal/keyset_wrapper_impl.h
+++ b/cc/internal/keyset_wrapper_impl.h
@@ -53,11 +53,11 @@
}
auto primitive = primitive_getter_(key.key_data());
if (!primitive.ok()) return primitive.status();
- auto entry = primitives->AddPrimitive(std::move(primitive.ValueOrDie()),
+ auto entry = primitives->AddPrimitive(std::move(primitive.value()),
KeyInfoFromKey(key));
if (!entry.ok()) return entry.status();
if (key.key_id() == keyset.primary_key_id()) {
- auto primary_result = primitives->set_primary(entry.ValueOrDie());
+ auto primary_result = primitives->set_primary(entry.value());
if (!primary_result.ok()) return primary_result;
}
}
diff --git a/cc/internal/keyset_wrapper_impl_test.cc b/cc/internal/keyset_wrapper_impl_test.cc
index 05936c1..3bda4a4 100644
--- a/cc/internal/keyset_wrapper_impl_test.cc
+++ b/cc/internal/keyset_wrapper_impl_test.cc
@@ -16,6 +16,7 @@
#include "tink/internal/keyset_wrapper_impl.h"
#include <string>
+#include <utility>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
@@ -59,7 +60,7 @@
result->back().second.append(" (primary)");
}
}
- return result;
+ return std::move(result);
}
};
@@ -104,7 +105,7 @@
wrapper_or->Wrap(keyset);
ASSERT_THAT(wrapped.status(), IsOk());
- ASSERT_THAT(*wrapped.ValueOrDie(),
+ ASSERT_THAT(*wrapped.value(),
UnorderedElementsAre(Pair(111, "one"), Pair(222, "two (primary)"),
Pair(333, "three")));
}
@@ -155,7 +156,7 @@
wrapper_or->Wrap(keyset);
ASSERT_THAT(wrapped.status(), IsOk());
- ASSERT_THAT(*wrapped.ValueOrDie(),
+ ASSERT_THAT(*wrapped.value(),
UnorderedElementsAre(Pair(111, "one"), Pair(222, "two (primary)"),
Pair(444, "four")));
}
diff --git a/cc/internal/registry_impl.cc b/cc/internal/registry_impl.cc
index c8d625a..2b68992 100644
--- a/cc/internal/registry_impl.cc
+++ b/cc/internal/registry_impl.cc
@@ -48,13 +48,13 @@
const KeyTemplate& key_template) const {
auto key_type_info_or = get_key_type_info(key_template.type_url());
if (!key_type_info_or.ok()) return key_type_info_or.status();
- if (!key_type_info_or.ValueOrDie()->new_key_allowed()) {
+ if (!key_type_info_or.value()->new_key_allowed()) {
return crypto::tink::util::Status(
absl::StatusCode::kInvalidArgument,
absl::StrCat("KeyManager for type ", key_template.type_url(),
" does not allow for creation of new keys."));
}
- return key_type_info_or.ValueOrDie()->key_factory().NewKeyData(
+ return key_type_info_or.value()->key_factory().NewKeyData(
key_template.value());
}
@@ -64,7 +64,7 @@
auto key_type_info_or = get_key_type_info(type_url);
if (!key_type_info_or.ok()) return key_type_info_or.status();
auto factory = dynamic_cast<const PrivateKeyFactory*>(
- &key_type_info_or.ValueOrDie()->key_factory());
+ &key_type_info_or.value()->key_factory());
if (factory == nullptr) {
return ToStatusF(absl::StatusCode::kInvalidArgument,
"KeyManager for type '%s' does not have "
@@ -102,14 +102,14 @@
InputStream* randomness) const {
auto key_type_info_or = get_key_type_info(key_template.type_url());
if (!key_type_info_or.ok()) return key_type_info_or.status();
- if (!key_type_info_or.ValueOrDie()->key_deriver()) {
+ if (!key_type_info_or.value()->key_deriver()) {
return crypto::tink::util::Status(
absl::StatusCode::kInvalidArgument,
absl::StrCat("Manager for type '", key_template.type_url(),
"' cannot derive keys."));
}
- return key_type_info_or.ValueOrDie()->key_deriver()(key_template.value(),
- randomness);
+ return key_type_info_or.value()->key_deriver()(key_template.value(),
+ randomness);
}
util::Status RegistryImpl::RegisterMonitoringClientFactory(
diff --git a/cc/internal/registry_impl.h b/cc/internal/registry_impl.h
index 9866880..ec5cd13 100644
--- a/cc/internal/registry_impl.h
+++ b/cc/internal/registry_impl.h
@@ -731,7 +731,7 @@
const google::crypto::tink::KeyData& key_data) const {
auto key_manager_result = get_key_manager<P>(key_data.type_url());
if (key_manager_result.ok()) {
- return key_manager_result.ValueOrDie()->GetPrimitive(key_data);
+ return key_manager_result.value()->GetPrimitive(key_data);
}
return key_manager_result.status();
}
@@ -786,7 +786,7 @@
return wrapper_result.status();
}
crypto::tink::util::StatusOr<std::unique_ptr<P>> primitive_result =
- wrapper_result.ValueOrDie()->Wrap(std::move(primitive_set));
+ wrapper_result.value()->Wrap(std::move(primitive_set));
return std::move(primitive_result);
}
@@ -799,7 +799,7 @@
return wrapper_result.status();
}
crypto::tink::util::StatusOr<std::unique_ptr<P>> primitive_result =
- wrapper_result.ValueOrDie()->Wrap(keyset);
+ wrapper_result.value()->Wrap(keyset);
return std::move(primitive_result);
}
diff --git a/cc/internal/registry_impl_test.cc b/cc/internal/registry_impl_test.cc
index d594f8e..4a02fbf 100644
--- a/cc/internal/registry_impl_test.cc
+++ b/cc/internal/registry_impl_test.cc
@@ -238,7 +238,7 @@
return randomness.status();
}
AesGcmKey key;
- key.set_key_value(randomness.ValueOrDie());
+ key.set_key_value(randomness.value());
return key;
}
@@ -296,7 +296,7 @@
std::string key_type = key_type_prefix + std::to_string(i);
auto manager_result = Registry::get_key_manager<Aead>(key_type);
EXPECT_TRUE(manager_result.ok()) << manager_result.status();
- auto manager = manager_result.ValueOrDie();
+ auto manager = manager_result.value();
EXPECT_EQ(key_type, manager->get_key_type());
}
}
@@ -398,7 +398,7 @@
std::string key_type = key_type_prefix_a + std::to_string(count_a - 1);
auto manager_result = Registry::get_key_manager<Aead>(key_type);
EXPECT_TRUE(manager_result.ok()) << manager_result.status();
- EXPECT_EQ(key_type, manager_result.ValueOrDie()->get_key_type());
+ EXPECT_EQ(key_type, manager_result.value()->get_key_type());
key_type = key_type_prefix_a + std::to_string(count_a);
manager_result = Registry::get_key_manager<Aead>(key_type);
@@ -425,13 +425,13 @@
manager_result = Registry::get_key_manager<Aead>(key_type_1);
EXPECT_TRUE(manager_result.ok()) << manager_result.status();
- auto manager = manager_result.ValueOrDie();
+ auto manager = manager_result.value();
EXPECT_TRUE(manager->DoesSupport(key_type_1));
EXPECT_FALSE(manager->DoesSupport(key_type_2));
manager_result = Registry::get_key_manager<Aead>(key_type_2);
EXPECT_TRUE(manager_result.ok()) << manager_result.status();
- manager = manager_result.ValueOrDie();
+ manager = manager_result.value();
EXPECT_TRUE(manager->DoesSupport(key_type_2));
EXPECT_FALSE(manager->DoesSupport(key_type_1));
}
@@ -464,7 +464,7 @@
// Check the key manager is still registered.
auto manager_result = Registry::get_key_manager<Aead>(key_type_1);
EXPECT_TRUE(manager_result.ok()) << manager_result.status();
- auto manager = manager_result.ValueOrDie();
+ auto manager = manager_result.value();
EXPECT_TRUE(manager->DoesSupport(key_type_1));
}
@@ -482,7 +482,7 @@
EXPECT_THAT(Registry::RegisterKeyManager(
absl::make_unique<TestAeadKeyManager>(key_type), true),
IsOk());
- EXPECT_THAT(key_manager.ValueOrDie()->get_key_type(), Eq(key_type));
+ EXPECT_THAT(key_manager.value()->get_key_type(), Eq(key_type));
}
class TestAeadCatalogue : public Catalogue<Aead> {
@@ -576,18 +576,18 @@
{
auto result = Registry::GetPrimitive<Aead>(keyset.key(0).key_data());
EXPECT_TRUE(result.ok()) << result.status();
- auto aead = std::move(result.ValueOrDie());
- EXPECT_EQ(DummyAead(key_type_1).Encrypt(plaintext, aad).ValueOrDie(),
- aead->Encrypt(plaintext, aad).ValueOrDie());
+ auto aead = std::move(result.value());
+ EXPECT_EQ(DummyAead(key_type_1).Encrypt(plaintext, aad).value(),
+ aead->Encrypt(plaintext, aad).value());
}
// Key #3.
{
auto result = Registry::GetPrimitive<Aead>(keyset.key(2).key_data());
EXPECT_TRUE(result.ok()) << result.status();
- auto aead = std::move(result.ValueOrDie());
- EXPECT_EQ(DummyAead(key_type_2).Encrypt(plaintext, aad).ValueOrDie(),
- aead->Encrypt(plaintext, aad).ValueOrDie());
+ auto aead = std::move(result.value());
+ EXPECT_EQ(DummyAead(key_type_2).Encrypt(plaintext, aad).value(),
+ aead->Encrypt(plaintext, aad).value());
}
}
@@ -617,8 +617,8 @@
key_template.set_value("test value 42");
auto new_key_data_result = Registry::NewKeyData(key_template);
EXPECT_TRUE(new_key_data_result.ok()) << new_key_data_result.status();
- EXPECT_EQ(key_type_1, new_key_data_result.ValueOrDie()->type_url());
- EXPECT_EQ(key_template.value(), new_key_data_result.ValueOrDie()->value());
+ EXPECT_EQ(key_type_1, new_key_data_result.value()->type_url());
+ EXPECT_EQ(key_template.value(), new_key_data_result.value()->value());
}
{ // Another supported key type.
@@ -627,8 +627,8 @@
key_template.set_value("yet another test value 42");
auto new_key_data_result = Registry::NewKeyData(key_template);
EXPECT_TRUE(new_key_data_result.ok()) << new_key_data_result.status();
- EXPECT_EQ(key_type_2, new_key_data_result.ValueOrDie()->type_url());
- EXPECT_EQ(key_template.value(), new_key_data_result.ValueOrDie()->value());
+ EXPECT_EQ(key_type_2, new_key_data_result.value()->type_url());
+ EXPECT_EQ(key_template.value(), new_key_data_result.value()->value());
}
{ // A key type that does not allow NewKey-operations.
@@ -687,7 +687,7 @@
EciesAeadHkdfPrivateKeyManager().get_key_type(),
ecies_key.SerializeAsString());
EXPECT_TRUE(public_key_data_result.ok()) << public_key_data_result.status();
- auto public_key_data = std::move(public_key_data_result.ValueOrDie());
+ auto public_key_data = std::move(public_key_data_result.value());
EXPECT_EQ(EciesAeadHkdfPublicKeyManager().get_key_type(),
public_key_data->type_url());
EXPECT_EQ(KeyData::ASYMMETRIC_PUBLIC, public_key_data->key_material_type());
@@ -847,7 +847,7 @@
.ok());
auto entry_result = primitive_set->AddPrimitive(
absl::make_unique<DummyAead>("primary_aead"), keyset_info.key_info(2));
- ASSERT_THAT(primitive_set->set_primary(entry_result.ValueOrDie()), IsOk());
+ ASSERT_THAT(primitive_set->set_primary(entry_result.value()), IsOk());
EXPECT_TRUE(
Registry::RegisterPrimitiveWrapper(absl::make_unique<AeadWrapper>())
@@ -855,18 +855,18 @@
auto aead_result = Registry::Wrap<Aead>(std::move(primitive_set));
EXPECT_TRUE(aead_result.ok()) << aead_result.status();
- std::unique_ptr<Aead> aead = std::move(aead_result.ValueOrDie());
+ std::unique_ptr<Aead> aead = std::move(aead_result.value());
std::string plaintext = "some_plaintext";
std::string aad = "some_aad";
auto encrypt_result = aead->Encrypt(plaintext, aad);
EXPECT_TRUE(encrypt_result.ok()) << encrypt_result.status();
- std::string ciphertext = encrypt_result.ValueOrDie();
+ std::string ciphertext = encrypt_result.value();
EXPECT_PRED_FORMAT2(testing::IsSubstring, "primary_aead", ciphertext);
auto decrypt_result = aead->Decrypt(ciphertext, aad);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
decrypt_result = aead->Decrypt("some bad ciphertext", aad);
EXPECT_FALSE(decrypt_result.ok());
@@ -915,7 +915,7 @@
crypto::tink::util::StatusOr<std::unique_ptr<AeadVariant>> aead_variant =
RegistryImpl::GlobalInstance().WrapKeyset<AeadVariant>(keyset);
EXPECT_THAT(aead_variant.status(), IsOk());
- EXPECT_THAT(aead_variant.ValueOrDie()->get(), Eq(raw_key));
+ EXPECT_THAT(aead_variant.value()->get(), Eq(raw_key));
}
// Tests that wrapping of a keyset works.
@@ -939,7 +939,7 @@
crypto::tink::util::StatusOr<std::unique_ptr<std::string>> string_primitive =
RegistryImpl::GlobalInstance().WrapKeyset<std::string>(keyset);
EXPECT_THAT(string_primitive.status(), IsOk());
- EXPECT_THAT(*string_primitive.ValueOrDie(), Eq(raw_key));
+ EXPECT_THAT(*string_primitive.value(), Eq(raw_key));
}
// Tests that when we ask the registry to wrap a PrimitiveSet<Aead> into an
@@ -1047,14 +1047,14 @@
IsOk());
AesGcmKeyFormat format;
format.set_key_size(16);
- AesGcmKey key = ExampleKeyTypeManager().CreateKey(format).ValueOrDie();
+ AesGcmKey key = ExampleKeyTypeManager().CreateKey(format).value();
auto aead = Registry::get_key_manager<Aead>(
"type.googleapis.com/google.crypto.tink.AesGcmKey")
.ValueOrDie()
->GetPrimitive(key)
- .ValueOrDie();
- std::string encryption = aead->Encrypt("TESTMESSAGE", "").ValueOrDie();
- std::string decryption = aead->Decrypt(encryption, "").ValueOrDie();
+ .value();
+ std::string encryption = aead->Encrypt("TESTMESSAGE", "").value();
+ std::string decryption = aead->Decrypt(encryption, "").value();
EXPECT_THAT(decryption, Eq("TESTMESSAGE"));
}
@@ -1068,12 +1068,12 @@
IsOk());
AesGcmKeyFormat format;
format.set_key_size(16);
- AesGcmKey key = ExampleKeyTypeManager().CreateKey(format).ValueOrDie();
+ AesGcmKey key = ExampleKeyTypeManager().CreateKey(format).value();
auto aead_variant = Registry::get_key_manager<AeadVariant>(
"type.googleapis.com/google.crypto.tink.AesGcmKey")
.ValueOrDie()
->GetPrimitive(key)
- .ValueOrDie();
+ .value();
EXPECT_THAT(aead_variant->get(), Eq(key.key_value()));
}
@@ -1110,7 +1110,7 @@
EXPECT_THAT(Registry::RegisterKeyTypeManager(
absl::make_unique<ExampleKeyTypeManager>(), true),
IsOk());
- EXPECT_THAT(key_manager.ValueOrDie()->get_key_type(),
+ EXPECT_THAT(key_manager.value()->get_key_type(),
Eq(ExampleKeyTypeManager().get_key_type()));
}
@@ -1129,7 +1129,7 @@
key_template.set_type_url("type.googleapis.com/google.crypto.tink.AesGcmKey");
key_template.set_value(format.SerializeAsString());
- KeyData key_data = *Registry::NewKeyData(key_template).ValueOrDie();
+ KeyData key_data = *Registry::NewKeyData(key_template).value();
EXPECT_THAT(key_data.type_url(),
Eq("type.googleapis.com/google.crypto.tink.AesGcmKey"));
EXPECT_THAT(key_data.key_material_type(),
@@ -1179,9 +1179,9 @@
auto key_data_or =
RegistryImpl::GlobalInstance().DeriveKey(key_template, &input_stream);
ASSERT_THAT(key_data_or.status(), IsOk());
- EXPECT_THAT(key_data_or.ValueOrDie().type_url(), Eq(key_template.type_url()));
+ EXPECT_THAT(key_data_or.value().type_url(), Eq(key_template.type_url()));
AesGcmKey key;
- EXPECT_TRUE(key.ParseFromString(key_data_or.ValueOrDie().value()));
+ EXPECT_TRUE(key.ParseFromString(key_data_or.value().value()));
// 32 byte prefix of above string.
EXPECT_THAT(key.key_value(), Eq("01234567890123456789012345678901"));
}
@@ -1213,9 +1213,9 @@
auto key_data_or =
RegistryImpl::GlobalInstance().DeriveKey(key_template, &input_stream);
ASSERT_THAT(key_data_or.status(), IsOk());
- EXPECT_THAT(key_data_or.ValueOrDie().type_url(), Eq(key_template.type_url()));
+ EXPECT_THAT(key_data_or.value().type_url(), Eq(key_template.type_url()));
AesGcmKey key;
- EXPECT_TRUE(key.ParseFromString(key_data_or.ValueOrDie().value()));
+ EXPECT_TRUE(key.ParseFromString(key_data_or.value().value()));
// 32 byte prefix of above string.
EXPECT_THAT(key.key_value(), Eq("01234567890123456789012345678901"));
}
@@ -1545,9 +1545,9 @@
CreateTestPublicKeyManagerFipsCompatible(), true),
IsOk());
- EXPECT_THAT(private_key_manager.ValueOrDie()->get_key_type(),
+ EXPECT_THAT(private_key_manager.value()->get_key_type(),
Eq(TestPrivateKeyTypeManager().get_key_type()));
- EXPECT_THAT(public_key_manager.ValueOrDie()->get_key_type(),
+ EXPECT_THAT(public_key_manager.value()->get_key_type(),
Eq(TestPublicKeyTypeManager().get_key_type()));
}
@@ -1593,7 +1593,7 @@
Registry::get_key_manager<PrivatePrimitiveA>(
TestPrivateKeyTypeManager().get_key_type());
ASSERT_TRUE(km.ok()) << km.status();
- EXPECT_THAT(km.ValueOrDie()->get_key_type(),
+ EXPECT_THAT(km.value()->get_key_type(),
Eq(TestPrivateKeyTypeManager().get_key_type()));
}
@@ -1611,7 +1611,7 @@
Registry::get_key_manager<PrivatePrimitiveB>(
TestPrivateKeyTypeManager().get_key_type());
ASSERT_TRUE(km.ok()) << km.status();
- EXPECT_THAT(km.ValueOrDie()->get_key_type(),
+ EXPECT_THAT(km.value()->get_key_type(),
Eq(TestPrivateKeyTypeManager().get_key_type()));
}
@@ -1629,7 +1629,7 @@
Registry::get_key_manager<PublicPrimitiveA>(
TestPublicKeyTypeManager().get_key_type());
ASSERT_TRUE(km.ok()) << km.status();
- EXPECT_THAT(km.ValueOrDie()->get_key_type(),
+ EXPECT_THAT(km.value()->get_key_type(),
Eq(TestPublicKeyTypeManager().get_key_type()));
}
@@ -1647,7 +1647,7 @@
Registry::get_key_manager<PublicPrimitiveB>(
TestPublicKeyTypeManager().get_key_type());
ASSERT_TRUE(km.ok()) << km.status();
- EXPECT_THAT(km.ValueOrDie()->get_key_type(),
+ EXPECT_THAT(km.value()->get_key_type(),
Eq(TestPublicKeyTypeManager().get_key_type()));
}
@@ -1698,7 +1698,7 @@
key_template.set_value(key_format.SerializeAsString());
key_template.set_output_prefix_type(OutputPrefixType::TINK);
std::unique_ptr<KeyData> key_data =
- Registry::NewKeyData(key_template).ValueOrDie();
+ Registry::NewKeyData(key_template).value();
EXPECT_THAT(key_data->type_url(),
Eq(TestPrivateKeyTypeManager().get_key_type()));
EcdsaPrivateKey private_key;
@@ -1745,7 +1745,7 @@
std::unique_ptr<KeyData> key_data =
Registry::GetPublicKeyData(TestPrivateKeyTypeManager().get_key_type(),
private_key.SerializeAsString())
- .ValueOrDie();
+ .value();
ASSERT_THAT(key_data->type_url(),
Eq(TestPublicKeyTypeManager().get_key_type()));
EcdsaPublicKey public_key;
diff --git a/cc/internal/rsa_util.cc b/cc/internal/rsa_util.cc
index 1f857d5..62398e0 100644
--- a/cc/internal/rsa_util.cc
+++ b/cc/internal/rsa_util.cc
@@ -316,7 +316,7 @@
absl::StrCat("Could not load RSA key: ", internal::GetSslErrors()));
}
#endif
- return rsa;
+ return std::move(rsa);
}
util::StatusOr<internal::SslUniquePtr<RSA>> RsaPublicKeyToRsa(
@@ -344,7 +344,7 @@
}
n->release();
e->release();
- return rsa;
+ return std::move(rsa);
}
util::Status RsaCheckPublicKey(const RSA *key) {
diff --git a/cc/internal/rsa_util_test.cc b/cc/internal/rsa_util_test.cc
index d8f4d93..bbcdc8a 100644
--- a/cc/internal/rsa_util_test.cc
+++ b/cc/internal/rsa_util_test.cc
@@ -304,7 +304,7 @@
util::StatusOr<internal::SslUniquePtr<RSA>> rsa_result =
RsaPrivateKeyToRsa(private_key);
EXPECT_TRUE(rsa_result.ok());
- internal::SslUniquePtr<RSA> rsa = std::move(rsa_result).ValueOrDie();
+ internal::SslUniquePtr<RSA> rsa = std::move(rsa_result).value();
const BIGNUM* n = nullptr;
const BIGNUM* e = nullptr;
const BIGNUM* d = nullptr;
@@ -328,7 +328,7 @@
util::StatusOr<internal::SslUniquePtr<RSA>> rsa_result =
RsaPublicKeyToRsa(public_key);
EXPECT_TRUE(rsa_result.ok());
- internal::SslUniquePtr<RSA> rsa = std::move(rsa_result).ValueOrDie();
+ internal::SslUniquePtr<RSA> rsa = std::move(rsa_result).value();
const BIGNUM* n = nullptr;
const BIGNUM* e = nullptr;
@@ -356,7 +356,7 @@
// RSA_set0_key takes ownership of the arguments.
n.release();
e.release();
- return key;
+ return std::move(key);
}
TEST(RsaUtilTest, RsaCheckPublicKeyNullKey) {
diff --git a/cc/jwt/internal/jwt_ecdsa_sign_key_manager.cc b/cc/jwt/internal/jwt_ecdsa_sign_key_manager.cc
index 6888d76..009057e 100644
--- a/cc/jwt/internal/jwt_ecdsa_sign_key_manager.cc
+++ b/cc/jwt/internal/jwt_ecdsa_sign_key_manager.cc
@@ -51,7 +51,7 @@
std::unique_ptr<JwtPublicKeySignInternal> jwt_public_key_sign =
absl::make_unique<jwt_internal::JwtPublicKeySignImpl>(*std::move(sign),
*name, custom_kid);
- return jwt_public_key_sign;
+ return std::move(jwt_public_key_sign);
}
uint32_t JwtEcdsaSignKeyManager::get_version() const {
diff --git a/cc/jwt/internal/jwt_ecdsa_verify_key_manager.cc b/cc/jwt/internal/jwt_ecdsa_verify_key_manager.cc
index 02f7a66..e6a51d5 100644
--- a/cc/jwt/internal/jwt_ecdsa_verify_key_manager.cc
+++ b/cc/jwt/internal/jwt_ecdsa_verify_key_manager.cc
@@ -48,7 +48,7 @@
std::unique_ptr<JwtPublicKeyVerifyInternal> jwt_public_key_verify =
absl::make_unique<jwt_internal::JwtPublicKeyVerifyImpl>(
*std::move(verify), *name, custom_kid);
- return jwt_public_key_verify;
+ return std::move(jwt_public_key_verify);
}
uint32_t JwtEcdsaVerifyKeyManager::get_version() const {
diff --git a/cc/jwt/internal/jwt_hmac_key_manager.h b/cc/jwt/internal/jwt_hmac_key_manager.h
index 9dc64af..03228dd 100644
--- a/cc/jwt/internal/jwt_hmac_key_manager.h
+++ b/cc/jwt/internal/jwt_hmac_key_manager.h
@@ -86,7 +86,7 @@
std::unique_ptr<JwtMacInternal> jwt_mac =
absl::make_unique<jwt_internal::JwtMacImpl>(*std::move(mac),
algorithm, custom_kid);
- return jwt_mac;
+ return std::move(jwt_mac);
}
};
diff --git a/cc/jwt/internal/jwt_public_key_sign_verify_impl_test.cc b/cc/jwt/internal/jwt_public_key_sign_verify_impl_test.cc
index c70e658..9938261 100644
--- a/cc/jwt/internal/jwt_public_key_sign_verify_impl_test.cc
+++ b/cc/jwt/internal/jwt_public_key_sign_verify_impl_test.cc
@@ -85,7 +85,7 @@
.SetExpiration(now + absl::Seconds(300))
.Build();
ASSERT_THAT(raw_jwt_or.status(), IsOk());
- RawJwt raw_jwt = raw_jwt_or.ValueOrDie();
+ RawJwt raw_jwt = raw_jwt_or.value();
util::StatusOr<std::string> compact =
jwt_sign_->SignAndEncodeWithKid(raw_jwt, /*kid=*/absl::nullopt);
diff --git a/cc/jwt/internal/jwt_rsa_ssa_pkcs1_sign_key_manager.cc b/cc/jwt/internal/jwt_rsa_ssa_pkcs1_sign_key_manager.cc
index 7b0b102..8cd220f 100644
--- a/cc/jwt/internal/jwt_rsa_ssa_pkcs1_sign_key_manager.cc
+++ b/cc/jwt/internal/jwt_rsa_ssa_pkcs1_sign_key_manager.cc
@@ -53,7 +53,7 @@
std::unique_ptr<JwtPublicKeySignInternal> jwt_public_key_sign =
absl::make_unique<jwt_internal::JwtPublicKeySignImpl>(*std::move(sign),
*name, custom_kid);
- return jwt_public_key_sign;
+ return std::move(jwt_public_key_sign);
}
uint32_t JwtRsaSsaPkcs1SignKeyManager::get_version() const {
diff --git a/cc/jwt/internal/jwt_rsa_ssa_pkcs1_sign_verify_key_manager_test.cc b/cc/jwt/internal/jwt_rsa_ssa_pkcs1_sign_verify_key_manager_test.cc
index 4931c0c..86e2e19 100644
--- a/cc/jwt/internal/jwt_rsa_ssa_pkcs1_sign_verify_key_manager_test.cc
+++ b/cc/jwt/internal/jwt_rsa_ssa_pkcs1_sign_verify_key_manager_test.cc
@@ -59,7 +59,7 @@
internal::SslUniquePtr<BIGNUM> e(BN_new());
BN_set_word(e.get(), public_exponent);
key_format.set_public_exponent(
- internal::BignumToString(e.get(), BN_num_bytes(e.get())).ValueOrDie());
+ internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
return key_format;
}
diff --git a/cc/jwt/internal/jwt_rsa_ssa_pkcs1_verify_key_manager.cc b/cc/jwt/internal/jwt_rsa_ssa_pkcs1_verify_key_manager.cc
index 1048b17..2d75ae4 100644
--- a/cc/jwt/internal/jwt_rsa_ssa_pkcs1_verify_key_manager.cc
+++ b/cc/jwt/internal/jwt_rsa_ssa_pkcs1_verify_key_manager.cc
@@ -50,7 +50,7 @@
std::unique_ptr<JwtPublicKeyVerifyInternal> jwt_public_key_verify =
absl::make_unique<jwt_internal::JwtPublicKeyVerifyImpl>(
*std::move(verify), *name, custom_kid);
- return jwt_public_key_verify;
+ return std::move(jwt_public_key_verify);
}
uint32_t JwtRsaSsaPkcs1VerifyKeyManager::get_version() const {
diff --git a/cc/jwt/internal/jwt_rsa_ssa_pss_sign_key_manager.cc b/cc/jwt/internal/jwt_rsa_ssa_pss_sign_key_manager.cc
index fd170aa..470be79 100644
--- a/cc/jwt/internal/jwt_rsa_ssa_pss_sign_key_manager.cc
+++ b/cc/jwt/internal/jwt_rsa_ssa_pss_sign_key_manager.cc
@@ -51,7 +51,7 @@
std::unique_ptr<JwtPublicKeySignInternal> jwt_public_key_sign =
absl::make_unique<jwt_internal::JwtPublicKeySignImpl>(*std::move(sign),
*name, custom_kid);
- return jwt_public_key_sign;
+ return std::move(jwt_public_key_sign);
}
uint32_t JwtRsaSsaPssSignKeyManager::get_version() const {
diff --git a/cc/jwt/internal/jwt_rsa_ssa_pss_sign_verify_key_manager_test.cc b/cc/jwt/internal/jwt_rsa_ssa_pss_sign_verify_key_manager_test.cc
index 26b28c2..bbcb94c 100644
--- a/cc/jwt/internal/jwt_rsa_ssa_pss_sign_verify_key_manager_test.cc
+++ b/cc/jwt/internal/jwt_rsa_ssa_pss_sign_verify_key_manager_test.cc
@@ -59,7 +59,7 @@
internal::SslUniquePtr<BIGNUM> e(BN_new());
BN_set_word(e.get(), public_exponent);
key_format.set_public_exponent(
- internal::BignumToString(e.get(), BN_num_bytes(e.get())).ValueOrDie());
+ internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
return key_format;
}
diff --git a/cc/jwt/internal/jwt_rsa_ssa_pss_verify_key_manager.cc b/cc/jwt/internal/jwt_rsa_ssa_pss_verify_key_manager.cc
index 9057685..c6813b0 100644
--- a/cc/jwt/internal/jwt_rsa_ssa_pss_verify_key_manager.cc
+++ b/cc/jwt/internal/jwt_rsa_ssa_pss_verify_key_manager.cc
@@ -50,7 +50,7 @@
std::unique_ptr<JwtPublicKeyVerifyInternal> jwt_public_key_verify =
absl::make_unique<jwt_internal::JwtPublicKeyVerifyImpl>(
*std::move(verify), *name, custom_kid);
- return jwt_public_key_verify;
+ return std::move(jwt_public_key_verify);
}
uint32_t JwtRsaSsaPssVerifyKeyManager::get_version() const {
diff --git a/cc/jwt/internal/raw_jwt_ecdsa_sign_key_manager_test.cc b/cc/jwt/internal/raw_jwt_ecdsa_sign_key_manager_test.cc
index 49967a2..19ccf71 100644
--- a/cc/jwt/internal/raw_jwt_ecdsa_sign_key_manager_test.cc
+++ b/cc/jwt/internal/raw_jwt_ecdsa_sign_key_manager_test.cc
@@ -116,7 +116,7 @@
JwtEcdsaPrivateKey CreateValidEs256Key() {
JwtEcdsaKeyFormat format = CreateValidEs256KeyFormat();
- return RawJwtEcdsaSignKeyManager().CreateKey(format).ValueOrDie();
+ return RawJwtEcdsaSignKeyManager().CreateKey(format).value();
}
TEST(RawJwtEcdsaSignKeyManagerTest, ValidateKey) {
diff --git a/cc/jwt/internal/raw_jwt_ecdsa_verify_key_manager_test.cc b/cc/jwt/internal/raw_jwt_ecdsa_verify_key_manager_test.cc
index 7d92080..7291449 100644
--- a/cc/jwt/internal/raw_jwt_ecdsa_verify_key_manager_test.cc
+++ b/cc/jwt/internal/raw_jwt_ecdsa_verify_key_manager_test.cc
@@ -69,13 +69,13 @@
JwtEcdsaPrivateKey CreateValidEs256PrivateKey() {
JwtEcdsaKeyFormat key_format;
key_format.set_algorithm(JwtEcdsaAlgorithm::ES256);
- return RawJwtEcdsaSignKeyManager().CreateKey(key_format).ValueOrDie();
+ return RawJwtEcdsaSignKeyManager().CreateKey(key_format).value();
}
JwtEcdsaPublicKey CreateValidPublicKey() {
return RawJwtEcdsaSignKeyManager()
.GetPublicKey(CreateValidEs256PrivateKey())
- .ValueOrDie();
+ .value();
}
// Checks that a public key generaed by the SignKeyManager is considered valid.
@@ -96,7 +96,7 @@
TEST(EcdsaSignKeyManagerTest, Create) {
JwtEcdsaPrivateKey private_key = CreateValidEs256PrivateKey();
JwtEcdsaPublicKey public_key =
- RawJwtEcdsaSignKeyManager().GetPublicKey(private_key).ValueOrDie();
+ RawJwtEcdsaSignKeyManager().GetPublicKey(private_key).value();
internal::EcKey ec_key;
ec_key.curve = Enums::ProtoToSubtle(EllipticCurveType::NIST_P256);
diff --git a/cc/jwt/internal/raw_jwt_hmac_key_manager_test.cc b/cc/jwt/internal/raw_jwt_hmac_key_manager_test.cc
index 13d6d7e..3bf9a3a 100644
--- a/cc/jwt/internal/raw_jwt_hmac_key_manager_test.cc
+++ b/cc/jwt/internal/raw_jwt_hmac_key_manager_test.cc
@@ -97,13 +97,11 @@
key_format.set_algorithm(JwtHmacAlgorithm::HS256);
auto hmac_key_or = RawJwtHmacKeyManager().CreateKey(key_format);
ASSERT_THAT(hmac_key_or.status(), IsOk());
- EXPECT_THAT(hmac_key_or.ValueOrDie().version(), Eq(0));
- EXPECT_THAT(hmac_key_or.ValueOrDie().algorithm(), Eq(key_format.algorithm()));
- EXPECT_THAT(hmac_key_or.ValueOrDie().key_value(),
- SizeIs(key_format.key_size()));
+ EXPECT_THAT(hmac_key_or.value().version(), Eq(0));
+ EXPECT_THAT(hmac_key_or.value().algorithm(), Eq(key_format.algorithm()));
+ EXPECT_THAT(hmac_key_or.value().key_value(), SizeIs(key_format.key_size()));
- EXPECT_THAT(RawJwtHmacKeyManager().ValidateKey(hmac_key_or.ValueOrDie()),
- IsOk());
+ EXPECT_THAT(RawJwtHmacKeyManager().ValidateKey(hmac_key_or.value()), IsOk());
}
TEST(RawJwtHmacKeyManagerTest, CreateKeyWithSha384) {
@@ -112,13 +110,11 @@
key_format.set_algorithm(JwtHmacAlgorithm::HS384);
auto hmac_key_or = RawJwtHmacKeyManager().CreateKey(key_format);
ASSERT_THAT(hmac_key_or.status(), IsOk());
- EXPECT_THAT(hmac_key_or.ValueOrDie().version(), Eq(0));
- EXPECT_THAT(hmac_key_or.ValueOrDie().algorithm(), Eq(key_format.algorithm()));
- EXPECT_THAT(hmac_key_or.ValueOrDie().key_value(),
- SizeIs(key_format.key_size()));
+ EXPECT_THAT(hmac_key_or.value().version(), Eq(0));
+ EXPECT_THAT(hmac_key_or.value().algorithm(), Eq(key_format.algorithm()));
+ EXPECT_THAT(hmac_key_or.value().key_value(), SizeIs(key_format.key_size()));
- EXPECT_THAT(RawJwtHmacKeyManager().ValidateKey(hmac_key_or.ValueOrDie()),
- IsOk());
+ EXPECT_THAT(RawJwtHmacKeyManager().ValidateKey(hmac_key_or.value()), IsOk());
}
TEST(RawJwtHmacKeyManagerTest, CreateKeyWithSha512) {
@@ -127,13 +123,11 @@
key_format.set_algorithm(JwtHmacAlgorithm::HS512);
auto key_or = RawJwtHmacKeyManager().CreateKey(key_format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().version(), Eq(0));
- EXPECT_THAT(key_or.ValueOrDie().algorithm(), Eq(key_format.algorithm()));
- EXPECT_THAT(key_or.ValueOrDie().key_value(),
- SizeIs(key_format.key_size()));
+ EXPECT_THAT(key_or.value().version(), Eq(0));
+ EXPECT_THAT(key_or.value().algorithm(), Eq(key_format.algorithm()));
+ EXPECT_THAT(key_or.value().key_value(), SizeIs(key_format.key_size()));
- EXPECT_THAT(RawJwtHmacKeyManager().ValidateKey(key_or.ValueOrDie()),
- IsOk());
+ EXPECT_THAT(RawJwtHmacKeyManager().ValidateKey(key_or.value()), IsOk());
}
TEST(RawJwtHmacKeyManagerTest, ShortKeyIsInvalid) {
@@ -183,14 +177,14 @@
auto handle_result = KeysetHandle::GenerateNew(key_template);
ASSERT_TRUE(handle_result.ok()) << handle_result.status();
- std::unique_ptr<KeysetHandle> handle = std::move(handle_result.ValueOrDie());
+ std::unique_ptr<KeysetHandle> handle = std::move(handle_result.value());
auto mac_result = handle->GetPrimitive<Mac>();
ASSERT_TRUE(mac_result.ok()) << mac_result.status();
- std::unique_ptr<Mac> mac = std::move(mac_result.ValueOrDie());
+ std::unique_ptr<Mac> mac = std::move(mac_result.value());
auto tag_or = mac->ComputeMac("some plaintext");
ASSERT_THAT(tag_or.status(), IsOk());
- EXPECT_THAT(mac->VerifyMac(tag_or.ValueOrDie(), "some plaintext"), IsOk());
+ EXPECT_THAT(mac->VerifyMac(tag_or.value(), "some plaintext"), IsOk());
}
} // namespace
diff --git a/cc/jwt/internal/raw_jwt_rsa_ssa_pkcs1_sign_key_manager_test.cc b/cc/jwt/internal/raw_jwt_rsa_ssa_pkcs1_sign_key_manager_test.cc
index b5f8243..bca88fa 100644
--- a/cc/jwt/internal/raw_jwt_rsa_ssa_pkcs1_sign_key_manager_test.cc
+++ b/cc/jwt/internal/raw_jwt_rsa_ssa_pkcs1_sign_key_manager_test.cc
@@ -69,7 +69,7 @@
internal::SslUniquePtr<BIGNUM> e(BN_new());
BN_set_word(e.get(), public_exponent);
key_format.set_public_exponent(
- internal::BignumToString(e.get(), BN_num_bytes(e.get())).ValueOrDie());
+ internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
return key_format;
}
diff --git a/cc/jwt/internal/raw_jwt_rsa_ssa_pkcs1_verify_key_manager_test.cc b/cc/jwt/internal/raw_jwt_rsa_ssa_pkcs1_verify_key_manager_test.cc
index 35226cb..c72f16e 100644
--- a/cc/jwt/internal/raw_jwt_rsa_ssa_pkcs1_verify_key_manager_test.cc
+++ b/cc/jwt/internal/raw_jwt_rsa_ssa_pkcs1_verify_key_manager_test.cc
@@ -80,7 +80,7 @@
internal::SslUniquePtr<BIGNUM> e(BN_new());
BN_set_word(e.get(), public_exponent);
key_format.set_public_exponent(
- internal::BignumToString(e.get(), BN_num_bytes(e.get())).ValueOrDie());
+ internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
return key_format;
}
@@ -89,15 +89,13 @@
}
JwtRsaSsaPkcs1PrivateKey CreateValidPrivateKey() {
- return RawJwtRsaSsaPkcs1SignKeyManager()
- .CreateKey(ValidKeyFormat())
- .ValueOrDie();
+ return RawJwtRsaSsaPkcs1SignKeyManager().CreateKey(ValidKeyFormat()).value();
}
JwtRsaSsaPkcs1PublicKey CreateValidPublicKey() {
return RawJwtRsaSsaPkcs1SignKeyManager()
.GetPublicKey(CreateValidPrivateKey())
- .ValueOrDie();
+ .value();
}
// Checks that a public key generaed by the SignKeyManager is considered valid.
diff --git a/cc/jwt/internal/raw_jwt_rsa_ssa_pss_sign_key_manager_test.cc b/cc/jwt/internal/raw_jwt_rsa_ssa_pss_sign_key_manager_test.cc
index 31d9206..b4f49d3 100644
--- a/cc/jwt/internal/raw_jwt_rsa_ssa_pss_sign_key_manager_test.cc
+++ b/cc/jwt/internal/raw_jwt_rsa_ssa_pss_sign_key_manager_test.cc
@@ -69,7 +69,7 @@
internal::SslUniquePtr<BIGNUM> e(BN_new());
BN_set_word(e.get(), public_exponent);
key_format.set_public_exponent(
- internal::BignumToString(e.get(), BN_num_bytes(e.get())).ValueOrDie());
+ internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
return key_format;
}
diff --git a/cc/jwt/internal/raw_jwt_rsa_ssa_pss_verify_key_manager.cc b/cc/jwt/internal/raw_jwt_rsa_ssa_pss_verify_key_manager.cc
index 0cc33c5..baabdf9 100644
--- a/cc/jwt/internal/raw_jwt_rsa_ssa_pss_verify_key_manager.cc
+++ b/cc/jwt/internal/raw_jwt_rsa_ssa_pss_verify_key_manager.cc
@@ -62,8 +62,8 @@
return salt_length.status();
}
internal::RsaSsaPssParams params;
- params.sig_hash = Enums::ProtoToSubtle(hash_or.ValueOrDie());
- params.mgf1_hash = Enums::ProtoToSubtle(hash_or.ValueOrDie());
+ params.sig_hash = Enums::ProtoToSubtle(hash_or.value());
+ params.mgf1_hash = Enums::ProtoToSubtle(hash_or.value());
params.salt_length = *salt_length;
util::StatusOr<std::unique_ptr<RsaSsaPssVerifyBoringSsl>> verify =
diff --git a/cc/jwt/internal/raw_jwt_rsa_ssa_pss_verify_key_manager_test.cc b/cc/jwt/internal/raw_jwt_rsa_ssa_pss_verify_key_manager_test.cc
index 3a568e2..50acca1 100644
--- a/cc/jwt/internal/raw_jwt_rsa_ssa_pss_verify_key_manager_test.cc
+++ b/cc/jwt/internal/raw_jwt_rsa_ssa_pss_verify_key_manager_test.cc
@@ -76,7 +76,7 @@
internal::SslUniquePtr<BIGNUM> e(BN_new());
BN_set_word(e.get(), public_exponent);
key_format.set_public_exponent(
- internal::BignumToString(e.get(), BN_num_bytes(e.get())).ValueOrDie());
+ internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
return key_format;
}
@@ -86,8 +86,8 @@
RawJwtRsaSsaPssSignKeyManager()
.CreateKey(
CreateKeyFormat(JwtRsaSsaPssAlgorithm::PS256, 3072, RSA_F4))
- .ValueOrDie();
- return RawJwtRsaSsaPssSignKeyManager().GetPublicKey(private_key).ValueOrDie();
+ .value();
+ return RawJwtRsaSsaPssSignKeyManager().GetPublicKey(private_key).value();
}
// Checks that a public key generaed by the SignKeyManager is considered valid.
diff --git a/cc/jwt/jwt_key_templates.cc b/cc/jwt/jwt_key_templates.cc
index 7bdc77c..ad4068d 100644
--- a/cc/jwt/jwt_key_templates.cc
+++ b/cc/jwt/jwt_key_templates.cc
@@ -87,7 +87,7 @@
BN_set_word(e.get(), public_exponent);
util::StatusOr<std::string> e_str =
internal::BignumToString(e.get(), BN_num_bytes(e.get()));
- key_format.set_public_exponent(e_str.ValueOrDie());
+ key_format.set_public_exponent(e_str.value());
key_format.SerializeToString(key_template->mutable_value());
return key_template;
}
@@ -107,7 +107,7 @@
BN_set_word(e.get(), public_exponent);
util::StatusOr<std::string> e_str =
internal::BignumToString(e.get(), BN_num_bytes(e.get()));
- key_format.set_public_exponent(e_str.ValueOrDie());
+ key_format.set_public_exponent(e_str.value());
key_format.SerializeToString(key_template->mutable_value());
return key_template;
}
diff --git a/cc/keyset_handle.h b/cc/keyset_handle.h
index 377e171..60296fe 100644
--- a/cc/keyset_handle.h
+++ b/cc/keyset_handle.h
@@ -160,18 +160,17 @@
custom_manager->DoesSupport(key.key_data().type_url())) {
auto primitive_result = custom_manager->GetPrimitive(key.key_data());
if (!primitive_result.ok()) return primitive_result.status();
- primitive = std::move(primitive_result.ValueOrDie());
+ primitive = std::move(primitive_result.value());
} else {
auto primitive_result = Registry::GetPrimitive<P>(key.key_data());
if (!primitive_result.ok()) return primitive_result.status();
- primitive = std::move(primitive_result.ValueOrDie());
+ primitive = std::move(primitive_result.value());
}
auto entry_result =
primitives->AddPrimitive(std::move(primitive), KeyInfoFromKey(key));
if (!entry_result.ok()) return entry_result.status();
if (key.key_id() == get_keyset().primary_key_id()) {
- auto primary_result =
- primitives->set_primary(entry_result.ValueOrDie());
+ auto primary_result = primitives->set_primary(entry_result.value());
if (!primary_result.ok()) return primary_result;
}
}
@@ -196,7 +195,7 @@
if (!primitives_result.ok()) {
return primitives_result.status();
}
- return Registry::Wrap<P>(std::move(primitives_result.ValueOrDie()));
+ return Registry::Wrap<P>(std::move(primitives_result.value()));
}
} // namespace tink
diff --git a/cc/mac/aes_cmac_key_manager_test.cc b/cc/mac/aes_cmac_key_manager_test.cc
index 91027db..51c50cc 100644
--- a/cc/mac/aes_cmac_key_manager_test.cc
+++ b/cc/mac/aes_cmac_key_manager_test.cc
@@ -131,7 +131,7 @@
TEST(AesCmacKeyManagerTest, CreateKey) {
AesCmacKeyFormat format = ValidKeyFormat();
ASSERT_THAT(AesCmacKeyManager().CreateKey(format).status(), IsOk());
- AesCmacKey key = AesCmacKeyManager().CreateKey(format).ValueOrDie();
+ AesCmacKey key = AesCmacKeyManager().CreateKey(format).value();
EXPECT_THAT(key.version(), Eq(0));
EXPECT_THAT(key.key_value(), SizeIs(format.key_size()));
EXPECT_THAT(key.params().tag_size(), Eq(format.params().tag_size()));
@@ -139,27 +139,27 @@
TEST(AesCmacKeyManagerTest, ValidateKey) {
AesCmacKeyFormat format = ValidKeyFormat();
- AesCmacKey key = AesCmacKeyManager().CreateKey(format).ValueOrDie();
+ AesCmacKey key = AesCmacKeyManager().CreateKey(format).value();
EXPECT_THAT(AesCmacKeyManager().ValidateKey(key), IsOk());
}
TEST(AesCmacKeyManagerTest, ValidateKeyInvalidVersion) {
AesCmacKeyFormat format = ValidKeyFormat();
- AesCmacKey key = AesCmacKeyManager().CreateKey(format).ValueOrDie();
+ AesCmacKey key = AesCmacKeyManager().CreateKey(format).value();
key.set_version(1);
EXPECT_THAT(AesCmacKeyManager().ValidateKey(key), Not(IsOk()));
}
TEST(AesCmacKeyManagerTest, ValidateKeyShortKey) {
AesCmacKeyFormat format = ValidKeyFormat();
- AesCmacKey key = AesCmacKeyManager().CreateKey(format).ValueOrDie();
+ AesCmacKey key = AesCmacKeyManager().CreateKey(format).value();
key.set_key_value("0123456789abcdef");
EXPECT_THAT(AesCmacKeyManager().ValidateKey(key), Not(IsOk()));
}
TEST(AesCmacKeyManagerTest, ValidateKeyLongTagSize) {
AesCmacKeyFormat format = ValidKeyFormat();
- AesCmacKey key = AesCmacKeyManager().CreateKey(format).ValueOrDie();
+ AesCmacKey key = AesCmacKeyManager().CreateKey(format).value();
key.mutable_params()->set_tag_size(17);
EXPECT_THAT(AesCmacKeyManager().ValidateKey(key), Not(IsOk()));
}
@@ -167,24 +167,25 @@
TEST(AesCmacKeyManagerTest, ValidateKeyTooShortTagSize) {
AesCmacKeyFormat format = ValidKeyFormat();
- AesCmacKey key = AesCmacKeyManager().CreateKey(format).ValueOrDie();
+ AesCmacKey key = AesCmacKeyManager().CreateKey(format).value();
key.mutable_params()->set_tag_size(9);
EXPECT_THAT(AesCmacKeyManager().ValidateKey(key), Not(IsOk()));
}
TEST(AesCmacKeyManagerTest, GetPrimitive) {
AesCmacKeyFormat format = ValidKeyFormat();
- AesCmacKey key = AesCmacKeyManager().CreateKey(format).ValueOrDie();
+ AesCmacKey key = AesCmacKeyManager().CreateKey(format).value();
auto manager_mac_or = AesCmacKeyManager().GetPrimitive<Mac>(key);
ASSERT_THAT(manager_mac_or.status(), IsOk());
- auto mac_value_or = manager_mac_or.ValueOrDie()->ComputeMac("some plaintext");
+ auto mac_value_or = manager_mac_or.value()->ComputeMac("some plaintext");
ASSERT_THAT(mac_value_or.status(), IsOk());
auto direct_mac_or = subtle::AesCmacBoringSsl::New(
util::SecretDataFromStringView(key.key_value()), key.params().tag_size());
ASSERT_THAT(direct_mac_or.status(), IsOk());
- EXPECT_THAT(direct_mac_or.ValueOrDie()->VerifyMac(mac_value_or.ValueOrDie(),
- "some plaintext"), IsOk());
+ EXPECT_THAT(
+ direct_mac_or.value()->VerifyMac(mac_value_or.value(), "some plaintext"),
+ IsOk());
}
} // namespace
diff --git a/cc/mac/hmac_key_manager.cc b/cc/mac/hmac_key_manager.cc
index 59bb744..4c32946 100644
--- a/cc/mac/hmac_key_manager.cc
+++ b/cc/mac/hmac_key_manager.cc
@@ -83,7 +83,7 @@
HmacKey hmac_key;
hmac_key.set_version(get_version());
*(hmac_key.mutable_params()) = hmac_key_format.params();
- hmac_key.set_key_value(randomness.ValueOrDie());
+ hmac_key.set_key_value(randomness.value());
return hmac_key;
}
diff --git a/cc/mac/hmac_key_manager_test.cc b/cc/mac/hmac_key_manager_test.cc
index 23390dd..f3254ad 100644
--- a/cc/mac/hmac_key_manager_test.cc
+++ b/cc/mac/hmac_key_manager_test.cc
@@ -154,15 +154,13 @@
key_format.mutable_params()->set_hash(HashType::SHA512);
auto hmac_key_or = HmacKeyManager().CreateKey(key_format);
ASSERT_THAT(hmac_key_or.status(), IsOk());
- EXPECT_EQ(hmac_key_or.ValueOrDie().version(), 0);
- EXPECT_EQ(hmac_key_or.ValueOrDie().params().hash(),
- key_format.params().hash());
- EXPECT_EQ(hmac_key_or.ValueOrDie().params().tag_size(),
+ EXPECT_EQ(hmac_key_or.value().version(), 0);
+ EXPECT_EQ(hmac_key_or.value().params().hash(), key_format.params().hash());
+ EXPECT_EQ(hmac_key_or.value().params().tag_size(),
key_format.params().tag_size());
- EXPECT_THAT(hmac_key_or.ValueOrDie().key_value(),
- SizeIs(key_format.key_size()));
+ EXPECT_THAT(hmac_key_or.value().key_value(), SizeIs(key_format.key_size()));
- EXPECT_THAT(HmacKeyManager().ValidateKey(hmac_key_or.ValueOrDie()), IsOk());
+ EXPECT_THAT(HmacKeyManager().ValidateKey(hmac_key_or.value()), IsOk());
}
TEST(HmacKeyManagerTest, ValidKey) {
@@ -259,10 +257,9 @@
StatusOr<HmacKey> key_or = HmacKeyManager().DeriveKey(format, &input_stream);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_EQ(key_or.ValueOrDie().key_value(), "0123456789abcdefghijklm");
- EXPECT_EQ(key_or.ValueOrDie().params().hash(), format.params().hash());
- EXPECT_EQ(key_or.ValueOrDie().params().tag_size(),
- format.params().tag_size());
+ EXPECT_EQ(key_or.value().key_value(), "0123456789abcdefghijklm");
+ EXPECT_EQ(key_or.value().params().hash(), format.params().hash());
+ EXPECT_EQ(key_or.value().params().tag_size(), format.params().tag_size());
}
TEST(HmacKeyManagerTest, DeriveKeyNotEnoughRandomness) {
@@ -299,19 +296,19 @@
key_format.mutable_params()->set_tag_size(16);
key_format.mutable_params()->set_hash(HashType::SHA256);
key_format.set_key_size(16);
- HmacKey key = HmacKeyManager().CreateKey(key_format).ValueOrDie();
+ HmacKey key = HmacKeyManager().CreateKey(key_format).value();
auto manager_mac_or = HmacKeyManager().GetPrimitive<Mac>(key);
ASSERT_THAT(manager_mac_or.status(), IsOk());
- auto mac_value_or = manager_mac_or.ValueOrDie()->ComputeMac("some plaintext");
+ auto mac_value_or = manager_mac_or.value()->ComputeMac("some plaintext");
ASSERT_THAT(mac_value_or.status(), IsOk());
auto direct_mac_or = subtle::HmacBoringSsl::New(
util::Enums::ProtoToSubtle(key.params().hash()), key.params().tag_size(),
util::SecretDataFromStringView(key.key_value()));
ASSERT_THAT(direct_mac_or.status(), IsOk());
- EXPECT_THAT(direct_mac_or.ValueOrDie()->VerifyMac(mac_value_or.ValueOrDie(),
- "some plaintext"),
- IsOk());
+ EXPECT_THAT(
+ direct_mac_or.value()->VerifyMac(mac_value_or.value(), "some plaintext"),
+ IsOk());
}
} // namespace
diff --git a/cc/mac/mac_config_test.cc b/cc/mac/mac_config_test.cc
index defdd4a..6e8b867 100644
--- a/cc/mac/mac_config_test.cc
+++ b/cc/mac/mac_config_test.cc
@@ -80,21 +80,19 @@
->set_primary(
primitive_set
->AddPrimitive(absl::make_unique<DummyMac>("dummy"), key_info)
- .ValueOrDie())
+ .value())
.ok());
auto primitive_result = Registry::Wrap(std::move(primitive_set));
ASSERT_TRUE(primitive_result.ok()) << primitive_result.status();
- auto mac_result =
- primitive_result.ValueOrDie()->ComputeMac("verified text");
+ auto mac_result = primitive_result.value()->ComputeMac("verified text");
ASSERT_TRUE(mac_result.ok());
- EXPECT_TRUE(DummyMac("dummy")
- .VerifyMac(mac_result.ValueOrDie(), "verified text")
- .ok());
+ EXPECT_TRUE(
+ DummyMac("dummy").VerifyMac(mac_result.value(), "verified text").ok());
EXPECT_FALSE(
- DummyMac("dummy").VerifyMac(mac_result.ValueOrDie(), "faked text").ok());
+ DummyMac("dummy").VerifyMac(mac_result.value(), "faked text").ok());
}
// FIPS-only mode tests
diff --git a/cc/mac/mac_factory_test.cc b/cc/mac/mac_factory_test.cc
index e40eee1..7e70f5c 100644
--- a/cc/mac/mac_factory_test.cc
+++ b/cc/mac/mac_factory_test.cc
@@ -75,17 +75,17 @@
// Prepare a Keyset.
Keyset keyset;
uint32_t key_id_1 = 1234543;
- auto new_key = std::move(key_factory.NewKey(key_format).ValueOrDie());
+ auto new_key = std::move(key_factory.NewKey(key_format).value());
AddTinkKey(key_type, key_id_1, *new_key, KeyStatusType::ENABLED,
KeyData::SYMMETRIC, &keyset);
uint32_t key_id_2 = 726329;
- new_key = std::move(key_factory.NewKey(key_format).ValueOrDie());
+ new_key = std::move(key_factory.NewKey(key_format).value());
AddRawKey(key_type, key_id_2, *new_key, KeyStatusType::ENABLED,
KeyData::SYMMETRIC, &keyset);
uint32_t key_id_3 = 7213743;
- new_key = std::move(key_factory.NewKey(key_format).ValueOrDie());
+ new_key = std::move(key_factory.NewKey(key_format).value());
AddTinkKey(key_type, key_id_3, *new_key, KeyStatusType::ENABLED,
KeyData::SYMMETRIC, &keyset);
@@ -98,16 +98,16 @@
auto mac_result =
MacFactory::GetPrimitive(*TestKeysetHandle::GetKeysetHandle(keyset));
EXPECT_TRUE(mac_result.ok()) << mac_result.status();
- auto mac = std::move(mac_result.ValueOrDie());
+ auto mac = std::move(mac_result.value());
// Test the resulting Mac-instance.
std::string data = "some_data_for_mac";
auto compute_mac_result = mac->ComputeMac(data);
EXPECT_TRUE(compute_mac_result.ok()) << compute_mac_result.status();
- std::string mac_value = compute_mac_result.ValueOrDie();
+ std::string mac_value = compute_mac_result.value();
std::string prefix =
- CryptoFormat::GetOutputPrefix(KeyInfoFromKey(keyset.key(2))).ValueOrDie();
+ CryptoFormat::GetOutputPrefix(KeyInfoFromKey(keyset.key(2))).value();
EXPECT_PRED_FORMAT2(testing::IsSubstring, prefix, mac_value);
util::Status status = mac->VerifyMac(mac_value, data);
@@ -126,9 +126,9 @@
std::string(status.message()));
// Create raw MAC value with 2nd key, and verify with Mac-instance.
- auto raw_mac = std::move(
- key_manager->GetPrimitive(keyset.key(1).key_data()).ValueOrDie());
- std::string raw_mac_value = raw_mac->ComputeMac(data).ValueOrDie();
+ auto raw_mac =
+ std::move(key_manager->GetPrimitive(keyset.key(1).key_data()).value());
+ std::string raw_mac_value = raw_mac->ComputeMac(data).value();
status = mac->VerifyMac(raw_mac_value, data);
EXPECT_TRUE(status.ok()) << status;
}
diff --git a/cc/mac/mac_wrapper.cc b/cc/mac/mac_wrapper.cc
index 196c5a9..1e825f6 100644
--- a/cc/mac/mac_wrapper.cc
+++ b/cc/mac/mac_wrapper.cc
@@ -82,7 +82,7 @@
auto compute_mac_result = primary->get_primitive().ComputeMac(data);
if (!compute_mac_result.ok()) return compute_mac_result.status();
const std::string& key_id = primary->get_identifier();
- return key_id + compute_mac_result.ValueOrDie();
+ return key_id + compute_mac_result.value();
}
util::Status MacSetWrapper::VerifyMac(
@@ -98,7 +98,7 @@
if (primitives_result.ok()) {
absl::string_view raw_mac_value =
mac_value.substr(CryptoFormat::kNonRawPrefixSize);
- for (auto& mac_entry : *(primitives_result.ValueOrDie())) {
+ for (auto& mac_entry : *(primitives_result.value())) {
std::string legacy_data;
absl::string_view view_on_data_or_legacy_data = data;
if (mac_entry->get_output_prefix_type() == OutputPrefixType::LEGACY) {
@@ -120,7 +120,7 @@
// No matching key succeeded with verification, try all RAW keys.
auto raw_primitives_result = mac_set_->get_raw_primitives();
if (raw_primitives_result.ok()) {
- for (auto& mac_entry : *(raw_primitives_result.ValueOrDie())) {
+ for (auto& mac_entry : *(raw_primitives_result.value())) {
Mac& mac = mac_entry->get_primitive();
util::Status status = mac.VerifyMac(mac_value, data);
if (status.ok()) {
diff --git a/cc/mac/mac_wrapper_test.cc b/cc/mac/mac_wrapper_test.cc
index 95d324d..b40e970 100644
--- a/cc/mac/mac_wrapper_test.cc
+++ b/cc/mac/mac_wrapper_test.cc
@@ -92,17 +92,17 @@
keyset_info.key_info(2));
ASSERT_TRUE(entry_result.ok());
// The last key is the primary.
- ASSERT_THAT(mac_set->set_primary(entry_result.ValueOrDie()), IsOk());
+ ASSERT_THAT(mac_set->set_primary(entry_result.value()), IsOk());
// Wrap mac_set and test the resulting Mac.
auto mac_result = MacWrapper().Wrap(std::move(mac_set));
EXPECT_TRUE(mac_result.ok()) << mac_result.status();
- std::unique_ptr<Mac> mac = std::move(mac_result.ValueOrDie());
+ std::unique_ptr<Mac> mac = std::move(mac_result.value());
std::string data = "some_data_for_mac";
auto compute_mac_result = mac->ComputeMac(data);
EXPECT_TRUE(compute_mac_result.ok()) << compute_mac_result.status();
- std::string mac_value = compute_mac_result.ValueOrDie();
+ std::string mac_value = compute_mac_result.value();
EXPECT_PRED_FORMAT2(testing::IsSubstring, mac_name_2, mac_value);
util::Status status = mac->VerifyMac(mac_value, data);
@@ -128,18 +128,18 @@
std::unique_ptr<Mac> mac(new DummyMac(mac_name));
auto entry_result = mac_set->AddPrimitive(std::move(mac), key_info);
ASSERT_TRUE(entry_result.ok());
- ASSERT_THAT(mac_set->set_primary(entry_result.ValueOrDie()), IsOk());
+ ASSERT_THAT(mac_set->set_primary(entry_result.value()), IsOk());
// Wrap mac_set and test the resulting Mac.
auto mac_result = MacWrapper().Wrap(std::move(mac_set));
EXPECT_TRUE(mac_result.ok()) << mac_result.status();
- mac = std::move(mac_result.ValueOrDie());
+ mac = std::move(mac_result.value());
std::string data = "Some data to authenticate";
// Compute and verify MAC via wrapper.
auto compute_mac_result = mac->ComputeMac(data);
EXPECT_TRUE(compute_mac_result.ok()) << compute_mac_result.status();
- std::string mac_value = compute_mac_result.ValueOrDie();
+ std::string mac_value = compute_mac_result.value();
EXPECT_PRED_FORMAT2(testing::IsSubstring, mac_name, mac_value);
auto status = mac->VerifyMac(mac_value, data);
EXPECT_TRUE(status.ok()) << status;
@@ -168,7 +168,7 @@
crypto::tink::util::Status VerifyMac(absl::string_view mac,
absl::string_view data) const override {
- if (mac != ComputeMac(data).ValueOrDie()) {
+ if (mac != ComputeMac(data).value()) {
return absl::InvalidArgumentError("Wrong mac");
}
return util::OkStatus();
@@ -197,16 +197,15 @@
auto entry1 =
mac_set->AddPrimitive(absl::make_unique<DummyMac>(""), key_info_1);
ASSERT_THAT(entry1.status(), IsOk());
- ASSERT_THAT(mac_set->set_primary(entry1.ValueOrDie()), IsOk());
+ ASSERT_THAT(mac_set->set_primary(entry1.value()), IsOk());
// Wrap mac_set and test the resulting Mac.
auto wrapped_mac = MacWrapper().Wrap(std::move(mac_set));
EXPECT_THAT(wrapped_mac.status(), IsOk());
std::string data = "some data";
- std::string mac_tag = TryBreakLegacyMac().ComputeMac(data).ValueOrDie();
- EXPECT_THAT(wrapped_mac.ValueOrDie()->VerifyMac(mac_tag, data),
- IsOk());
+ std::string mac_tag = TryBreakLegacyMac().ComputeMac(data).value();
+ EXPECT_THAT(wrapped_mac.value()->VerifyMac(mac_tag, data), IsOk());
}
} // namespace
diff --git a/cc/prf/aes_cmac_prf_key_manager.h b/cc/prf/aes_cmac_prf_key_manager.h
index 93b2fbd..fdb5844 100644
--- a/cc/prf/aes_cmac_prf_key_manager.h
+++ b/cc/prf/aes_cmac_prf_key_manager.h
@@ -121,7 +121,7 @@
}
google::crypto::tink::AesCmacPrfKey key;
key.set_version(get_version());
- key.set_key_value(randomness.ValueOrDie());
+ key.set_key_value(randomness.value());
return key;
}
diff --git a/cc/prf/aes_cmac_prf_key_manager_test.cc b/cc/prf/aes_cmac_prf_key_manager_test.cc
index 7783d7a..41f2a86 100644
--- a/cc/prf/aes_cmac_prf_key_manager_test.cc
+++ b/cc/prf/aes_cmac_prf_key_manager_test.cc
@@ -104,48 +104,46 @@
TEST(AesCmacPrfKeyManagerTest, CreateKey) {
AesCmacPrfKeyFormat format = ValidKeyFormat();
ASSERT_THAT(AesCmacPrfKeyManager().CreateKey(format).status(), IsOk());
- AesCmacPrfKey key = AesCmacPrfKeyManager().CreateKey(format).ValueOrDie();
+ AesCmacPrfKey key = AesCmacPrfKeyManager().CreateKey(format).value();
EXPECT_THAT(key.version(), Eq(0));
EXPECT_THAT(key.key_value(), SizeIs(format.key_size()));
}
TEST(AesCmacPrfKeyManagerTest, ValidateKey) {
AesCmacPrfKeyFormat format = ValidKeyFormat();
- AesCmacPrfKey key = AesCmacPrfKeyManager().CreateKey(format).ValueOrDie();
+ AesCmacPrfKey key = AesCmacPrfKeyManager().CreateKey(format).value();
EXPECT_THAT(AesCmacPrfKeyManager().ValidateKey(key), IsOk());
}
TEST(AesCmacPrfKeyManagerTest, ValidateKeyInvalidVersion) {
AesCmacPrfKeyFormat format = ValidKeyFormat();
- AesCmacPrfKey key = AesCmacPrfKeyManager().CreateKey(format).ValueOrDie();
+ AesCmacPrfKey key = AesCmacPrfKeyManager().CreateKey(format).value();
key.set_version(1);
EXPECT_THAT(AesCmacPrfKeyManager().ValidateKey(key), Not(IsOk()));
}
TEST(AesCmacPrfKeyManagerTest, ValidateKeyShortKey) {
AesCmacPrfKeyFormat format = ValidKeyFormat();
- AesCmacPrfKey key = AesCmacPrfKeyManager().CreateKey(format).ValueOrDie();
+ AesCmacPrfKey key = AesCmacPrfKeyManager().CreateKey(format).value();
key.set_key_value("0123456789abcdef");
EXPECT_THAT(AesCmacPrfKeyManager().ValidateKey(key), Not(IsOk()));
}
TEST(AesCmacPrfKeyManagerTest, GetPrimitive) {
AesCmacPrfKeyFormat format = ValidKeyFormat();
- AesCmacPrfKey key = AesCmacPrfKeyManager().CreateKey(format).ValueOrDie();
+ AesCmacPrfKey key = AesCmacPrfKeyManager().CreateKey(format).value();
auto manager_prf_or = AesCmacPrfKeyManager().GetPrimitive<Prf>(key);
ASSERT_THAT(manager_prf_or.status(), IsOk());
- auto prf_value_or =
- manager_prf_or.ValueOrDie()->Compute("some plaintext", 16);
+ auto prf_value_or = manager_prf_or.value()->Compute("some plaintext", 16);
ASSERT_THAT(prf_value_or.status(), IsOk());
auto direct_prf_or = subtle::AesCmacBoringSsl::New(
util::SecretDataFromStringView(key.key_value()), 16);
ASSERT_THAT(direct_prf_or.status(), IsOk());
auto direct_prf_value_or =
- direct_prf_or.ValueOrDie()->ComputeMac("some plaintext");
+ direct_prf_or.value()->ComputeMac("some plaintext");
ASSERT_THAT(direct_prf_value_or.status(), IsOk());
- EXPECT_THAT(direct_prf_value_or.ValueOrDie(),
- StrEq(prf_value_or.ValueOrDie()));
+ EXPECT_THAT(direct_prf_value_or.value(), StrEq(prf_value_or.value()));
}
TEST(AesCmacPrfKeyManagerTest, DeriveKeyValid) {
@@ -154,7 +152,7 @@
auto key_or =
AesCmacPrfKeyManager().DeriveKey(ValidKeyFormat(), inputstream.get());
ASSERT_THAT(key_or.status(), IsOk());
- AesCmacPrfKey key = key_or.ValueOrDie();
+ AesCmacPrfKey key = key_or.value();
EXPECT_THAT(key.version(), Eq(AesCmacPrfKeyManager().get_version()));
EXPECT_THAT(key.key_value(), Eq(bytes));
}
diff --git a/cc/prf/hkdf_prf_key_manager.h b/cc/prf/hkdf_prf_key_manager.h
index f896705..fe860a3 100644
--- a/cc/prf/hkdf_prf_key_manager.h
+++ b/cc/prf/hkdf_prf_key_manager.h
@@ -67,8 +67,7 @@
if (!hkdf_result.ok()) {
return hkdf_result.status();
}
- return subtle::CreatePrfFromStreamingPrf(
- std::move(hkdf_result.ValueOrDie()));
+ return subtle::CreatePrfFromStreamingPrf(std::move(hkdf_result.value()));
}
};
@@ -130,7 +129,7 @@
google::crypto::tink::HkdfPrfKey key;
key.set_version(get_version());
*key.mutable_params() = key_format.params();
- key.set_key_value(randomness.ValueOrDie());
+ key.set_key_value(randomness.value());
return key;
}
diff --git a/cc/prf/hkdf_prf_key_manager_test.cc b/cc/prf/hkdf_prf_key_manager_test.cc
index 1461869..b4301ab 100644
--- a/cc/prf/hkdf_prf_key_manager_test.cc
+++ b/cc/prf/hkdf_prf_key_manager_test.cc
@@ -174,11 +174,11 @@
key_format.mutable_params()->set_hash(::google::crypto::tink::SHA256);
auto key_or = HkdfPrfKeyManager().CreateKey(key_format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(), SizeIs(32));
- EXPECT_THAT(key_or.ValueOrDie().params().hash(),
+ EXPECT_THAT(key_or.value().key_value(), SizeIs(32));
+ EXPECT_THAT(key_or.value().params().hash(),
Eq(::google::crypto::tink::SHA256));
- EXPECT_THAT(key_or.ValueOrDie().params().salt(), Eq(""));
- EXPECT_THAT(key_or.ValueOrDie().version(), Eq(0));
+ EXPECT_THAT(key_or.value().params().salt(), Eq(""));
+ EXPECT_THAT(key_or.value().version(), Eq(0));
}
TEST(HkdfPrfKeyManagerTest, CreateKeyDifferetSize) {
@@ -187,7 +187,7 @@
key_format.mutable_params()->set_hash(::google::crypto::tink::SHA256);
auto key_or = HkdfPrfKeyManager().CreateKey(key_format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(), SizeIs(77));
+ EXPECT_THAT(key_or.value().key_value(), SizeIs(77));
}
TEST(HkdfPrfKeyManagerTest, CreateKeyDifferetHash) {
@@ -196,7 +196,7 @@
key_format.mutable_params()->set_hash(::google::crypto::tink::SHA512);
auto key_or = HkdfPrfKeyManager().CreateKey(key_format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().params().hash(),
+ EXPECT_THAT(key_or.value().params().hash(),
Eq(::google::crypto::tink::SHA512));
}
@@ -207,7 +207,7 @@
key_format.mutable_params()->set_salt("saltstring");
auto key_or = HkdfPrfKeyManager().CreateKey(key_format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().params().salt(), Eq("saltstring"));
+ EXPECT_THAT(key_or.value().params().salt(), Eq("saltstring"));
}
TEST(HkdfPrfKeyManagerTest, CreatePrf) {
@@ -219,29 +219,29 @@
ASSERT_THAT(key_or.status(), IsOk());
StatusOr<std::unique_ptr<StreamingPrf>> prf_or =
- HkdfPrfKeyManager().GetPrimitive<StreamingPrf>(key_or.ValueOrDie());
+ HkdfPrfKeyManager().GetPrimitive<StreamingPrf>(key_or.value());
ASSERT_THAT(prf_or.status(), IsOk());
StatusOr<std::unique_ptr<StreamingPrf>> direct_prf =
subtle::HkdfStreamingPrf::New(
subtle::SHA256,
- util::SecretDataFromStringView(key_or.ValueOrDie().key_value()),
+ util::SecretDataFromStringView(key_or.value().key_value()),
"salt string");
ASSERT_THAT(direct_prf.status(), IsOk());
std::unique_ptr<InputStream> input =
- prf_or.ValueOrDie()->ComputePrf("input string");
+ prf_or.value()->ComputePrf("input string");
std::unique_ptr<InputStream> direct_input =
- direct_prf.ValueOrDie()->ComputePrf("input string");
+ direct_prf.value()->ComputePrf("input string");
auto output_or = ReadBytesFromStream(100, input.get());
auto direct_output_or = ReadBytesFromStream(100, direct_input.get());
ASSERT_THAT(output_or.status(), IsOk());
ASSERT_THAT(direct_output_or.status(), IsOk());
- EXPECT_THAT(output_or.ValueOrDie(), Eq(direct_output_or.ValueOrDie()));
+ EXPECT_THAT(output_or.value(), Eq(direct_output_or.value()));
}
TEST(HkdfPrfKeyManagerTest, DeriveKey) {
@@ -256,9 +256,9 @@
StatusOr<HkdfPrfKey> key_or =
HkdfPrfKeyManager().DeriveKey(format, &input_stream);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(),
+ EXPECT_THAT(key_or.value().key_value(),
Eq("0123456789abcdef0123456789abcdef"));
- EXPECT_THAT(key_or.ValueOrDie().params().hash(), Eq(format.params().hash()));
+ EXPECT_THAT(key_or.value().params().hash(), Eq(format.params().hash()));
}
TEST(HmacPrfKeyManagerTest, DeriveKeyNotEnoughRandomness) {
@@ -297,28 +297,28 @@
ASSERT_THAT(key_or.status(), IsOk());
StatusOr<std::unique_ptr<Prf>> prf_or =
- HkdfPrfKeyManager().GetPrimitive<Prf>(key_or.ValueOrDie());
+ HkdfPrfKeyManager().GetPrimitive<Prf>(key_or.value());
ASSERT_THAT(prf_or.status(), IsOk());
StatusOr<std::unique_ptr<StreamingPrf>> direct_streaming_prf =
subtle::HkdfStreamingPrf::New(
subtle::SHA256,
- util::SecretDataFromStringView(key_or.ValueOrDie().key_value()),
+ util::SecretDataFromStringView(key_or.value().key_value()),
"salt string");
ASSERT_THAT(direct_streaming_prf.status(), IsOk());
auto direct_prf = subtle::CreatePrfFromStreamingPrf(
- std::move(direct_streaming_prf.ValueOrDie()));
+ std::move(direct_streaming_prf.value()));
util::StatusOr<std::string> output_or =
- prf_or.ValueOrDie()->Compute("input string", 100);
+ prf_or.value()->Compute("input string", 100);
util::StatusOr<std::string> direct_output_or =
direct_prf->Compute("input string", 100);
ASSERT_THAT(output_or.status(), IsOk());
ASSERT_THAT(direct_output_or.status(), IsOk());
- EXPECT_THAT(output_or.ValueOrDie(), Eq(direct_output_or.ValueOrDie()));
+ EXPECT_THAT(output_or.value(), Eq(direct_output_or.value()));
}
} // namespace
diff --git a/cc/prf/hmac_prf_key_manager.cc b/cc/prf/hmac_prf_key_manager.cc
index 60ac0da..beea85c 100644
--- a/cc/prf/hmac_prf_key_manager.cc
+++ b/cc/prf/hmac_prf_key_manager.cc
@@ -85,7 +85,7 @@
HmacPrfKey key;
key.set_version(get_version());
*(key.mutable_params()) = hmac_prf_key_format.params();
- key.set_key_value(randomness.ValueOrDie());
+ key.set_key_value(randomness.value());
return key;
}
diff --git a/cc/prf/hmac_prf_key_manager_test.cc b/cc/prf/hmac_prf_key_manager_test.cc
index 3bea357..1094234 100644
--- a/cc/prf/hmac_prf_key_manager_test.cc
+++ b/cc/prf/hmac_prf_key_manager_test.cc
@@ -85,14 +85,11 @@
key_format.mutable_params()->set_hash(HashType::SHA512);
auto hmac_key_or = HmacPrfKeyManager().CreateKey(key_format);
ASSERT_THAT(hmac_key_or.status(), IsOk());
- EXPECT_EQ(hmac_key_or.ValueOrDie().version(), 0);
- EXPECT_EQ(hmac_key_or.ValueOrDie().params().hash(),
- key_format.params().hash());
- EXPECT_THAT(hmac_key_or.ValueOrDie().key_value(),
- SizeIs(key_format.key_size()));
+ EXPECT_EQ(hmac_key_or.value().version(), 0);
+ EXPECT_EQ(hmac_key_or.value().params().hash(), key_format.params().hash());
+ EXPECT_THAT(hmac_key_or.value().key_value(), SizeIs(key_format.key_size()));
- EXPECT_THAT(HmacPrfKeyManager().ValidateKey(hmac_key_or.ValueOrDie()),
- IsOk());
+ EXPECT_THAT(HmacPrfKeyManager().ValidateKey(hmac_key_or.value()), IsOk());
}
TEST(HmacPrfKeyManagerTest, ValidKey) {
@@ -127,8 +124,8 @@
StatusOr<HmacPrfKey> key_or =
HmacPrfKeyManager().DeriveKey(format, &input_stream);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_EQ(key_or.ValueOrDie().key_value(), "0123456789abcdefghijklm");
- EXPECT_EQ(key_or.ValueOrDie().params().hash(), format.params().hash());
+ EXPECT_EQ(key_or.value().key_value(), "0123456789abcdefghijklm");
+ EXPECT_EQ(key_or.value().params().hash(), format.params().hash());
}
TEST(HmacPrfKeyManagerTest, DeriveKeyNotEnoughRandomness) {
@@ -162,11 +159,10 @@
HmacPrfKeyFormat key_format;
key_format.mutable_params()->set_hash(HashType::SHA256);
key_format.set_key_size(16);
- HmacPrfKey key = HmacPrfKeyManager().CreateKey(key_format).ValueOrDie();
+ HmacPrfKey key = HmacPrfKeyManager().CreateKey(key_format).value();
auto manager_mac_or = HmacPrfKeyManager().GetPrimitive<Prf>(key);
ASSERT_THAT(manager_mac_or.status(), IsOk());
- auto prf_value_or =
- manager_mac_or.ValueOrDie()->Compute("some plaintext", 16);
+ auto prf_value_or = manager_mac_or.value()->Compute("some plaintext", 16);
ASSERT_THAT(prf_value_or.status(), IsOk());
auto direct_prf_or = subtle::HmacBoringSsl::New(
@@ -174,10 +170,9 @@
util::SecretDataFromStringView(key.key_value()));
ASSERT_THAT(direct_prf_or.status(), IsOk());
auto direct_prf_value_or =
- direct_prf_or.ValueOrDie()->ComputeMac("some plaintext");
+ direct_prf_or.value()->ComputeMac("some plaintext");
ASSERT_THAT(direct_prf_value_or.status(), IsOk());
- EXPECT_THAT(direct_prf_value_or.ValueOrDie(),
- StartsWith(prf_value_or.ValueOrDie()));
+ EXPECT_THAT(direct_prf_value_or.value(), StartsWith(prf_value_or.value()));
}
} // namespace
diff --git a/cc/prf/prf_set_test.cc b/cc/prf/prf_set_test.cc
index 1af428d..f76ed88 100644
--- a/cc/prf/prf_set_test.cc
+++ b/cc/prf/prf_set_test.cc
@@ -91,21 +91,21 @@
auto keyset_manager_result =
KeysetManager::New(PrfKeyTemplates::HkdfSha256());
ASSERT_TRUE(keyset_manager_result.ok()) << keyset_manager_result.status();
- auto keyset_manager = std::move(keyset_manager_result.ValueOrDie());
+ auto keyset_manager = std::move(keyset_manager_result.value());
auto id_result = keyset_manager->Add(PrfKeyTemplates::HmacSha256());
ASSERT_TRUE(id_result.ok()) << id_result.status();
- uint32_t hmac_sha256_id = id_result.ValueOrDie();
+ uint32_t hmac_sha256_id = id_result.value();
id_result = keyset_manager->Add(PrfKeyTemplates::HmacSha512());
ASSERT_TRUE(id_result.ok()) << id_result.status();
- uint32_t hmac_sha512_id = id_result.ValueOrDie();
+ uint32_t hmac_sha512_id = id_result.value();
id_result = keyset_manager->Add(PrfKeyTemplates::AesCmac());
ASSERT_TRUE(id_result.ok()) << id_result.status();
- uint32_t aes_cmac_id = id_result.ValueOrDie();
+ uint32_t aes_cmac_id = id_result.value();
auto keyset_handle = keyset_manager->GetKeysetHandle();
uint32_t hkdf_id = keyset_handle->GetKeysetInfo().primary_key_id();
auto prf_set_result = keyset_handle->GetPrimitive<PrfSet>();
ASSERT_TRUE(prf_set_result.ok()) << prf_set_result.status();
- auto prf_set = std::move(prf_set_result.ValueOrDie());
+ auto prf_set = std::move(prf_set_result.value());
EXPECT_THAT(prf_set->GetPrimaryId(), Eq(hkdf_id));
auto prf_map = prf_set->GetPrfs();
EXPECT_THAT(prf_map, UnorderedElementsAre(Pair(Eq(hkdf_id), _),
@@ -136,18 +136,18 @@
}
std::string output;
if (output_result.ok()) {
- output = output_result.ValueOrDie();
+ output = output_result.value();
results.push_back(output);
}
output_result = prf.second->Compute(input2, output_length);
EXPECT_TRUE(output_result.ok()) << output_result.status();
if (output_result.ok()) {
- results.push_back(output_result.ValueOrDie());
+ results.push_back(output_result.value());
}
output_result = prf.second->Compute(input, output_length);
EXPECT_TRUE(output_result.ok()) << output_result.status();
if (output_result.ok()) {
- EXPECT_THAT(output_result.ValueOrDie(), StrEq(output));
+ EXPECT_THAT(output_result.value(), StrEq(output));
}
}
for (int i = 0; i < results.size(); i++) {
diff --git a/cc/prf/prf_set_wrapper.cc b/cc/prf/prf_set_wrapper.cc
index 0f7709b..f244a27 100644
--- a/cc/prf/prf_set_wrapper.cc
+++ b/cc/prf/prf_set_wrapper.cc
@@ -33,7 +33,7 @@
public:
explicit PrfSetPrimitiveWrapper(std::unique_ptr<PrimitiveSet<Prf>> prf_set)
: prf_set_(std::move(prf_set)) {
- for (const auto& prf : *prf_set_->get_raw_primitives().ValueOrDie()) {
+ for (const auto& prf : *prf_set_->get_raw_primitives().value()) {
prfs_.insert({prf->get_key_id(), &prf->get_primitive()});
}
}
diff --git a/cc/prf/prf_set_wrapper_test.cc b/cc/prf/prf_set_wrapper_test.cc
index 5b8e69f..0dcc8fd 100644
--- a/cc/prf/prf_set_wrapper_test.cc
+++ b/cc/prf/prf_set_wrapper_test.cc
@@ -95,7 +95,7 @@
key_info.set_output_prefix_type(google::crypto::tink::OutputPrefixType::TINK);
auto entry = AddPrf("output", key_info);
ASSERT_THAT(entry.status(), IsOk());
- ASSERT_THAT(PrfSet()->set_primary(entry.ValueOrDie()), IsOk());
+ ASSERT_THAT(PrfSet()->set_primary(entry.value()), IsOk());
PrfSetWrapper wrapper;
EXPECT_THAT(wrapper.Wrap(std::move(PrfSet())).status(), Not(IsOk()));
}
@@ -103,11 +103,11 @@
TEST_F(PrfSetWrapperTest, WrapOkay) {
auto entry = AddPrf("output", MakeKey(1));
ASSERT_THAT(entry.status(), IsOk());
- ASSERT_THAT(PrfSet()->set_primary(entry.ValueOrDie()), IsOk());
+ ASSERT_THAT(PrfSet()->set_primary(entry.value()), IsOk());
PrfSetWrapper wrapper;
auto wrapped = wrapper.Wrap(std::move(PrfSet()));
ASSERT_THAT(wrapped.status(), IsOk());
- EXPECT_THAT(wrapped.ValueOrDie()->ComputePrimary("input", 6),
+ EXPECT_THAT(wrapped.value()->ComputePrimary("input", 6),
IsOkAndHolds(StrEq("output")));
}
@@ -115,7 +115,7 @@
std::string primary_output("output");
auto entry = AddPrf(primary_output, MakeKey(1));
ASSERT_THAT(entry.status(), IsOk());
- ASSERT_THAT(PrfSet()->set_primary(entry.ValueOrDie()), IsOk());
+ ASSERT_THAT(PrfSet()->set_primary(entry.value()), IsOk());
ASSERT_THAT(AddPrf(primary_output, MakeKey(1)).status(), IsOk());
std::string secondary_output("different");
@@ -123,7 +123,7 @@
PrfSetWrapper wrapper;
auto wrapped_or = wrapper.Wrap(std::move(PrfSet()));
ASSERT_THAT(wrapped_or.status(), IsOk());
- auto wrapped = std::move(wrapped_or.ValueOrDie());
+ auto wrapped = std::move(wrapped_or.value());
EXPECT_THAT(wrapped->ComputePrimary("input", 6),
IsOkAndHolds(StrEq("output")));
const auto& prf_map = wrapped->GetPrfs();
diff --git a/cc/primitive_set.h b/cc/primitive_set.h
index dee81ae..1598e1d 100644
--- a/cc/primitive_set.h
+++ b/cc/primitive_set.h
@@ -70,7 +70,7 @@
return util::Status(absl::StatusCode::kInvalidArgument,
"The primitive must be non-null.");
}
- std::string identifier = identifier_result.ValueOrDie();
+ std::string identifier = identifier_result.value();
return absl::WrapUnique(new Entry(std::move(primitive), identifier,
key_info.status(), key_info.key_id(),
key_info.output_prefix_type()));
@@ -118,8 +118,8 @@
if (!entry_or.ok()) return entry_or.status();
absl::MutexLock lock(&primitives_mutex_);
- std::string identifier = entry_or.ValueOrDie()->get_identifier();
- primitives_[identifier].push_back(std::move(entry_or.ValueOrDie()));
+ std::string identifier = entry_or.value()->get_identifier();
+ primitives_[identifier].push_back(std::move(entry_or.value()));
return primitives_[identifier].back().get();
}
diff --git a/cc/signature/ecdsa_sign_key_manager.cc b/cc/signature/ecdsa_sign_key_manager.cc
index 4bc0205..bea5312 100644
--- a/cc/signature/ecdsa_sign_key_manager.cc
+++ b/cc/signature/ecdsa_sign_key_manager.cc
@@ -53,7 +53,7 @@
auto ec_key_result = internal::NewEcKey(
util::Enums::ProtoToSubtle(ecdsa_key_format.params().curve()));
if (!ec_key_result.ok()) return ec_key_result.status();
- auto ec_key = ec_key_result.ValueOrDie();
+ auto ec_key = ec_key_result.value();
// Build EcdsaPrivateKey.
EcdsaPrivateKey ecdsa_private_key;
@@ -145,7 +145,7 @@
ec_key, Enums::ProtoToSubtle(public_key.params().hash_type()),
Enums::ProtoToSubtle(public_key.params().encoding()));
if (!result.ok()) return result.status();
- return {std::move(result.ValueOrDie())};
+ return {std::move(result.value())};
}
Status EcdsaSignKeyManager::ValidateKey(const EcdsaPrivateKey& key) const {
diff --git a/cc/signature/ecdsa_sign_key_manager_test.cc b/cc/signature/ecdsa_sign_key_manager_test.cc
index ed89c75..d54f00f 100644
--- a/cc/signature/ecdsa_sign_key_manager_test.cc
+++ b/cc/signature/ecdsa_sign_key_manager_test.cc
@@ -129,7 +129,7 @@
EcdsaKeyFormat format = CreateValidKeyFormat();
StatusOr<EcdsaPrivateKey> key_or = EcdsaSignKeyManager().CreateKey(format);
ASSERT_THAT(key_or.status(), IsOk());
- EcdsaPrivateKey key = key_or.ValueOrDie();
+ EcdsaPrivateKey key = key_or.value();
EXPECT_THAT(key.version(), Eq(0));
@@ -150,12 +150,12 @@
EcdsaKeyFormat format = CreateValidKeyFormat();
StatusOr<EcdsaPrivateKey> key_or = EcdsaSignKeyManager().CreateKey(format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(EcdsaSignKeyManager().ValidateKey(key_or.ValueOrDie()), IsOk());
+ EXPECT_THAT(EcdsaSignKeyManager().ValidateKey(key_or.value()), IsOk());
}
EcdsaPrivateKey CreateValidKey() {
EcdsaKeyFormat format = CreateValidKeyFormat();
- return EcdsaSignKeyManager().CreateKey(format).ValueOrDie();
+ return EcdsaSignKeyManager().CreateKey(format).value();
}
TEST(EcdsaSignKeyManagerTest, ValidateKey) {
@@ -199,7 +199,7 @@
EcdsaSignKeyManager().GetPublicKey(key);
ASSERT_THAT(public_key_or.status(), IsOk());
- EcdsaPublicKey public_key = public_key_or.ValueOrDie();
+ EcdsaPublicKey public_key = public_key_or.value();
EXPECT_THAT(public_key.version(), Eq(key.public_key().version()));
EXPECT_THAT(public_key.params().hash_type(),
@@ -216,7 +216,7 @@
TEST(EcdsaSignKeyManagerTest, Create) {
EcdsaPrivateKey private_key = CreateValidKey();
EcdsaPublicKey public_key =
- EcdsaSignKeyManager().GetPublicKey(private_key).ValueOrDie();
+ EcdsaSignKeyManager().GetPublicKey(private_key).value();
auto signer_or =
EcdsaSignKeyManager().GetPrimitive<PublicKeySign>(private_key);
@@ -232,8 +232,8 @@
ASSERT_THAT(direct_verifier_or.status(), IsOk());
std::string message = "Some message";
- EXPECT_THAT(direct_verifier_or.ValueOrDie()->Verify(
- signer_or.ValueOrDie()->Sign(message).ValueOrDie(), message),
+ EXPECT_THAT(direct_verifier_or.value()->Verify(
+ signer_or.ValueOrDie()->Sign(message).value(), message),
IsOk());
}
@@ -241,7 +241,7 @@
EcdsaPrivateKey private_key = CreateValidKey();
// Note: we create a new key in the next line.
EcdsaPublicKey public_key =
- EcdsaSignKeyManager().GetPublicKey(CreateValidKey()).ValueOrDie();
+ EcdsaSignKeyManager().GetPublicKey(CreateValidKey()).value();
auto signer_or =
EcdsaSignKeyManager().GetPrimitive<PublicKeySign>(private_key);
@@ -257,8 +257,8 @@
ASSERT_THAT(direct_verifier_or.status(), IsOk());
std::string message = "Some message";
- EXPECT_THAT(direct_verifier_or.ValueOrDie()->Verify(
- signer_or.ValueOrDie()->Sign(message).ValueOrDie(), message),
+ EXPECT_THAT(direct_verifier_or.value()->Verify(
+ signer_or.ValueOrDie()->Sign(message).value(), message),
Not(IsOk()));
}
diff --git a/cc/signature/ecdsa_verify_key_manager.cc b/cc/signature/ecdsa_verify_key_manager.cc
index 795a78b..f72c05c 100644
--- a/cc/signature/ecdsa_verify_key_manager.cc
+++ b/cc/signature/ecdsa_verify_key_manager.cc
@@ -54,7 +54,7 @@
ec_key, Enums::ProtoToSubtle(ecdsa_public_key.params().hash_type()),
Enums::ProtoToSubtle(ecdsa_public_key.params().encoding()));
if (!result.ok()) return result.status();
- return {std::move(result.ValueOrDie())};
+ return {std::move(result.value())};
}
Status EcdsaVerifyKeyManager::ValidateParams(const EcdsaParams& params) const {
diff --git a/cc/signature/ecdsa_verify_key_manager_test.cc b/cc/signature/ecdsa_verify_key_manager_test.cc
index 0e7df4d..b9f16e6 100644
--- a/cc/signature/ecdsa_verify_key_manager_test.cc
+++ b/cc/signature/ecdsa_verify_key_manager_test.cc
@@ -72,13 +72,11 @@
params->set_hash_type(HashType::SHA256);
params->set_curve(EllipticCurveType::NIST_P256);
params->set_encoding(EcdsaSignatureEncoding::DER);
- return EcdsaSignKeyManager().CreateKey(key_format).ValueOrDie();
+ return EcdsaSignKeyManager().CreateKey(key_format).value();
}
EcdsaPublicKey CreateValidPublicKey() {
- return EcdsaSignKeyManager()
- .GetPublicKey(CreateValidPrivateKey())
- .ValueOrDie();
+ return EcdsaSignKeyManager().GetPublicKey(CreateValidPrivateKey()).value();
}
// Checks that a public key generaed by the SignKeyManager is considered valid.
@@ -166,7 +164,7 @@
TEST(EcdsaSignKeyManagerTest, Create) {
EcdsaPrivateKey private_key = CreateValidPrivateKey();
EcdsaPublicKey public_key =
- EcdsaSignKeyManager().GetPublicKey(private_key).ValueOrDie();
+ EcdsaSignKeyManager().GetPublicKey(private_key).value();
internal::EcKey ec_key;
ec_key.curve = Enums::ProtoToSubtle(public_key.params().curve());
@@ -185,8 +183,8 @@
std::string message = "Some message";
EXPECT_THAT(
- verifier_or.ValueOrDie()->Verify(
- direct_signer_or.ValueOrDie()->Sign(message).ValueOrDie(), message),
+ verifier_or.value()->Verify(
+ direct_signer_or.ValueOrDie()->Sign(message).value(), message),
IsOk());
}
@@ -194,7 +192,7 @@
EcdsaPrivateKey private_key = CreateValidPrivateKey();
// Note: we create a new key in the next line.
EcdsaPublicKey public_key =
- EcdsaSignKeyManager().GetPublicKey(CreateValidPrivateKey()).ValueOrDie();
+ EcdsaSignKeyManager().GetPublicKey(CreateValidPrivateKey()).value();
internal::EcKey ec_key;
ec_key.curve = Enums::ProtoToSubtle(public_key.params().curve());
@@ -213,8 +211,8 @@
std::string message = "Some message";
EXPECT_THAT(
- verifier_or.ValueOrDie()->Verify(
- direct_signer_or.ValueOrDie()->Sign(message).ValueOrDie(), message),
+ verifier_or.value()->Verify(
+ direct_signer_or.ValueOrDie()->Sign(message).value(), message),
Not(IsOk()));
}
diff --git a/cc/signature/ed25519_sign_key_manager_test.cc b/cc/signature/ed25519_sign_key_manager_test.cc
index e73bee9..81afc9d 100644
--- a/cc/signature/ed25519_sign_key_manager_test.cc
+++ b/cc/signature/ed25519_sign_key_manager_test.cc
@@ -67,7 +67,7 @@
StatusOr<Ed25519PrivateKey> key_or =
Ed25519SignKeyManager().CreateKey(Ed25519KeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
- Ed25519PrivateKey key = key_or.ValueOrDie();
+ Ed25519PrivateKey key = key_or.value();
EXPECT_THAT(key.version(), Eq(0));
@@ -81,7 +81,7 @@
StatusOr<Ed25519PrivateKey> key_or =
Ed25519SignKeyManager().CreateKey(Ed25519KeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(Ed25519SignKeyManager().ValidateKey(key_or.ValueOrDie()), IsOk());
+ EXPECT_THAT(Ed25519SignKeyManager().ValidateKey(key_or.value()), IsOk());
}
TEST(Ed25519SignKeyManagerTest, CreateKeyAlwaysNew) {
@@ -91,7 +91,7 @@
StatusOr<Ed25519PrivateKey> key_or =
Ed25519SignKeyManager().CreateKey(Ed25519KeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
- keys.insert(key_or.ValueOrDie().key_value());
+ keys.insert(key_or.value().key_value());
}
EXPECT_THAT(keys, SizeIs(num_tests));
}
@@ -101,19 +101,19 @@
Ed25519SignKeyManager().CreateKey(Ed25519KeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
StatusOr<Ed25519PublicKey> public_key_or =
- Ed25519SignKeyManager().GetPublicKey(key_or.ValueOrDie());
+ Ed25519SignKeyManager().GetPublicKey(key_or.value());
ASSERT_THAT(public_key_or.status(), IsOk());
- EXPECT_THAT(public_key_or.ValueOrDie().version(),
- Eq(key_or.ValueOrDie().public_key().version()));
- EXPECT_THAT(public_key_or.ValueOrDie().key_value(),
- Eq(key_or.ValueOrDie().public_key().key_value()));
+ EXPECT_THAT(public_key_or.value().version(),
+ Eq(key_or.value().public_key().version()));
+ EXPECT_THAT(public_key_or.value().key_value(),
+ Eq(key_or.value().public_key().key_value()));
}
TEST(Ed25519SignKeyManagerTest, Create) {
StatusOr<Ed25519PrivateKey> key_or =
Ed25519SignKeyManager().CreateKey(Ed25519KeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
- Ed25519PrivateKey key = key_or.ValueOrDie();
+ Ed25519PrivateKey key = key_or.value();
auto signer_or =
Ed25519SignKeyManager().GetPrimitive<PublicKeySign>(key);
@@ -125,8 +125,8 @@
ASSERT_THAT(direct_verifier_or.status(), IsOk());
std::string message = "Some message";
- EXPECT_THAT(direct_verifier_or.ValueOrDie()->Verify(
- signer_or.ValueOrDie()->Sign(message).ValueOrDie(), message),
+ EXPECT_THAT(direct_verifier_or.value()->Verify(
+ signer_or.ValueOrDie()->Sign(message).value(), message),
IsOk());
}
@@ -134,7 +134,7 @@
StatusOr<Ed25519PrivateKey> key_or =
Ed25519SignKeyManager().CreateKey(Ed25519KeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
- Ed25519PrivateKey key = key_or.ValueOrDie();
+ Ed25519PrivateKey key = key_or.value();
auto signer_or =
Ed25519SignKeyManager().GetPrimitive<PublicKeySign>(key);
@@ -146,8 +146,8 @@
ASSERT_THAT(direct_verifier_or.status(), IsOk());
std::string message = "Some message";
- EXPECT_THAT(direct_verifier_or.ValueOrDie()->Verify(
- signer_or.ValueOrDie()->Sign(message).ValueOrDie(), message),
+ EXPECT_THAT(direct_verifier_or.value()->Verify(
+ signer_or.ValueOrDie()->Sign(message).value(), message),
Not(IsOk()));
}
@@ -160,7 +160,7 @@
StatusOr<Ed25519PrivateKey> key_or =
Ed25519SignKeyManager().DeriveKey(format, &input_stream);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(),
+ EXPECT_THAT(key_or.value().key_value(),
Eq("0123456789abcdef0123456789abcdef"));
}
@@ -171,17 +171,17 @@
absl::make_unique<std::stringstream>("0123456789abcdef0123456789abcdef")};
Ed25519PrivateKey key =
- Ed25519SignKeyManager().DeriveKey(format, &input_stream).ValueOrDie();
+ Ed25519SignKeyManager().DeriveKey(format, &input_stream).value();
auto signer_or = Ed25519SignKeyManager().GetPrimitive<PublicKeySign>(key);
ASSERT_THAT(signer_or.status(), IsOk());
std::string message = "Some message";
- auto signature = signer_or.ValueOrDie()->Sign(message).ValueOrDie();
+ auto signature = signer_or.ValueOrDie()->Sign(message).value();
auto verifier_or =
Ed25519VerifyKeyManager().GetPrimitive<PublicKeyVerify>(key.public_key());
- EXPECT_THAT(verifier_or.ValueOrDie()->Verify(signature, message), IsOk());
+ EXPECT_THAT(verifier_or.value()->Verify(signature, message), IsOk());
}
TEST(Ed25519SignKeyManagerTest, DeriveKeyNotEnoughRandomness) {
diff --git a/cc/signature/ed25519_verify_key_manager_test.cc b/cc/signature/ed25519_verify_key_manager_test.cc
index 6c5d007..e1ccd49 100644
--- a/cc/signature/ed25519_verify_key_manager_test.cc
+++ b/cc/signature/ed25519_verify_key_manager_test.cc
@@ -60,13 +60,11 @@
}
Ed25519PrivateKey CreateValidPrivateKey() {
- return Ed25519SignKeyManager().CreateKey(Ed25519KeyFormat()).ValueOrDie();
+ return Ed25519SignKeyManager().CreateKey(Ed25519KeyFormat()).value();
}
Ed25519PublicKey CreateValidPublicKey() {
- return Ed25519SignKeyManager()
- .GetPublicKey(CreateValidPrivateKey())
- .ValueOrDie();
+ return Ed25519SignKeyManager().GetPublicKey(CreateValidPrivateKey()).value();
}
// Checks that a public key generaed by the SignKeyManager is considered valid.
@@ -96,7 +94,7 @@
TEST(Ed25519SignKeyManagerTest, Create) {
Ed25519PrivateKey private_key = CreateValidPrivateKey();
Ed25519PublicKey public_key =
- Ed25519SignKeyManager().GetPublicKey(private_key).ValueOrDie();
+ Ed25519SignKeyManager().GetPublicKey(private_key).value();
auto direct_signer_or =
subtle::Ed25519SignBoringSsl::New(util::SecretDataFromStringView(
@@ -109,17 +107,16 @@
std::string message = "Some message";
EXPECT_THAT(
- verifier_or.ValueOrDie()->Verify(
- direct_signer_or.ValueOrDie()->Sign(message).ValueOrDie(), message),
+ verifier_or.value()->Verify(
+ direct_signer_or.ValueOrDie()->Sign(message).value(), message),
IsOk());
}
TEST(Ed25519SignKeyManagerTest, CreateDifferentPrivateKey) {
Ed25519PrivateKey private_key = CreateValidPrivateKey();
// Note: we create a new key in the next line.
- Ed25519PublicKey public_key = Ed25519SignKeyManager()
- .GetPublicKey(CreateValidPrivateKey())
- .ValueOrDie();
+ Ed25519PublicKey public_key =
+ Ed25519SignKeyManager().GetPublicKey(CreateValidPrivateKey()).value();
auto direct_signer_or = subtle::Ed25519SignBoringSsl::New(
util::SecretDataFromStringView(absl::StrCat(
@@ -132,8 +129,8 @@
std::string message = "Some message";
EXPECT_THAT(
- verifier_or.ValueOrDie()->Verify(
- direct_signer_or.ValueOrDie()->Sign(message).ValueOrDie(), message),
+ verifier_or.value()->Verify(
+ direct_signer_or.ValueOrDie()->Sign(message).value(), message),
Not(IsOk()));
}
diff --git a/cc/signature/public_key_sign_factory_test.cc b/cc/signature/public_key_sign_factory_test.cc
index 6c68cde..804002a 100644
--- a/cc/signature/public_key_sign_factory_test.cc
+++ b/cc/signature/public_key_sign_factory_test.cc
@@ -97,12 +97,12 @@
*TestKeysetHandle::GetKeysetHandle(keyset));
EXPECT_TRUE(public_key_sign_result.ok())
<< public_key_sign_result.status();
- auto public_key_sign = std::move(public_key_sign_result.ValueOrDie());
+ auto public_key_sign = std::move(public_key_sign_result.value());
std::string data = "some data to sign";
auto sign_result = public_key_sign->Sign(data);
EXPECT_TRUE(sign_result.ok()) << sign_result.status();
- EXPECT_NE(data, sign_result.ValueOrDie());
+ EXPECT_NE(data, sign_result.value());
}
} // namespace
diff --git a/cc/signature/public_key_sign_wrapper.cc b/cc/signature/public_key_sign_wrapper.cc
index 4a331d1..e01b75a 100644
--- a/cc/signature/public_key_sign_wrapper.cc
+++ b/cc/signature/public_key_sign_wrapper.cc
@@ -77,7 +77,7 @@
auto sign_result = primary->get_primitive().Sign(data);
if (!sign_result.ok()) return sign_result.status();
const std::string& key_id = primary->get_identifier();
- return key_id + sign_result.ValueOrDie();
+ return key_id + sign_result.value();
}
} // anonymous namespace
diff --git a/cc/signature/public_key_sign_wrapper_test.cc b/cc/signature/public_key_sign_wrapper_test.cc
index 8b2cc65..be12a14 100644
--- a/cc/signature/public_key_sign_wrapper_test.cc
+++ b/cc/signature/public_key_sign_wrapper_test.cc
@@ -112,16 +112,16 @@
ASSERT_TRUE(entry_result.ok());
// The last key is the primary.
- ASSERT_THAT(pk_sign_set->set_primary(entry_result.ValueOrDie()), IsOk());
+ ASSERT_THAT(pk_sign_set->set_primary(entry_result.value()), IsOk());
// Wrap pk_sign_set and test the resulting PublicKeySign.
auto pk_sign_result = PublicKeySignWrapper().Wrap(std::move(pk_sign_set));
EXPECT_TRUE(pk_sign_result.ok()) << pk_sign_result.status();
- pk_sign = std::move(pk_sign_result.ValueOrDie());
+ pk_sign = std::move(pk_sign_result.value());
std::string data = "some data to sign";
auto sign_result = pk_sign->Sign(data);
EXPECT_TRUE(sign_result.ok()) << sign_result.status();
- std::string signature = sign_result.ValueOrDie();
+ std::string signature = sign_result.value();
std::unique_ptr<PublicKeyVerify> pk_verify(
new DummyPublicKeyVerify(signature_name_2));
auto verify_status = pk_verify->Verify(signature, data);
@@ -145,17 +145,17 @@
new DummyPublicKeySign(signature_name));
auto entry_result = pk_sign_set->AddPrimitive(std::move(pk_sign), key);
ASSERT_TRUE(entry_result.ok());
- ASSERT_THAT(pk_sign_set->set_primary(entry_result.ValueOrDie()), IsOk());
+ ASSERT_THAT(pk_sign_set->set_primary(entry_result.value()), IsOk());
// Wrap pk_sign_set and test the resulting PublicKeySign.
auto pk_sign_result = PublicKeySignWrapper().Wrap(std::move(pk_sign_set));
EXPECT_TRUE(pk_sign_result.ok()) << pk_sign_result.status();
- pk_sign = std::move(pk_sign_result.ValueOrDie());
+ pk_sign = std::move(pk_sign_result.value());
// Compute the signature via wrapper.
auto sign_result = pk_sign->Sign(data);
EXPECT_TRUE(sign_result.ok()) << sign_result.status();
- std::string signature = sign_result.ValueOrDie();
+ std::string signature = sign_result.value();
EXPECT_PRED_FORMAT2(testing::IsSubstring, signature_name, signature);
// Try verifying on raw PublicKeyVerify-primitive using original data.
diff --git a/cc/signature/public_key_verify_factory_test.cc b/cc/signature/public_key_verify_factory_test.cc
index a371265..94564c6 100644
--- a/cc/signature/public_key_verify_factory_test.cc
+++ b/cc/signature/public_key_verify_factory_test.cc
@@ -98,7 +98,7 @@
*TestKeysetHandle::GetKeysetHandle(keyset));
EXPECT_TRUE(public_key_verify_result.ok())
<< public_key_verify_result.status();
- auto public_key_verify = std::move(public_key_verify_result.ValueOrDie());
+ auto public_key_verify = std::move(public_key_verify_result.value());
}
} // namespace
diff --git a/cc/signature/public_key_verify_wrapper.cc b/cc/signature/public_key_verify_wrapper.cc
index 7052cbe..b55bc7d 100644
--- a/cc/signature/public_key_verify_wrapper.cc
+++ b/cc/signature/public_key_verify_wrapper.cc
@@ -82,7 +82,7 @@
if (primitives_result.ok()) {
absl::string_view raw_signature =
signature.substr(CryptoFormat::kNonRawPrefixSize);
- for (auto& entry : *(primitives_result.ValueOrDie())) {
+ for (auto& entry : *(primitives_result.value())) {
std::string legacy_data;
absl::string_view view_on_data_or_legacy_data = data;
if (entry->get_output_prefix_type() == OutputPrefixType::LEGACY) {
@@ -103,8 +103,7 @@
// No matching key succeeded with verification, try all RAW keys.
auto raw_primitives_result = public_key_verify_set_->get_raw_primitives();
if (raw_primitives_result.ok()) {
- for (auto& public_key_verify_entry :
- *(raw_primitives_result.ValueOrDie())) {
+ for (auto& public_key_verify_entry : *(raw_primitives_result.value())) {
auto& public_key_verify = public_key_verify_entry->get_primitive();
auto verify_result = public_key_verify.Verify(signature, data);
if (verify_result.ok()) {
diff --git a/cc/signature/public_key_verify_wrapper_test.cc b/cc/signature/public_key_verify_wrapper_test.cc
index 88a68b9..c82082e 100644
--- a/cc/signature/public_key_verify_wrapper_test.cc
+++ b/cc/signature/public_key_verify_wrapper_test.cc
@@ -112,17 +112,17 @@
ASSERT_TRUE(entry_result.ok());
// The last key is the primary.
- ASSERT_THAT(pk_verify_set->set_primary(entry_result.ValueOrDie()), IsOk());
+ ASSERT_THAT(pk_verify_set->set_primary(entry_result.value()), IsOk());
// Wrap pk_verify_set and test the resulting PublicKeyVerify.
auto pk_verify_result =
PublicKeyVerifyWrapper().Wrap(std::move(pk_verify_set));
EXPECT_TRUE(pk_verify_result.ok()) << pk_verify_result.status();
- pk_verify = std::move(pk_verify_result.ValueOrDie());
+ pk_verify = std::move(pk_verify_result.value());
std::string data = "some data to sign";
std::unique_ptr<PublicKeySign> pk_sign(
new DummyPublicKeySign(signature_name_0));
- std::string signature = pk_sign->Sign(data).ValueOrDie();
+ std::string signature = pk_sign->Sign(data).value();
util::Status status = pk_verify->Verify(signature, data);
EXPECT_TRUE(status.ok()) << status;
}
diff --git a/cc/signature/rsa_ssa_pkcs1_sign_key_manager.cc b/cc/signature/rsa_ssa_pkcs1_sign_key_manager.cc
index 13d59e0..cd4c1fa 100644
--- a/cc/signature/rsa_ssa_pkcs1_sign_key_manager.cc
+++ b/cc/signature/rsa_ssa_pkcs1_sign_key_manager.cc
@@ -121,7 +121,7 @@
private_key.public_key());
if (!verifier.ok()) return verifier.status();
auto sign_verify_result =
- SignAndVerify(signer.ValueOrDie().get(), verifier.ValueOrDie().get());
+ SignAndVerify(signer.value().get(), verifier.value().get());
if (!sign_verify_result.ok()) {
return util::Status(absl::StatusCode::kInternal,
"security bug: signing with private key followed by "
diff --git a/cc/signature/rsa_ssa_pkcs1_sign_key_manager_test.cc b/cc/signature/rsa_ssa_pkcs1_sign_key_manager_test.cc
index 33493d2..4509678 100644
--- a/cc/signature/rsa_ssa_pkcs1_sign_key_manager_test.cc
+++ b/cc/signature/rsa_ssa_pkcs1_sign_key_manager_test.cc
@@ -68,7 +68,7 @@
internal::SslUniquePtr<BIGNUM> e(BN_new());
BN_set_word(e.get(), public_exponent);
key_format.set_public_exponent(
- internal::BignumToString(e.get(), BN_num_bytes(e.get())).ValueOrDie());
+ internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
return key_format;
}
@@ -178,7 +178,7 @@
StatusOr<RsaSsaPkcs1PrivateKey> private_key_or =
RsaSsaPkcs1SignKeyManager().CreateKey(key_format);
ASSERT_THAT(private_key_or.status(), IsOk());
- CheckNewKey(private_key_or.ValueOrDie(), key_format);
+ CheckNewKey(private_key_or.value(), key_format);
}
TEST(RsaSsaPkcs1SignKeyManagerTest, CreateKeySmallKey) {
@@ -188,7 +188,7 @@
StatusOr<RsaSsaPkcs1PrivateKey> private_key_or =
RsaSsaPkcs1SignKeyManager().CreateKey(key_format);
ASSERT_THAT(private_key_or.status(), IsOk());
- CheckNewKey(private_key_or.ValueOrDie(), key_format);
+ CheckNewKey(private_key_or.value(), key_format);
}
TEST(RsaSsaPkcs1SignKeyManagerTest, CreateKeyLargeKey) {
@@ -198,15 +198,14 @@
StatusOr<RsaSsaPkcs1PrivateKey> private_key_or =
RsaSsaPkcs1SignKeyManager().CreateKey(key_format);
ASSERT_THAT(private_key_or.status(), IsOk());
- CheckNewKey(private_key_or.ValueOrDie(), key_format);
+ CheckNewKey(private_key_or.value(), key_format);
}
TEST(RsaSsaPkcs1SignKeyManagerTest, CreateKeyValid) {
StatusOr<RsaSsaPkcs1PrivateKey> key_or =
RsaSsaPkcs1SignKeyManager().CreateKey(ValidKeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKey(key_or.ValueOrDie()),
- IsOk());
+ EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKey(key_or.value()), IsOk());
}
// Check that in a bunch of CreateKey calls all generated primes are distinct.
@@ -218,8 +217,8 @@
StatusOr<RsaSsaPkcs1PrivateKey> key_or =
RsaSsaPkcs1SignKeyManager().CreateKey(ValidKeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
- keys.insert(key_or.ValueOrDie().p());
- keys.insert(key_or.ValueOrDie().q());
+ keys.insert(key_or.value().p());
+ keys.insert(key_or.value().q());
}
EXPECT_THAT(keys, SizeIs(2 * num_generated_keys));
}
@@ -229,16 +228,14 @@
RsaSsaPkcs1SignKeyManager().CreateKey(ValidKeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
StatusOr<RsaSsaPkcs1PublicKey> public_key_or =
- RsaSsaPkcs1SignKeyManager().GetPublicKey(key_or.ValueOrDie());
+ RsaSsaPkcs1SignKeyManager().GetPublicKey(key_or.value());
ASSERT_THAT(public_key_or.status(), IsOk());
- EXPECT_THAT(public_key_or.ValueOrDie().version(),
- Eq(key_or.ValueOrDie().public_key().version()));
- EXPECT_THAT(public_key_or.ValueOrDie().params().hash_type(),
- Eq(key_or.ValueOrDie().public_key().params().hash_type()));
- EXPECT_THAT(public_key_or.ValueOrDie().n(),
- Eq(key_or.ValueOrDie().public_key().n()));
- EXPECT_THAT(public_key_or.ValueOrDie().e(),
- Eq(key_or.ValueOrDie().public_key().e()));
+ EXPECT_THAT(public_key_or.value().version(),
+ Eq(key_or.value().public_key().version()));
+ EXPECT_THAT(public_key_or.value().params().hash_type(),
+ Eq(key_or.value().public_key().params().hash_type()));
+ EXPECT_THAT(public_key_or.value().n(), Eq(key_or.value().public_key().n()));
+ EXPECT_THAT(public_key_or.value().e(), Eq(key_or.value().public_key().e()));
}
TEST(EcdsaSignKeyManagerTest, Create) {
@@ -247,7 +244,7 @@
StatusOr<RsaSsaPkcs1PrivateKey> key_or =
RsaSsaPkcs1SignKeyManager().CreateKey(key_format);
ASSERT_THAT(key_or.status(), IsOk());
- RsaSsaPkcs1PrivateKey key = key_or.ValueOrDie();
+ RsaSsaPkcs1PrivateKey key = key_or.value();
auto signer_or = RsaSsaPkcs1SignKeyManager().GetPrimitive<PublicKeySign>(key);
ASSERT_THAT(signer_or.status(), IsOk());
@@ -257,8 +254,8 @@
ASSERT_THAT(direct_verifier_or.status(), IsOk());
std::string message = "Some message";
- EXPECT_THAT(direct_verifier_or.ValueOrDie()->Verify(
- signer_or.ValueOrDie()->Sign(message).ValueOrDie(), message),
+ EXPECT_THAT(direct_verifier_or.value()->Verify(
+ signer_or.ValueOrDie()->Sign(message).value(), message),
IsOk());
}
diff --git a/cc/signature/rsa_ssa_pkcs1_verify_key_manager.cc b/cc/signature/rsa_ssa_pkcs1_verify_key_manager.cc
index 92e35fa..06f4964 100644
--- a/cc/signature/rsa_ssa_pkcs1_verify_key_manager.cc
+++ b/cc/signature/rsa_ssa_pkcs1_verify_key_manager.cc
@@ -55,7 +55,7 @@
auto rsa_ssa_pkcs1_result =
subtle::RsaSsaPkcs1VerifyBoringSsl::New(rsa_pub_key, params);
if (!rsa_ssa_pkcs1_result.ok()) return rsa_ssa_pkcs1_result.status();
- return {std::move(rsa_ssa_pkcs1_result.ValueOrDie())};
+ return {std::move(rsa_ssa_pkcs1_result.value())};
}
util::Status RsaSsaPkcs1VerifyKeyManager::ValidateParams(
diff --git a/cc/signature/rsa_ssa_pkcs1_verify_key_manager_test.cc b/cc/signature/rsa_ssa_pkcs1_verify_key_manager_test.cc
index f6d769c..a0739c9 100644
--- a/cc/signature/rsa_ssa_pkcs1_verify_key_manager_test.cc
+++ b/cc/signature/rsa_ssa_pkcs1_verify_key_manager_test.cc
@@ -80,7 +80,7 @@
internal::SslUniquePtr<BIGNUM> e(BN_new());
BN_set_word(e.get(), public_exponent);
key_format.set_public_exponent(
- internal::BignumToString(e.get(), BN_num_bytes(e.get())).ValueOrDie());
+ internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
return key_format;
}
@@ -89,13 +89,13 @@
}
RsaSsaPkcs1PrivateKey CreateValidPrivateKey() {
- return RsaSsaPkcs1SignKeyManager().CreateKey(ValidKeyFormat()).ValueOrDie();
+ return RsaSsaPkcs1SignKeyManager().CreateKey(ValidKeyFormat()).value();
}
RsaSsaPkcs1PublicKey CreateValidPublicKey() {
return RsaSsaPkcs1SignKeyManager()
.GetPublicKey(CreateValidPrivateKey())
- .ValueOrDie();
+ .value();
}
// Checks that a public key generaed by the SignKeyManager is considered valid.
@@ -131,9 +131,9 @@
StatusOr<RsaSsaPkcs1PrivateKey> private_key_or =
RsaSsaPkcs1SignKeyManager().CreateKey(key_format);
ASSERT_THAT(private_key_or.status(), IsOk());
- RsaSsaPkcs1PrivateKey private_key = private_key_or.ValueOrDie();
+ RsaSsaPkcs1PrivateKey private_key = private_key_or.value();
RsaSsaPkcs1PublicKey public_key =
- RsaSsaPkcs1SignKeyManager().GetPublicKey(private_key).ValueOrDie();
+ RsaSsaPkcs1SignKeyManager().GetPublicKey(private_key).value();
internal::RsaPrivateKey private_key_subtle;
private_key_subtle.n = private_key.public_key().n();
@@ -154,8 +154,8 @@
std::string message = "Some message";
EXPECT_THAT(
- verifier_or.ValueOrDie()->Verify(
- direct_signer_or.ValueOrDie()->Sign(message).ValueOrDie(), message),
+ verifier_or.value()->Verify(
+ direct_signer_or.ValueOrDie()->Sign(message).value(), message),
IsOk());
}
@@ -205,8 +205,8 @@
auto result =
RsaSsaPkcs1VerifyKeyManager().GetPrimitive<PublicKeyVerify>(key);
EXPECT_THAT(result.status(), IsOk());
- EXPECT_THAT(result.ValueOrDie()->Verify(nist_test_vector.signature,
- nist_test_vector.message),
+ EXPECT_THAT(result.value()->Verify(nist_test_vector.signature,
+ nist_test_vector.message),
IsOk());
}
diff --git a/cc/signature/rsa_ssa_pss_sign_key_manager.cc b/cc/signature/rsa_ssa_pss_sign_key_manager.cc
index 7e18d08..8d6bd25 100644
--- a/cc/signature/rsa_ssa_pss_sign_key_manager.cc
+++ b/cc/signature/rsa_ssa_pss_sign_key_manager.cc
@@ -123,7 +123,7 @@
private_key.public_key());
if (!verifier.ok()) return verifier.status();
auto sign_verify_result =
- SignAndVerify(signer.ValueOrDie().get(), verifier.ValueOrDie().get());
+ SignAndVerify(signer.value().get(), verifier.value().get());
if (!sign_verify_result.ok()) {
return util::Status(absl::StatusCode::kInternal,
"security bug: signing with private key followed by "
diff --git a/cc/signature/rsa_ssa_pss_sign_key_manager_test.cc b/cc/signature/rsa_ssa_pss_sign_key_manager_test.cc
index 3665fd6..843a758 100644
--- a/cc/signature/rsa_ssa_pss_sign_key_manager_test.cc
+++ b/cc/signature/rsa_ssa_pss_sign_key_manager_test.cc
@@ -72,7 +72,7 @@
internal::SslUniquePtr<BIGNUM> e(BN_new());
BN_set_word(e.get(), public_exponent);
key_format.set_public_exponent(
- internal::BignumToString(e.get(), BN_num_bytes(e.get())).ValueOrDie());
+ internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
return key_format;
}
@@ -199,7 +199,7 @@
StatusOr<RsaSsaPssPrivateKey> private_key_or =
RsaSsaPssSignKeyManager().CreateKey(key_format);
ASSERT_THAT(private_key_or.status(), IsOk());
- CheckNewKey(private_key_or.ValueOrDie(), key_format);
+ CheckNewKey(private_key_or.value(), key_format);
}
TEST(RsaSsaPssSignKeyManagerTest, CreateKeySmallKey) {
@@ -209,7 +209,7 @@
StatusOr<RsaSsaPssPrivateKey> private_key_or =
RsaSsaPssSignKeyManager().CreateKey(key_format);
ASSERT_THAT(private_key_or.status(), IsOk());
- CheckNewKey(private_key_or.ValueOrDie(), key_format);
+ CheckNewKey(private_key_or.value(), key_format);
}
TEST(RsaSsaPssSignKeyManagerTest, CreateKeyLargeKey) {
@@ -219,15 +219,14 @@
StatusOr<RsaSsaPssPrivateKey> private_key_or =
RsaSsaPssSignKeyManager().CreateKey(key_format);
ASSERT_THAT(private_key_or.status(), IsOk());
- CheckNewKey(private_key_or.ValueOrDie(), key_format);
+ CheckNewKey(private_key_or.value(), key_format);
}
TEST(RsaSsaPssSignKeyManagerTest, CreateKeyValid) {
StatusOr<RsaSsaPssPrivateKey> key_or =
RsaSsaPssSignKeyManager().CreateKey(ValidKeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(RsaSsaPssSignKeyManager().ValidateKey(key_or.ValueOrDie()),
- IsOk());
+ EXPECT_THAT(RsaSsaPssSignKeyManager().ValidateKey(key_or.value()), IsOk());
}
// Check that in a bunch of CreateKey calls all generated primes are distinct.
@@ -239,8 +238,8 @@
StatusOr<RsaSsaPssPrivateKey> key_or =
RsaSsaPssSignKeyManager().CreateKey(ValidKeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
- keys.insert(key_or.ValueOrDie().p());
- keys.insert(key_or.ValueOrDie().q());
+ keys.insert(key_or.value().p());
+ keys.insert(key_or.value().q());
}
EXPECT_THAT(keys, SizeIs(2 * num_generated_keys));
}
@@ -250,14 +249,12 @@
RsaSsaPssSignKeyManager().CreateKey(ValidKeyFormat());
ASSERT_THAT(key_or.status(), IsOk());
StatusOr<RsaSsaPssPublicKey> public_key_or =
- RsaSsaPssSignKeyManager().GetPublicKey(key_or.ValueOrDie());
+ RsaSsaPssSignKeyManager().GetPublicKey(key_or.value());
ASSERT_THAT(public_key_or.status(), IsOk());
- EXPECT_THAT(public_key_or.ValueOrDie().version(),
- Eq(key_or.ValueOrDie().public_key().version()));
- EXPECT_THAT(public_key_or.ValueOrDie().n(),
- Eq(key_or.ValueOrDie().public_key().n()));
- EXPECT_THAT(public_key_or.ValueOrDie().e(),
- Eq(key_or.ValueOrDie().public_key().e()));
+ EXPECT_THAT(public_key_or.value().version(),
+ Eq(key_or.value().public_key().version()));
+ EXPECT_THAT(public_key_or.value().n(), Eq(key_or.value().public_key().n()));
+ EXPECT_THAT(public_key_or.value().e(), Eq(key_or.value().public_key().e()));
}
TEST(RsaSsaPssSignKeyManagerTest, Create) {
@@ -266,7 +263,7 @@
StatusOr<RsaSsaPssPrivateKey> key_or =
RsaSsaPssSignKeyManager().CreateKey(key_format);
ASSERT_THAT(key_or.status(), IsOk());
- RsaSsaPssPrivateKey key = key_or.ValueOrDie();
+ RsaSsaPssPrivateKey key = key_or.value();
auto signer_or = RsaSsaPssSignKeyManager().GetPrimitive<PublicKeySign>(key);
ASSERT_THAT(signer_or.status(), IsOk());
@@ -281,8 +278,8 @@
ASSERT_THAT(direct_verifier_or.status(), IsOk());
std::string message = "Some message";
- EXPECT_THAT(direct_verifier_or.ValueOrDie()->Verify(
- signer_or.ValueOrDie()->Sign(message).ValueOrDie(), message),
+ EXPECT_THAT(direct_verifier_or.value()->Verify(
+ signer_or.ValueOrDie()->Sign(message).value(), message),
IsOk());
}
@@ -292,14 +289,14 @@
StatusOr<RsaSsaPssPrivateKey> key_or =
RsaSsaPssSignKeyManager().CreateKey(key_format);
ASSERT_THAT(key_or.status(), IsOk());
- RsaSsaPssPrivateKey key = key_or.ValueOrDie();
+ RsaSsaPssPrivateKey key = key_or.value();
auto signer_or = RsaSsaPssSignKeyManager().GetPrimitive<PublicKeySign>(key);
StatusOr<RsaSsaPssPrivateKey> second_key_or =
RsaSsaPssSignKeyManager().CreateKey(key_format);
ASSERT_THAT(second_key_or.status(), IsOk());
- RsaSsaPssPrivateKey second_key = second_key_or.ValueOrDie();
+ RsaSsaPssPrivateKey second_key = second_key_or.value();
ASSERT_THAT(signer_or.status(), IsOk());
@@ -313,8 +310,8 @@
ASSERT_THAT(direct_verifier_or.status(), IsOk());
std::string message = "Some message";
- EXPECT_THAT(direct_verifier_or.ValueOrDie()->Verify(
- signer_or.ValueOrDie()->Sign(message).ValueOrDie(), message),
+ EXPECT_THAT(direct_verifier_or.value()->Verify(
+ signer_or.ValueOrDie()->Sign(message).value(), message),
Not(IsOk()));
}
diff --git a/cc/signature/rsa_ssa_pss_verify_key_manager.cc b/cc/signature/rsa_ssa_pss_verify_key_manager.cc
index 55220f2..7c7aa8c 100644
--- a/cc/signature/rsa_ssa_pss_verify_key_manager.cc
+++ b/cc/signature/rsa_ssa_pss_verify_key_manager.cc
@@ -61,7 +61,7 @@
auto rsa_ssa_pss_result =
subtle::RsaSsaPssVerifyBoringSsl::New(rsa_pub_key, params);
if (!rsa_ssa_pss_result.ok()) return rsa_ssa_pss_result.status();
- return {std::move(rsa_ssa_pss_result).ValueOrDie()};
+ return {std::move(rsa_ssa_pss_result).value()};
}
Status RsaSsaPssVerifyKeyManager::ValidateKey(
diff --git a/cc/signature/rsa_ssa_pss_verify_key_manager_test.cc b/cc/signature/rsa_ssa_pss_verify_key_manager_test.cc
index 7598594..fb37125 100644
--- a/cc/signature/rsa_ssa_pss_verify_key_manager_test.cc
+++ b/cc/signature/rsa_ssa_pss_verify_key_manager_test.cc
@@ -79,7 +79,7 @@
internal::SslUniquePtr<BIGNUM> e(BN_new());
BN_set_word(e.get(), public_exponent);
key_format.set_public_exponent(
- internal::BignumToString(e.get(), BN_num_bytes(e.get())).ValueOrDie());
+ internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
return key_format;
}
@@ -89,13 +89,13 @@
}
RsaSsaPssPrivateKey CreateValidPrivateKey() {
- return RsaSsaPssSignKeyManager().CreateKey(ValidKeyFormat()).ValueOrDie();
+ return RsaSsaPssSignKeyManager().CreateKey(ValidKeyFormat()).value();
}
RsaSsaPssPublicKey CreateValidPublicKey() {
return RsaSsaPssSignKeyManager()
.GetPublicKey(CreateValidPrivateKey())
- .ValueOrDie();
+ .value();
}
// Checks that a public key generaed by the SignKeyManager is considered valid.
@@ -152,9 +152,9 @@
StatusOr<RsaSsaPssPrivateKey> private_key_or =
RsaSsaPssSignKeyManager().CreateKey(key_format);
ASSERT_THAT(private_key_or.status(), IsOk());
- RsaSsaPssPrivateKey private_key = private_key_or.ValueOrDie();
+ RsaSsaPssPrivateKey private_key = private_key_or.value();
RsaSsaPssPublicKey public_key =
- RsaSsaPssSignKeyManager().GetPublicKey(private_key).ValueOrDie();
+ RsaSsaPssSignKeyManager().GetPublicKey(private_key).value();
internal::RsaPrivateKey private_key_subtle;
private_key_subtle.n = private_key.public_key().n();
@@ -176,8 +176,8 @@
std::string message = "Some message";
EXPECT_THAT(
- verifier_or.ValueOrDie()->Verify(
- direct_signer_or.ValueOrDie()->Sign(message).ValueOrDie(), message),
+ verifier_or.value()->Verify(
+ direct_signer_or.ValueOrDie()->Sign(message).value(), message),
IsOk());
}
@@ -234,8 +234,8 @@
key.set_e(nist_test_vector->e);
auto result = RsaSsaPssVerifyKeyManager().GetPrimitive<PublicKeyVerify>(key);
ASSERT_THAT(result.status(), IsOk());
- EXPECT_THAT(result.ValueOrDie()->Verify(nist_test_vector->signature,
- nist_test_vector->message),
+ EXPECT_THAT(result.value()->Verify(nist_test_vector->signature,
+ nist_test_vector->message),
IsOk());
}
diff --git a/cc/signature/sig_util.cc b/cc/signature/sig_util.cc
index fb695d7..dae9b8d 100644
--- a/cc/signature/sig_util.cc
+++ b/cc/signature/sig_util.cc
@@ -24,7 +24,7 @@
static constexpr char kTestMessage[] = "Wycheproof and Tink.";
auto sign_result = signer->Sign(kTestMessage);
if (!sign_result.ok()) return sign_result.status();
- return verifier->Verify(sign_result.ValueOrDie(), kTestMessage);
+ return verifier->Verify(sign_result.value(), kTestMessage);
}
} // namespace tink
diff --git a/cc/signature/signature_config_test.cc b/cc/signature/signature_config_test.cc
index ff35b76..b30ac9a 100644
--- a/cc/signature/signature_config_test.cc
+++ b/cc/signature/signature_config_test.cc
@@ -98,20 +98,19 @@
primitive_set
->AddPrimitive(absl::make_unique<DummyPublicKeySign>("dummy"),
key_info)
- .ValueOrDie()),
+ .value()),
IsOk());
auto wrapped = Registry::Wrap(std::move(primitive_set));
ASSERT_TRUE(wrapped.ok()) << wrapped.status();
- auto signature_result = wrapped.ValueOrDie()->Sign("message");
+ auto signature_result = wrapped.value()->Sign("message");
ASSERT_TRUE(signature_result.ok());
- std::string prefix = CryptoFormat::GetOutputPrefix(key_info).ValueOrDie();
- EXPECT_EQ(
- signature_result.ValueOrDie(),
- absl::StrCat(prefix,
- DummyPublicKeySign("dummy").Sign("message").ValueOrDie()));
+ std::string prefix = CryptoFormat::GetOutputPrefix(key_info).value();
+ EXPECT_EQ(signature_result.value(),
+ absl::StrCat(prefix,
+ DummyPublicKeySign("dummy").Sign("message").value()));
}
@@ -135,18 +134,16 @@
primitive_set
->AddPrimitive(absl::make_unique<DummyPublicKeyVerify>("dummy"),
key_info)
- .ValueOrDie()),
+ .value()),
IsOk());
- std::string prefix = CryptoFormat::GetOutputPrefix(key_info).ValueOrDie();
- std::string signature =
- DummyPublicKeySign("dummy").Sign("message").ValueOrDie();
+ std::string prefix = CryptoFormat::GetOutputPrefix(key_info).value();
+ std::string signature = DummyPublicKeySign("dummy").Sign("message").value();
auto wrapped = Registry::Wrap(std::move(primitive_set));
ASSERT_TRUE(wrapped.ok()) << wrapped.status();
- ASSERT_TRUE(wrapped.ValueOrDie()
- ->Verify(absl::StrCat(prefix, signature), "message")
- .ok());
+ ASSERT_TRUE(
+ wrapped.value()->Verify(absl::StrCat(prefix, signature), "message").ok());
}
// FIPS-only mode tests
diff --git a/cc/signature/signature_key_templates.cc b/cc/signature/signature_key_templates.cc
index e279790..a95c3bf 100644
--- a/cc/signature/signature_key_templates.cc
+++ b/cc/signature/signature_key_templates.cc
@@ -84,7 +84,7 @@
internal::SslUniquePtr<BIGNUM> e(BN_new());
BN_set_word(e.get(), public_exponent);
key_format.set_public_exponent(
- internal::BignumToString(e.get(), BN_num_bytes(e.get())).ValueOrDie());
+ internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
key_format.SerializeToString(key_template->mutable_value());
return key_template;
}
@@ -107,7 +107,7 @@
internal::SslUniquePtr<BIGNUM> e(BN_new());
BN_set_word(e.get(), public_exponent);
key_format.set_public_exponent(
- internal::BignumToString(e.get(), BN_num_bytes(e.get())).ValueOrDie());
+ internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
key_format.SerializeToString(key_template->mutable_value());
return key_template;
}
diff --git a/cc/signature/signature_pem_keyset_reader.cc b/cc/signature/signature_pem_keyset_reader.cc
index 4248606..fc397e0 100644
--- a/cc/signature/signature_pem_keyset_reader.cc
+++ b/cc/signature/signature_pem_keyset_reader.cc
@@ -79,7 +79,7 @@
parameters->set_sig_hash(pem_parameters.hash_type);
auto salt_len_or = util::Enums::HashLength(pem_parameters.hash_type);
if (!salt_len_or.ok()) return salt_len_or.status();
- parameters->set_salt_length(salt_len_or.ValueOrDie());
+ parameters->set_salt_length(salt_len_or.value());
return util::OkStatus();
}
@@ -212,7 +212,7 @@
if (!private_key_subtle_or.ok()) return private_key_subtle_or.status();
std::unique_ptr<internal::RsaPrivateKey> private_key_subtle =
- std::move(private_key_subtle_or).ValueOrDie();
+ std::move(private_key_subtle_or).value();
size_t modulus_size = private_key_subtle->n.length() * 8;
if (pem_key.parameters.key_size_in_bits != modulus_size) {
@@ -228,7 +228,7 @@
auto private_key_proto_or = NewRsaSsaPrivateKey(
*private_key_subtle, key_manager.get_version(), pem_key.parameters);
if (!private_key_proto_or.ok()) return private_key_proto_or.status();
- RsaSsaPssPrivateKey private_key_proto = private_key_proto_or.ValueOrDie();
+ RsaSsaPssPrivateKey private_key_proto = private_key_proto_or.value();
// Validate the key.
auto key_validation_status = key_manager.ValidateKey(private_key_proto);
@@ -273,7 +273,7 @@
if (!public_key_subtle_or.ok()) return public_key_subtle_or.status();
std::unique_ptr<internal::EcKey> public_key_subtle =
- std::move(public_key_subtle_or).ValueOrDie();
+ std::move(public_key_subtle_or).value();
EcdsaPublicKey ecdsa_key;
EcdsaVerifyKeyManager key_manager;
@@ -307,7 +307,7 @@
if (!public_key_subtle_or.ok()) return public_key_subtle_or.status();
std::unique_ptr<internal::RsaPublicKey> public_key_subtle =
- std::move(public_key_subtle_or).ValueOrDie();
+ std::move(public_key_subtle_or).value();
// Check key length is as expected.
size_t modulus_size = public_key_subtle->n.length() * 8;
@@ -426,7 +426,7 @@
// Set the 1st key as primary.
keyset->set_primary_key_id(keyset->key(0).key_id());
- return keyset;
+ return std::move(keyset);
}
util::StatusOr<std::unique_ptr<Keyset>> PublicKeyVerifyPemKeysetReader::Read() {
@@ -453,7 +453,7 @@
// Set the 1st key as primary.
keyset->set_primary_key_id(keyset->key(0).key_id());
- return keyset;
+ return std::move(keyset);
}
util::StatusOr<std::unique_ptr<EncryptedKeyset>>
diff --git a/cc/signature/signature_pem_keyset_reader_test.cc b/cc/signature/signature_pem_keyset_reader_test.cc
index 7a37dc3..e67df05 100644
--- a/cc/signature/signature_pem_keyset_reader_test.cc
+++ b/cc/signature/signature_pem_keyset_reader_test.cc
@@ -177,7 +177,7 @@
public_key_proto.mutable_params()->set_mgf1_hash(hash_type);
public_key_proto.mutable_params()->set_sig_hash(hash_type);
public_key_proto.mutable_params()->set_salt_length(
- util::Enums::HashLength(hash_type).ValueOrDie());
+ util::Enums::HashLength(hash_type).value());
return public_key_proto;
}
@@ -223,7 +223,7 @@
public_key_proto->mutable_params()->set_mgf1_hash(hash_type);
public_key_proto->mutable_params()->set_sig_hash(hash_type);
public_key_proto->mutable_params()->set_salt_length(
- util::Enums::HashLength(hash_type).ValueOrDie());
+ util::Enums::HashLength(hash_type).value());
return private_key_proto;
}
@@ -250,7 +250,7 @@
auto keyset_reader_or = builder.Build();
ASSERT_THAT(keyset_reader_or.status(), IsOk());
std::unique_ptr<KeysetReader> keyset_reader =
- std::move(keyset_reader_or).ValueOrDie();
+ std::move(keyset_reader_or).value();
EXPECT_THAT(keyset_reader->ReadEncrypted().status(),
StatusIs(absl::StatusCode::kUnimplemented));
@@ -275,11 +275,11 @@
auto keyset_reader_or = builder.Build();
ASSERT_THAT(keyset_reader_or.status(), IsOk());
std::unique_ptr<KeysetReader> keyset_reader =
- std::move(keyset_reader_or).ValueOrDie();
+ std::move(keyset_reader_or).value();
auto keyset_or = keyset_reader->Read();
ASSERT_THAT(keyset_or.status(), IsOk());
- std::unique_ptr<Keyset> keyset = std::move(keyset_or).ValueOrDie();
+ std::unique_ptr<Keyset> keyset = std::move(keyset_or).value();
// Key manager to validate key type and key material type.
RsaSsaPssVerifyKeyManager verify_key_manager;
@@ -345,11 +345,11 @@
auto keyset_reader_or = builder.Build();
ASSERT_THAT(keyset_reader_or.status(), IsOk());
std::unique_ptr<KeysetReader> keyset_reader =
- std::move(keyset_reader_or).ValueOrDie();
+ std::move(keyset_reader_or).value();
auto keyset_or = keyset_reader->Read();
ASSERT_THAT(keyset_or.status(), IsOk());
- std::unique_ptr<Keyset> keyset = std::move(keyset_or).ValueOrDie();
+ std::unique_ptr<Keyset> keyset = std::move(keyset_or).value();
EXPECT_THAT(keyset->key(), SizeIs(2));
EXPECT_EQ(keyset->primary_key_id(), keyset->key(0).key_id());
@@ -409,7 +409,7 @@
auto keyset_reader_or = builder.Build();
ASSERT_THAT(keyset_reader_or.status(), IsOk());
std::unique_ptr<KeysetReader> keyset_reader =
- std::move(keyset_reader_or).ValueOrDie();
+ std::move(keyset_reader_or).value();
EXPECT_THAT(keyset_reader->Read().status(),
StatusIs(absl::StatusCode::kInvalidArgument));
@@ -430,7 +430,7 @@
auto keyset_reader_or = builder.Build();
ASSERT_THAT(keyset_reader_or.status(), IsOk());
std::unique_ptr<KeysetReader> keyset_reader =
- std::move(keyset_reader_or).ValueOrDie();
+ std::move(keyset_reader_or).value();
EXPECT_THAT(keyset_reader->Read().status(),
StatusIs(absl::StatusCode::kInvalidArgument));
@@ -450,7 +450,7 @@
auto keyset_reader_or = builder.Build();
ASSERT_THAT(keyset_reader_or.status(), IsOk());
std::unique_ptr<KeysetReader> keyset_reader =
- std::move(keyset_reader_or).ValueOrDie();
+ std::move(keyset_reader_or).value();
EXPECT_THAT(keyset_reader->Read().status(),
StatusIs(absl::StatusCode::kInvalidArgument));
@@ -471,7 +471,7 @@
auto keyset_reader_or = builder.Build();
ASSERT_THAT(keyset_reader_or.status(), IsOk());
std::unique_ptr<KeysetReader> keyset_reader =
- std::move(keyset_reader_or).ValueOrDie();
+ std::move(keyset_reader_or).value();
EXPECT_THAT(keyset_reader->Read().status(),
StatusIs(absl::StatusCode::kInvalidArgument));
@@ -491,7 +491,7 @@
auto keyset_reader_or = builder.Build();
ASSERT_THAT(keyset_reader_or.status(), IsOk());
std::unique_ptr<KeysetReader> keyset_reader =
- std::move(keyset_reader_or).ValueOrDie();
+ std::move(keyset_reader_or).value();
EXPECT_THAT(keyset_reader->Read().status(),
StatusIs(absl::StatusCode::kInvalidArgument));
@@ -518,7 +518,7 @@
auto keyset_read = reader->get()->Read();
ASSERT_THAT(keyset_read.status(), IsOk());
- std::unique_ptr<Keyset> keyset = std::move(keyset_read).ValueOrDie();
+ std::unique_ptr<Keyset> keyset = std::move(keyset_read).value();
// Key manager to validate key type and key material type.
EcdsaVerifyKeyManager key_manager;
diff --git a/cc/streamingaead/aes_ctr_hmac_streaming_key_manager.cc b/cc/streamingaead/aes_ctr_hmac_streaming_key_manager.cc
index 8524d86..a5e5eee 100644
--- a/cc/streamingaead/aes_ctr_hmac_streaming_key_manager.cc
+++ b/cc/streamingaead/aes_ctr_hmac_streaming_key_manager.cc
@@ -102,7 +102,7 @@
}
AesCtrHmacStreamingKey key;
key.set_version(get_version());
- key.set_key_value(randomness_or.ValueOrDie());
+ key.set_key_value(randomness_or.value());
*key.mutable_params() = key_format.params();
return key;
}
diff --git a/cc/streamingaead/aes_ctr_hmac_streaming_key_manager.h b/cc/streamingaead/aes_ctr_hmac_streaming_key_manager.h
index b2139c3..5028c39 100644
--- a/cc/streamingaead/aes_ctr_hmac_streaming_key_manager.h
+++ b/cc/streamingaead/aes_ctr_hmac_streaming_key_manager.h
@@ -61,7 +61,7 @@
auto streaming_result =
crypto::tink::subtle::AesCtrHmacStreaming::New(params);
if (!streaming_result.ok()) return streaming_result.status();
- return {std::move(streaming_result.ValueOrDie())};
+ return {std::move(streaming_result.value())};
}
};
diff --git a/cc/streamingaead/aes_ctr_hmac_streaming_key_manager_test.cc b/cc/streamingaead/aes_ctr_hmac_streaming_key_manager_test.cc
index 3318d68..82ccad8 100644
--- a/cc/streamingaead/aes_ctr_hmac_streaming_key_manager_test.cc
+++ b/cc/streamingaead/aes_ctr_hmac_streaming_key_manager_test.cc
@@ -132,8 +132,8 @@
// Check that the two primitives are the same by encrypting with one, and
// decrypting with the other.
EXPECT_THAT(
- EncryptThenDecrypt(streaming_aead_from_manager_result.ValueOrDie().get(),
- streaming_aead_direct_result.ValueOrDie().get(),
+ EncryptThenDecrypt(streaming_aead_from_manager_result.value().get(),
+ streaming_aead_direct_result.value().get(),
subtle::Random::GetRandomBytes(10000),
"some associated data", params.ciphertext_offset),
IsOk());
@@ -237,18 +237,17 @@
key_format.mutable_params()->mutable_hmac_params()->set_tag_size(32);
auto key_or = AesCtrHmacStreamingKeyManager().CreateKey(key_format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().version(), Eq(0));
- EXPECT_THAT(key_or.ValueOrDie().params().ciphertext_segment_size(),
+ EXPECT_THAT(key_or.value().version(), Eq(0));
+ EXPECT_THAT(key_or.value().params().ciphertext_segment_size(),
Eq(key_format.params().ciphertext_segment_size()));
- EXPECT_THAT(key_or.ValueOrDie().params().derived_key_size(),
+ EXPECT_THAT(key_or.value().params().derived_key_size(),
Eq(key_format.params().derived_key_size()));
- EXPECT_THAT(key_or.ValueOrDie().params().hkdf_hash_type(),
+ EXPECT_THAT(key_or.value().params().hkdf_hash_type(),
Eq(key_format.params().hkdf_hash_type()));
- EXPECT_THAT(key_or.ValueOrDie().key_value().size(),
- Eq(key_format.key_size()));
- EXPECT_THAT(key_or.ValueOrDie().params().hmac_params().hash(),
+ EXPECT_THAT(key_or.value().key_value().size(), Eq(key_format.key_size()));
+ EXPECT_THAT(key_or.value().params().hmac_params().hash(),
Eq(key_format.params().hmac_params().hash()));
- EXPECT_THAT(key_or.ValueOrDie().params().hmac_params().tag_size(),
+ EXPECT_THAT(key_or.value().params().hmac_params().tag_size(),
Eq(key_format.params().hmac_params().tag_size()));
}
@@ -266,13 +265,13 @@
util::StatusOr<AesCtrHmacStreamingKey> key_or =
AesCtrHmacStreamingKeyManager().DeriveKey(key_format, &input_stream);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(),
+ EXPECT_THAT(key_or.value().key_value(),
Eq("01234567890123456789012345678901"));
- EXPECT_THAT(key_or.ValueOrDie().params().derived_key_size(),
+ EXPECT_THAT(key_or.value().params().derived_key_size(),
Eq(key_format.params().derived_key_size()));
- EXPECT_THAT(key_or.ValueOrDie().params().hkdf_hash_type(),
+ EXPECT_THAT(key_or.value().params().hkdf_hash_type(),
Eq(key_format.params().hkdf_hash_type()));
- EXPECT_THAT(key_or.ValueOrDie().params().ciphertext_segment_size(),
+ EXPECT_THAT(key_or.value().params().ciphertext_segment_size(),
Eq(key_format.params().ciphertext_segment_size()));
}
diff --git a/cc/streamingaead/aes_gcm_hkdf_streaming_key_manager.cc b/cc/streamingaead/aes_gcm_hkdf_streaming_key_manager.cc
index efe9c1c..9521441 100644
--- a/cc/streamingaead/aes_gcm_hkdf_streaming_key_manager.cc
+++ b/cc/streamingaead/aes_gcm_hkdf_streaming_key_manager.cc
@@ -82,7 +82,7 @@
}
AesGcmHkdfStreamingKey key;
key.set_version(get_version());
- key.set_key_value(randomness_or.ValueOrDie());
+ key.set_key_value(randomness_or.value());
*key.mutable_params() = key_format.params();
return key;
}
diff --git a/cc/streamingaead/aes_gcm_hkdf_streaming_key_manager.h b/cc/streamingaead/aes_gcm_hkdf_streaming_key_manager.h
index 5c66c1c..418e1a0 100644
--- a/cc/streamingaead/aes_gcm_hkdf_streaming_key_manager.h
+++ b/cc/streamingaead/aes_gcm_hkdf_streaming_key_manager.h
@@ -58,7 +58,7 @@
auto streaming_result =
subtle::AesGcmHkdfStreaming::New(std::move(params));
if (!streaming_result.ok()) return streaming_result.status();
- return {std::move(streaming_result.ValueOrDie())};
+ return {std::move(streaming_result.value())};
}
};
diff --git a/cc/streamingaead/aes_gcm_hkdf_streaming_key_manager_test.cc b/cc/streamingaead/aes_gcm_hkdf_streaming_key_manager_test.cc
index 38f9c80..267b007 100644
--- a/cc/streamingaead/aes_gcm_hkdf_streaming_key_manager_test.cc
+++ b/cc/streamingaead/aes_gcm_hkdf_streaming_key_manager_test.cc
@@ -128,8 +128,8 @@
// Check that the two primitives are the same by encrypting with one, and
// decrypting with the other.
EXPECT_THAT(
- EncryptThenDecrypt(streaming_aead_from_manager_result.ValueOrDie().get(),
- streaming_aead_direct_result.ValueOrDie().get(),
+ EncryptThenDecrypt(streaming_aead_from_manager_result.value().get(),
+ streaming_aead_direct_result.value().get(),
subtle::Random::GetRandomBytes(10000),
"some associated data", ciphertext_offset),
IsOk());
@@ -206,15 +206,14 @@
key_format.mutable_params()->set_ciphertext_segment_size(1024);
auto key_or = AesGcmHkdfStreamingKeyManager().CreateKey(key_format);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().version(), Eq(0));
- EXPECT_THAT(key_or.ValueOrDie().params().ciphertext_segment_size(),
+ EXPECT_THAT(key_or.value().version(), Eq(0));
+ EXPECT_THAT(key_or.value().params().ciphertext_segment_size(),
Eq(key_format.params().ciphertext_segment_size()));
- EXPECT_THAT(key_or.ValueOrDie().params().derived_key_size(),
+ EXPECT_THAT(key_or.value().params().derived_key_size(),
Eq(key_format.params().derived_key_size()));
- EXPECT_THAT(key_or.ValueOrDie().params().hkdf_hash_type(),
+ EXPECT_THAT(key_or.value().params().hkdf_hash_type(),
Eq(key_format.params().hkdf_hash_type()));
- EXPECT_THAT(key_or.ValueOrDie().key_value().size(),
- Eq(key_format.key_size()));
+ EXPECT_THAT(key_or.value().key_value().size(), Eq(key_format.key_size()));
}
TEST(AesGcmHkdfStreamingKeyManagerTest, DeriveKey) {
@@ -231,13 +230,13 @@
StatusOr<AesGcmHkdfStreamingKey> key_or =
AesGcmHkdfStreamingKeyManager().DeriveKey(key_format, &input_stream);
ASSERT_THAT(key_or.status(), IsOk());
- EXPECT_THAT(key_or.ValueOrDie().key_value(),
+ EXPECT_THAT(key_or.value().key_value(),
Eq("01234567890123456789012345678901"));
- EXPECT_THAT(key_or.ValueOrDie().params().derived_key_size(),
+ EXPECT_THAT(key_or.value().params().derived_key_size(),
Eq(key_format.params().derived_key_size()));
- EXPECT_THAT(key_or.ValueOrDie().params().hkdf_hash_type(),
+ EXPECT_THAT(key_or.value().params().hkdf_hash_type(),
Eq(key_format.params().hkdf_hash_type()));
- EXPECT_THAT(key_or.ValueOrDie().params().ciphertext_segment_size(),
+ EXPECT_THAT(key_or.value().params().ciphertext_segment_size(),
Eq(key_format.params().ciphertext_segment_size()));
}
diff --git a/cc/streamingaead/buffered_input_stream.cc b/cc/streamingaead/buffered_input_stream.cc
index af2be3d..5654a4f 100644
--- a/cc/streamingaead/buffered_input_stream.cc
+++ b/cc/streamingaead/buffered_input_stream.cc
@@ -88,7 +88,7 @@
status_ = next_result.status();
return status_;
}
- size_t count_read = next_result.ValueOrDie();
+ size_t count_read = next_result.value();
if (buffer_.size() < count_in_buffer_ + count_read) {
buffer_.resize(buffer_.size() + std::max(buffer_.size(), count_read));
}
diff --git a/cc/streamingaead/buffered_input_stream_test.cc b/cc/streamingaead/buffered_input_stream_test.cc
index 59740e3..d222878 100644
--- a/cc/streamingaead/buffered_input_stream_test.cc
+++ b/cc/streamingaead/buffered_input_stream_test.cc
@@ -76,7 +76,7 @@
return util::OkStatus();
}
if (!next_result.ok()) return next_result.status();
- auto read_bytes = next_result.ValueOrDie();
+ auto read_bytes = next_result.value();
auto used_bytes = std::min(read_bytes, bytes_to_read);
if (used_bytes > 0) {
output->append(
@@ -160,7 +160,7 @@
auto next_result = buf_stream->Next(&buf);
if (read_size < input_size) {
EXPECT_THAT(next_result.status(), IsOk());
- auto next_size = next_result.ValueOrDie();
+ auto next_size = next_result.value();
EXPECT_LE(next_size, kBufferSize);
EXPECT_EQ(pos + next_size, buf_stream->Position());
buf_stream->BackUp(next_size);
@@ -192,7 +192,7 @@
next_result = buf_stream->Next(&buf);
if (read_size < input_size) {
EXPECT_THAT(next_result.status(), IsOk());
- auto next_size = next_result.ValueOrDie();
+ auto next_size = next_result.value();
EXPECT_EQ(input_size - pos, next_size);
EXPECT_EQ(input_size, buf_stream->Position());
buf_stream->BackUp(next_size);
@@ -223,7 +223,7 @@
EXPECT_EQ(0, buf_stream->Position());
auto next_result = buf_stream->Next(&buffer);
EXPECT_THAT(next_result.status(), IsOk());
- auto next_size = next_result.ValueOrDie();
+ auto next_size = next_result.value();
EXPECT_EQ(contents.substr(0, next_size),
std::string(static_cast<const char*>(buffer), next_size));
@@ -239,7 +239,7 @@
// Call Next(), it should return exactly the backed up bytes.
next_result = buf_stream->Next(&buffer);
EXPECT_THAT(next_result.status(), IsOk());
- EXPECT_EQ(total_backup_size, next_result.ValueOrDie());
+ EXPECT_EQ(total_backup_size, next_result.value());
EXPECT_EQ(next_size, buf_stream->Position());
EXPECT_EQ(contents.substr(next_size - total_backup_size, total_backup_size),
std::string(static_cast<const char*>(buffer), total_backup_size));
diff --git a/cc/streamingaead/decrypting_input_stream.cc b/cc/streamingaead/decrypting_input_stream.cc
index 43353ce..d09d998 100644
--- a/cc/streamingaead/decrypting_input_stream.cc
+++ b/cc/streamingaead/decrypting_input_stream.cc
@@ -72,18 +72,18 @@
if (!raw_primitives_result.ok()) {
return Status(absl::StatusCode::kInternal, "No RAW primitives found");
}
- for (auto& primitive : *(raw_primitives_result.ValueOrDie())) {
+ for (auto& primitive : *(raw_primitives_result.value())) {
StreamingAead& streaming_aead = primitive->get_primitive();
auto shared_ct = absl::make_unique<SharedInputStream>(
buffered_ct_source_.get());
auto decrypting_stream_result = streaming_aead.NewDecryptingStream(
std::move(shared_ct), associated_data_);
if (decrypting_stream_result.ok()) {
- auto next_result = decrypting_stream_result.ValueOrDie()->Next(data);
+ auto next_result = decrypting_stream_result.value()->Next(data);
if (next_result.status().code() == absl::StatusCode::kOutOfRange ||
next_result.ok()) { // Found a match.
buffered_ct_source_->DisableRewinding();
- matching_stream_ = std::move(decrypting_stream_result.ValueOrDie());
+ matching_stream_ = std::move(decrypting_stream_result.value());
return next_result;
}
}
diff --git a/cc/streamingaead/decrypting_input_stream_test.cc b/cc/streamingaead/decrypting_input_stream_test.cc
index 98f014a..5306948 100644
--- a/cc/streamingaead/decrypting_input_stream_test.cc
+++ b/cc/streamingaead/decrypting_input_stream_test.cc
@@ -84,7 +84,7 @@
auto enc_stream_result =
saead->NewEncryptingStream(std::move(ct_destination), aad);
EXPECT_THAT(enc_stream_result.status(), IsOk());
- EXPECT_THAT(WriteToStream(enc_stream_result.ValueOrDie().get(), pt), IsOk());
+ EXPECT_THAT(WriteToStream(enc_stream_result.value().get(), pt), IsOk());
// Return the ciphertext as InputStream.
auto ct_stream3 = absl::make_unique<std::stringstream>(ct_buf->str());
@@ -120,7 +120,7 @@
auto entry_result = saead_set->AddPrimitive(std::move(saead), key_info);
EXPECT_TRUE(entry_result.ok());
if (i + 1 == spec.size()) {
- EXPECT_THAT(saead_set->set_primary(entry_result.ValueOrDie()), IsOk());
+ EXPECT_THAT(saead_set->set_primary(entry_result.value()), IsOk());
}
i++;
}
@@ -148,7 +148,7 @@
// in the primitive set, so that we can test decryption with both
// the primary primitive, and the non-primary ones.
std::vector<std::unique_ptr<InputStream>> ciphertexts;
- for (const auto& p : *(saead_set->get_raw_primitives().ValueOrDie())) {
+ for (const auto& p : *(saead_set->get_raw_primitives().value())) {
ciphertexts.push_back(
GetCiphertextSource(&(p->get_primitive()), plaintext, aad));
}
@@ -161,8 +161,8 @@
DecryptingInputStream::New(saead_set, std::move(ct), aad);
EXPECT_THAT(dec_stream_result.status(), IsOk());
std::string decrypted;
- auto status = ReadFromStream(dec_stream_result.ValueOrDie().get(),
- &decrypted);
+ auto status =
+ ReadFromStream(dec_stream_result.value().get(), &decrypted);
EXPECT_THAT(status, IsOk());
EXPECT_EQ(plaintext, decrypted);
}
@@ -194,8 +194,7 @@
DecryptingInputStream::New(saead_set, std::move(ct), "wrong aad");
EXPECT_THAT(dec_stream_result.status(), IsOk());
std::string decrypted;
- auto status = ReadFromStream(dec_stream_result.ValueOrDie().get(),
- &decrypted);
+ auto status = ReadFromStream(dec_stream_result.value().get(), &decrypted);
EXPECT_THAT(status, StatusIs(absl::StatusCode::kInvalidArgument));
}
}
@@ -224,8 +223,7 @@
DecryptingInputStream::New(saead_set, std::move(wrong_ct), aad);
EXPECT_THAT(dec_stream_result.status(), IsOk());
std::string decrypted;
- auto status = ReadFromStream(dec_stream_result.ValueOrDie().get(),
- &decrypted);
+ auto status = ReadFromStream(dec_stream_result.value().get(), &decrypted);
EXPECT_THAT(status, StatusIs(absl::StatusCode::kInvalidArgument));
}
}
diff --git a/cc/streamingaead/decrypting_random_access_stream.cc b/cc/streamingaead/decrypting_random_access_stream.cc
index 03e23af..df7e9a1 100644
--- a/cc/streamingaead/decrypting_random_access_stream.cc
+++ b/cc/streamingaead/decrypting_random_access_stream.cc
@@ -101,7 +101,7 @@
if (!raw_primitives_result.ok()) {
return Status(absl::StatusCode::kInternal, "No RAW primitives found");
}
- for (auto& primitive : *(raw_primitives_result.ValueOrDie())) {
+ for (auto& primitive : *(raw_primitives_result.value())) {
StreamingAead& streaming_aead = primitive->get_primitive();
auto shared_ct = absl::make_unique<SharedRandomAccessStream>(
ciphertext_source_.get());
@@ -109,11 +109,11 @@
streaming_aead.NewDecryptingRandomAccessStream(
std::move(shared_ct), associated_data_);
if (decrypting_stream_result.ok()) {
- auto status = decrypting_stream_result.ValueOrDie()->PRead(
- position, count, dest_buffer);
+ auto status =
+ decrypting_stream_result.value()->PRead(position, count, dest_buffer);
if (status.ok() || status.code() == absl::StatusCode::kOutOfRange) {
// Found a match.
- matching_stream_ = std::move(decrypting_stream_result.ValueOrDie());
+ matching_stream_ = std::move(decrypting_stream_result.value());
return status;
}
}
diff --git a/cc/streamingaead/decrypting_random_access_stream_test.cc b/cc/streamingaead/decrypting_random_access_stream_test.cc
index bdffeb8..26397ef 100644
--- a/cc/streamingaead/decrypting_random_access_stream_test.cc
+++ b/cc/streamingaead/decrypting_random_access_stream_test.cc
@@ -78,7 +78,7 @@
auto enc_stream_result =
saead->NewEncryptingStream(std::move(ct_destination), aad);
EXPECT_THAT(enc_stream_result.status(), IsOk());
- EXPECT_THAT(WriteToStream(enc_stream_result.ValueOrDie().get(), pt), IsOk());
+ EXPECT_THAT(WriteToStream(enc_stream_result.value().get(), pt), IsOk());
// Return the ciphertext as RandomAccessStream.
return GetRandomAccessStream(ct_buf->str());
@@ -90,7 +90,7 @@
util::Status ReadAll(RandomAccessStream* ra_stream, std::string* contents) {
int chunk_size = 42;
contents->clear();
- auto buffer = std::move(util::Buffer::New(chunk_size).ValueOrDie());
+ auto buffer = std::move(util::Buffer::New(chunk_size).value());
int64_t position = 0;
auto status = ra_stream->PRead(position, chunk_size, buffer.get());
while (status.ok()) {
@@ -129,7 +129,7 @@
auto entry_result = saead_set->AddPrimitive(std::move(saead), key_info);
EXPECT_TRUE(entry_result.ok());
if (i + 1 == spec.size()) {
- EXPECT_THAT(saead_set->set_primary(entry_result.ValueOrDie()), IsOk());
+ EXPECT_THAT(saead_set->set_primary(entry_result.value()), IsOk());
}
i++;
}
@@ -157,7 +157,7 @@
// in the primitive set, so that we can test decryption with both
// the primary primitive, and the non-primary ones.
std::vector<std::unique_ptr<RandomAccessStream>> ciphertexts;
- for (const auto& p : *(saead_set->get_raw_primitives().ValueOrDie())) {
+ for (const auto& p : *(saead_set->get_raw_primitives().value())) {
ciphertexts.push_back(
GetCiphertextSource(&(p->get_primitive()), plaintext, aad));
}
@@ -170,12 +170,12 @@
auto dec_stream_result =
DecryptingRandomAccessStream::New(saead_set, std::move(ct), aad);
EXPECT_THAT(dec_stream_result.status(), IsOk());
- auto dec_stream = std::move(dec_stream_result.ValueOrDie());
+ auto dec_stream = std::move(dec_stream_result.value());
std::string decrypted;
auto status = ReadAll(dec_stream.get(), &decrypted);
EXPECT_THAT(status, StatusIs(absl::StatusCode::kOutOfRange,
HasSubstr("EOF")));
- EXPECT_EQ(pt_size, dec_stream->size().ValueOrDie());
+ EXPECT_EQ(pt_size, dec_stream->size().value());
EXPECT_EQ(plaintext, decrypted);
}
}
@@ -203,7 +203,7 @@
// in the primitive set, so that we can test decryption with both
// the primary primitive, and the non-primary ones.
std::vector<std::unique_ptr<RandomAccessStream>> ciphertexts;
- for (const auto& p : *(saead_set->get_raw_primitives().ValueOrDie())) {
+ for (const auto& p : *(saead_set->get_raw_primitives().value())) {
ciphertexts.push_back(
GetCiphertextSource(&(p->get_primitive()), plaintext, aad));
}
@@ -217,13 +217,13 @@
auto dec_stream_result =
DecryptingRandomAccessStream::New(saead_set, std::move(ct), aad);
EXPECT_THAT(dec_stream_result.status(), IsOk());
- auto dec_stream = std::move(dec_stream_result.ValueOrDie());
+ auto dec_stream = std::move(dec_stream_result.value());
for (int position : {0, 1, 2, pt_size/2, pt_size-1}) {
for (int chunk_size : {1, pt_size/2, pt_size}) {
SCOPED_TRACE(absl::StrCat("ct_number = ", ct_number,
", position = ", position,
", chunk_size = ", chunk_size));
- auto buffer = std::move(util::Buffer::New(chunk_size).ValueOrDie());
+ auto buffer = std::move(util::Buffer::New(chunk_size).value());
auto status = dec_stream->PRead(position, chunk_size, buffer.get());
EXPECT_THAT(status, IsOk());
EXPECT_EQ(std::min(chunk_size, pt_size - position), buffer->size());
@@ -258,7 +258,7 @@
// in the primitive set, so that we can test decryption with both
// the primary primitive, and the non-primary ones.
std::vector<std::unique_ptr<RandomAccessStream>> ciphertexts;
- for (const auto& p : *(saead_set->get_raw_primitives().ValueOrDie())) {
+ for (const auto& p : *(saead_set->get_raw_primitives().value())) {
ciphertexts.push_back(
GetCiphertextSource(&(p->get_primitive()), plaintext, aad));
}
@@ -272,9 +272,9 @@
auto dec_stream_result =
DecryptingRandomAccessStream::New(saead_set, std::move(ct), aad);
EXPECT_THAT(dec_stream_result.status(), IsOk());
- auto dec_stream = std::move(dec_stream_result.ValueOrDie());
+ auto dec_stream = std::move(dec_stream_result.value());
int chunk_size = 1;
- auto buffer = std::move(util::Buffer::New(chunk_size).ValueOrDie());
+ auto buffer = std::move(util::Buffer::New(chunk_size).value());
for (int position : {pt_size, pt_size + 1}) {
SCOPED_TRACE(absl::StrCat("ct_number = ", ct_number,
", position = ", position));
@@ -320,8 +320,7 @@
saead_set, std::move(ct), "wrong aad");
EXPECT_THAT(dec_stream_result.status(), IsOk());
std::string decrypted;
- auto status = ReadAll(dec_stream_result.ValueOrDie().get(),
- &decrypted);
+ auto status = ReadAll(dec_stream_result.value().get(), &decrypted);
EXPECT_THAT(status, StatusIs(absl::StatusCode::kInvalidArgument));
}
}
@@ -351,7 +350,7 @@
saead_set, std::move(wrong_ct), aad);
EXPECT_THAT(dec_stream_result.status(), IsOk());
std::string decrypted;
- auto status = ReadAll(dec_stream_result.ValueOrDie().get(), &decrypted);
+ auto status = ReadAll(dec_stream_result.value().get(), &decrypted);
EXPECT_THAT(status, StatusIs(absl::StatusCode::kInvalidArgument));
}
}
diff --git a/cc/streamingaead/shared_input_stream_test.cc b/cc/streamingaead/shared_input_stream_test.cc
index fcfd8f8..01b9fe9 100644
--- a/cc/streamingaead/shared_input_stream_test.cc
+++ b/cc/streamingaead/shared_input_stream_test.cc
@@ -75,7 +75,7 @@
return util::OkStatus();
}
if (!next_result.ok()) return next_result.status();
- auto read_bytes = next_result.ValueOrDie();
+ auto read_bytes = next_result.value();
auto used_bytes = std::min(read_bytes, bytes_to_read);
if (used_bytes > 0) {
output->append(
@@ -160,7 +160,7 @@
auto next_result = shared_stream->Next(&buf);
if (read_size < input_size) {
EXPECT_THAT(next_result.status(), IsOk());
- auto next_size = next_result.ValueOrDie();
+ auto next_size = next_result.value();
EXPECT_EQ(pos + next_size, shared_stream->Position());
shared_stream->BackUp(next_size);
EXPECT_EQ(pos, shared_stream->Position());
@@ -207,7 +207,7 @@
const void* buffer;
auto next_result = shared_stream->Next(&buffer);
EXPECT_THAT(next_result.status(), IsOk());
- auto next_size = next_result.ValueOrDie();
+ auto next_size = next_result.value();
EXPECT_EQ(contents.substr(0, next_size),
std::string(static_cast<const char*>(buffer), next_size));
@@ -224,7 +224,7 @@
// Call Next(), it should return exactly the backed up bytes.
next_result = shared_stream->Next(&buffer);
EXPECT_THAT(next_result.status(), IsOk());
- EXPECT_EQ(total_backup_size, next_result.ValueOrDie());
+ EXPECT_EQ(total_backup_size, next_result.value());
EXPECT_EQ(next_size, shared_stream->Position());
EXPECT_EQ(buffered_stream->Position(), shared_stream->Position());
EXPECT_EQ(contents.substr(next_size - total_backup_size, total_backup_size),
diff --git a/cc/streamingaead/shared_random_access_stream_test.cc b/cc/streamingaead/shared_random_access_stream_test.cc
index 9510d8f..f0b3269 100644
--- a/cc/streamingaead/shared_random_access_stream_test.cc
+++ b/cc/streamingaead/shared_random_access_stream_test.cc
@@ -39,7 +39,7 @@
util::Status ReadAll(RandomAccessStream* ra_stream, int chunk_size,
std::string* contents) {
contents->clear();
- auto buffer = std::move(util::Buffer::New(chunk_size).ValueOrDie());
+ auto buffer = std::move(util::Buffer::New(chunk_size).value());
int64_t position = 0;
auto status = ra_stream->PRead(position, chunk_size, buffer.get());
while (status.ok()) {
@@ -69,7 +69,7 @@
EXPECT_EQ(absl::StatusCode::kOutOfRange, status.code());
EXPECT_EQ("EOF", status.message());
EXPECT_EQ(file_contents, stream_contents);
- EXPECT_EQ(stream_size, shared_stream.size().ValueOrDie());
+ EXPECT_EQ(stream_size, shared_stream.size().value());
}
}
diff --git a/cc/streamingaead/streaming_aead_config_test.cc b/cc/streamingaead/streaming_aead_config_test.cc
index eae163a..d50018f 100644
--- a/cc/streamingaead/streaming_aead_config_test.cc
+++ b/cc/streamingaead/streaming_aead_config_test.cc
@@ -92,7 +92,7 @@
primitive_set
->AddPrimitive(absl::make_unique<DummyStreamingAead>("dummy"),
key_info)
- .ValueOrDie()),
+ .value()),
IsOk());
auto primitive_result = Registry::Wrap(std::move(primitive_set));
diff --git a/cc/streamingaead/streaming_aead_wrapper_test.cc b/cc/streamingaead/streaming_aead_wrapper_test.cc
index c7de938..a08e81f 100644
--- a/cc/streamingaead/streaming_aead_wrapper_test.cc
+++ b/cc/streamingaead/streaming_aead_wrapper_test.cc
@@ -71,7 +71,7 @@
util::Status ReadAll(RandomAccessStream* ra_stream, std::string* contents) {
int chunk_size = 42;
contents->clear();
- auto buffer = std::move(util::Buffer::New(chunk_size).ValueOrDie());
+ auto buffer = std::move(util::Buffer::New(chunk_size).value());
int64_t position = 0;
auto status = ra_stream->PRead(position, chunk_size, buffer.get());
while (status.ok()) {
@@ -110,7 +110,7 @@
auto entry_result = saead_set->AddPrimitive(std::move(saead), key_info);
EXPECT_TRUE(entry_result.ok());
if (i + 1 == spec.size()) {
- EXPECT_THAT(saead_set->set_primary(entry_result.ValueOrDie()), IsOk());
+ EXPECT_THAT(saead_set->set_primary(entry_result.value()), IsOk());
}
i++;
}
@@ -152,7 +152,7 @@
StreamingAeadWrapper wrapper;
auto wrap_result = wrapper.Wrap(std::move(saead_set));
EXPECT_TRUE(wrap_result.ok()) << wrap_result.status();
- auto saead = std::move(wrap_result.ValueOrDie());
+ auto saead = std::move(wrap_result.value());
for (int pt_size : {0, 1, 10, 100, 10000}) {
std::string plaintext = subtle::Random::GetRandomBytes(pt_size);
for (std::string aad : {"some_aad", "", "some other aad"}) {
@@ -169,7 +169,7 @@
auto enc_stream_result =
saead->NewEncryptingStream(std::move(ct_destination), aad);
EXPECT_THAT(enc_stream_result.status(), IsOk());
- auto enc_stream = std::move(enc_stream_result.ValueOrDie());
+ auto enc_stream = std::move(enc_stream_result.value());
auto status = WriteToStream(enc_stream.get(), plaintext);
EXPECT_THAT(status, IsOk());
EXPECT_EQ(absl::StrCat(saead_name_2, aad, plaintext), ct_buf->str());
@@ -184,7 +184,7 @@
saead->NewDecryptingStream(std::move(ct_source), aad);
EXPECT_THAT(dec_stream_result.status(), IsOk());
std::string decrypted;
- status = ReadFromStream(dec_stream_result.ValueOrDie().get(), &decrypted);
+ status = ReadFromStream(dec_stream_result.value().get(), &decrypted);
EXPECT_THAT(status, IsOk());
EXPECT_EQ(plaintext, decrypted);
}
@@ -208,7 +208,7 @@
StreamingAeadWrapper wrapper;
auto wrap_result = wrapper.Wrap(std::move(saead_set));
EXPECT_TRUE(wrap_result.ok()) << wrap_result.status();
- auto saead = std::move(wrap_result.ValueOrDie());
+ auto saead = std::move(wrap_result.value());
for (int pt_size : {0, 1, 10, 100, 10000}) {
std::string plaintext = subtle::Random::GetRandomBytes(pt_size);
for (std::string aad : {"some_aad", "", "some other aad"}) {
@@ -226,7 +226,7 @@
auto enc_stream_result =
saead->NewEncryptingStream(std::move(ct_destination), aad);
EXPECT_THAT(enc_stream_result.status(), IsOk());
- auto enc_stream = std::move(enc_stream_result.ValueOrDie());
+ auto enc_stream = std::move(enc_stream_result.value());
auto status = WriteToStream(enc_stream.get(), plaintext);
EXPECT_THAT(status, IsOk());
EXPECT_EQ(absl::StrCat(saead_name_2, aad, plaintext), ct_buf->str());
@@ -237,7 +237,7 @@
saead->NewDecryptingRandomAccessStream(std::move(ct_source), aad);
EXPECT_THAT(dec_stream_result.status(), IsOk());
std::string decrypted;
- status = ReadAll(dec_stream_result.ValueOrDie().get(), &decrypted);
+ status = ReadAll(dec_stream_result.value().get(), &decrypted);
EXPECT_THAT(status, StatusIs(absl::StatusCode::kOutOfRange,
HasSubstr("EOF")));
EXPECT_EQ(plaintext, decrypted);
@@ -267,7 +267,7 @@
StreamingAeadWrapper wrapper;
auto wrap_result = wrapper.Wrap(std::move(saead_set));
EXPECT_TRUE(wrap_result.ok()) << wrap_result.status();
- auto saead = std::move(wrap_result.ValueOrDie());
+ auto saead = std::move(wrap_result.value());
// Prepare ciphertext destination stream.
auto ct_stream = absl::make_unique<std::stringstream>();
@@ -279,7 +279,7 @@
auto enc_stream_result =
saead->NewEncryptingStream(std::move(ct_destination), aad);
EXPECT_THAT(enc_stream_result.status(), IsOk());
- auto enc_stream = std::move(enc_stream_result.ValueOrDie());
+ auto enc_stream = std::move(enc_stream_result.value());
auto status = WriteToStream(enc_stream.get(), plaintext);
EXPECT_THAT(status, IsOk());
EXPECT_EQ(absl::StrCat(saead_name_2, aad, plaintext), ct_buf->str());
@@ -293,7 +293,7 @@
auto dec_stream_result =
saead->NewDecryptingStream(std::move(ct_source), aad);
EXPECT_THAT(dec_stream_result.status(), IsOk());
- dec_stream = std::move(dec_stream_result.ValueOrDie());
+ dec_stream = std::move(dec_stream_result.value());
}
// Now wrapper and saead are out of scope,
// but decrypting stream should still work.
diff --git a/cc/subtle/aead_test_util.cc b/cc/subtle/aead_test_util.cc
index e6c1810..eaaaea2 100644
--- a/cc/subtle/aead_test_util.cc
+++ b/cc/subtle/aead_test_util.cc
@@ -32,9 +32,9 @@
StatusOr<std::string> encryption_or = encrypter.Encrypt(message, aad);
if (!encryption_or.status().ok()) return encryption_or.status();
StatusOr<std::string> decryption_or =
- decrypter.Decrypt(encryption_or.ValueOrDie(), aad);
+ decrypter.Decrypt(encryption_or.value(), aad);
if (!decryption_or.status().ok()) return decryption_or.status();
- if (decryption_or.ValueOrDie() != message) {
+ if (decryption_or.value() != message) {
return crypto::tink::util::Status(absl::StatusCode::kInternal,
"Message/Decryption mismatch");
}
@@ -51,9 +51,9 @@
encrypter.Encrypt(message_cord, aad_cord);
if (!encryption_or.status().ok()) return encryption_or.status();
StatusOr<absl::Cord> decryption_or =
- decrypter.Decrypt(encryption_or.ValueOrDie(), aad_cord);
+ decrypter.Decrypt(encryption_or.value(), aad_cord);
if (!decryption_or.status().ok()) return decryption_or.status();
- if (decryption_or.ValueOrDie() != message) {
+ if (decryption_or.value() != message) {
return crypto::tink::util::Status(absl::StatusCode::kInternal,
"Message/Decryption mismatch");
}
diff --git a/cc/subtle/aes_ctr_boringssl_test.cc b/cc/subtle/aes_ctr_boringssl_test.cc
index f84faef..f9a6233 100644
--- a/cc/subtle/aes_ctr_boringssl_test.cc
+++ b/cc/subtle/aes_ctr_boringssl_test.cc
@@ -49,14 +49,14 @@
int iv_size = 12;
auto res = AesCtrBoringSsl::New(key, iv_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string message = "Some data to encrypt.";
auto ct = cipher->Encrypt(message);
EXPECT_TRUE(ct.ok()) << ct.status();
- EXPECT_EQ(ct.ValueOrDie().size(), message.size() + iv_size);
- auto pt = cipher->Decrypt(ct.ValueOrDie());
+ EXPECT_EQ(ct.value().size(), message.size() + iv_size);
+ auto pt = cipher->Decrypt(ct.value());
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
TEST(AesCtrBoringSslTest, TestEncryptDecrypt_randomMessage) {
@@ -70,15 +70,15 @@
int iv_size = 12;
auto res = AesCtrBoringSsl::New(key, iv_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
for (int i = 0; i < 256; i++) {
std::string message = Random::GetRandomBytes(i);
auto ct = cipher->Encrypt(message);
EXPECT_TRUE(ct.ok()) << ct.status();
- EXPECT_EQ(ct.ValueOrDie().size(), message.size() + iv_size);
- auto pt = cipher->Decrypt(ct.ValueOrDie());
+ EXPECT_EQ(ct.value().size(), message.size() + iv_size);
+ auto pt = cipher->Decrypt(ct.value());
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
}
@@ -93,14 +93,14 @@
int iv_size = 12;
auto res = AesCtrBoringSsl::New(key, iv_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string message = Random::GetRandomBytes(i);
auto ct = cipher->Encrypt(message);
EXPECT_TRUE(ct.ok()) << ct.status();
- EXPECT_EQ(ct.ValueOrDie().size(), message.size() + iv_size);
- auto pt = cipher->Decrypt(ct.ValueOrDie());
+ EXPECT_EQ(ct.value().size(), message.size() + iv_size);
+ auto pt = cipher->Decrypt(ct.value());
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
}
@@ -136,10 +136,10 @@
int iv_size = 16;
auto res = AesCtrBoringSsl::New(key, iv_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
auto pt = cipher->Decrypt(ciphertext);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
TEST(AesCtrBoringSslTest, TestMultipleEncrypt) {
@@ -152,11 +152,11 @@
int iv_size = 12;
auto res = AesCtrBoringSsl::New(key, iv_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string message = "Some data to encrypt.";
auto ct1 = cipher->Encrypt(message);
auto ct2 = cipher->Encrypt(message);
- EXPECT_NE(ct1.ValueOrDie(), ct2.ValueOrDie());
+ EXPECT_NE(ct1.value(), ct2.value());
}
TEST(AesCtrBoringSslTest, TestFipsOnly) {
diff --git a/cc/subtle/aes_ctr_hmac_streaming.cc b/cc/subtle/aes_ctr_hmac_streaming.cc
index 0dcdca8..597efd3 100644
--- a/cc/subtle/aes_ctr_hmac_streaming.cc
+++ b/cc/subtle/aes_ctr_hmac_streaming.cc
@@ -65,7 +65,7 @@
auto hkdf_result = Hkdf::ComputeHkdf(hkdf_algo, ikm, salt, associated_data,
derived_key_material_size);
if (!hkdf_result.ok()) return hkdf_result.status();
- util::SecretData key_material = std::move(hkdf_result.ValueOrDie());
+ util::SecretData key_material = std::move(hkdf_result.value());
*key_value =
util::SecretData(key_material.begin(), key_material.begin() + key_size);
*hmac_key_value =
@@ -177,7 +177,7 @@
auto hmac_result = HmacBoringSsl::New(params.tag_algo, params.tag_size,
std::move(hmac_key_value));
if (!hmac_result.ok()) return hmac_result.status();
- auto mac = std::move(hmac_result.ValueOrDie());
+ auto mac = std::move(hmac_result.value());
return {absl::WrapUnique(new AesCtrHmacStreamSegmentEncrypter(
std::move(key_value), header, nonce_prefix,
@@ -238,7 +238,7 @@
plaintext.size());
auto tag_result = mac_->ComputeMac(absl::StrCat(nonce, ciphertext_string));
if (!tag_result.ok()) return tag_result.status();
- std::string tag = tag_result.ValueOrDie();
+ std::string tag = tag_result.value();
memcpy(ciphertext_buffer->data() + plaintext.size(),
reinterpret_cast<const uint8_t*>(tag.data()), tag_size_);
@@ -297,7 +297,7 @@
auto hmac_result =
HmacBoringSsl::New(tag_algo_, tag_size_, std::move(hmac_key_value));
if (!hmac_result.ok()) return hmac_result.status();
- mac_ = std::move(hmac_result.ValueOrDie());
+ mac_ = std::move(hmac_result.value());
is_initialized_ = true;
return util::OkStatus();
diff --git a/cc/subtle/aes_ctr_hmac_streaming_test.cc b/cc/subtle/aes_ctr_hmac_streaming_test.cc
index 7997c38..2c554bb 100644
--- a/cc/subtle/aes_ctr_hmac_streaming_test.cc
+++ b/cc/subtle/aes_ctr_hmac_streaming_test.cc
@@ -92,7 +92,7 @@
auto enc_result = AesCtrHmacStreamSegmentEncrypter::New(
params, associated_data);
ASSERT_THAT(enc_result.status(), IsOk());
- auto enc = std::move(enc_result.ValueOrDie());
+ auto enc = std::move(enc_result.value());
EXPECT_EQ(0, enc->get_segment_number());
int header_size = 1 + key_size + /* nonce_prefix_size = */ 7;
EXPECT_EQ(header_size, enc->get_header().size());
@@ -138,7 +138,7 @@
auto enc_result =
AesCtrHmacStreamSegmentEncrypter::New(params, associated_data);
ASSERT_THAT(enc_result.status(), IsOk());
- auto enc = std::move(enc_result.ValueOrDie());
+ auto enc = std::move(enc_result.value());
std::vector<uint8_t> pt(enc->get_plaintext_segment_size() + 1, 'p');
std::vector<uint8_t> ct;
@@ -157,7 +157,7 @@
auto enc_result =
AesCtrHmacStreamSegmentEncrypter::New(params, associated_data);
ASSERT_THAT(enc_result.status(), IsOk());
- auto enc = std::move(enc_result.ValueOrDie());
+ auto enc = std::move(enc_result.value());
std::vector<uint8_t> pt(enc->get_plaintext_segment_size(), 'p');
ASSERT_THAT(enc->EncryptSegment(pt, true, nullptr),
@@ -200,13 +200,13 @@
auto enc_result = AesCtrHmacStreamSegmentEncrypter::New(
params, associated_data);
ASSERT_THAT(enc_result.status(), IsOk());
- auto enc = std::move(enc_result.ValueOrDie());
+ auto enc = std::move(enc_result.value());
// Get and initialize a segment decrypter.
auto dec_result = AesCtrHmacStreamSegmentDecrypter::New(
params, associated_data);
ASSERT_THAT(dec_result.status(), IsOk());
- auto dec = std::move(dec_result.ValueOrDie());
+ auto dec = std::move(dec_result.value());
ASSERT_THAT(dec->Init(enc->get_header()), IsOk());
int header_size = 1 + key_size + /* nonce_prefix_size = */ 7;
EXPECT_EQ(header_size, dec->get_header_size());
@@ -258,11 +258,11 @@
auto enc_result =
AesCtrHmacStreamSegmentEncrypter::New(params, associated_data);
ASSERT_THAT(enc_result.status(), IsOk());
- auto enc = std::move(enc_result.ValueOrDie());
+ auto enc = std::move(enc_result.value());
auto dec_result =
AesCtrHmacStreamSegmentDecrypter::New(params, associated_data);
ASSERT_THAT(dec_result.status(), IsOk());
- auto dec = std::move(dec_result.ValueOrDie());
+ auto dec = std::move(dec_result.value());
ASSERT_THAT(dec->Init(enc->get_header()), IsOk());
ASSERT_THAT(dec->Init(enc->get_header()),
StatusIs(absl::StatusCode::kFailedPrecondition,
@@ -279,11 +279,11 @@
auto enc_result =
AesCtrHmacStreamSegmentEncrypter::New(params, associated_data);
ASSERT_THAT(enc_result.status(), IsOk());
- auto enc = std::move(enc_result.ValueOrDie());
+ auto enc = std::move(enc_result.value());
auto dec_result =
AesCtrHmacStreamSegmentDecrypter::New(params, associated_data);
ASSERT_THAT(dec_result.status(), IsOk());
- auto dec = std::move(dec_result.ValueOrDie());
+ auto dec = std::move(dec_result.value());
auto header = enc->get_header();
header.resize(dec->get_header_size() - 1);
ASSERT_THAT(dec->Init(header), StatusIs(absl::StatusCode::kInvalidArgument,
@@ -300,11 +300,11 @@
auto enc_result =
AesCtrHmacStreamSegmentEncrypter::New(params, associated_data);
ASSERT_THAT(enc_result.status(), IsOk());
- auto enc = std::move(enc_result.ValueOrDie());
+ auto enc = std::move(enc_result.value());
auto dec_result =
AesCtrHmacStreamSegmentDecrypter::New(params, associated_data);
ASSERT_THAT(dec_result.status(), IsOk());
- auto dec = std::move(dec_result.ValueOrDie());
+ auto dec = std::move(dec_result.value());
auto header = enc->get_header();
header[0] = 0;
ASSERT_THAT(dec->Init(header), StatusIs(absl::StatusCode::kInvalidArgument,
@@ -321,11 +321,11 @@
auto enc_result =
AesCtrHmacStreamSegmentEncrypter::New(params, associated_data);
ASSERT_THAT(enc_result.status(), IsOk());
- auto enc = std::move(enc_result.ValueOrDie());
+ auto enc = std::move(enc_result.value());
auto dec_result =
AesCtrHmacStreamSegmentDecrypter::New(params, associated_data);
ASSERT_THAT(dec_result.status(), IsOk());
- auto dec = std::move(dec_result.ValueOrDie());
+ auto dec = std::move(dec_result.value());
std::vector<uint8_t> ct(dec->get_ciphertext_segment_size(), 'c');
std::vector<uint8_t> pt;
@@ -344,11 +344,11 @@
auto enc_result =
AesCtrHmacStreamSegmentEncrypter::New(params, associated_data);
ASSERT_THAT(enc_result.status(), IsOk());
- auto enc = std::move(enc_result.ValueOrDie());
+ auto enc = std::move(enc_result.value());
auto dec_result =
AesCtrHmacStreamSegmentDecrypter::New(params, associated_data);
ASSERT_THAT(dec_result.status(), IsOk());
- auto dec = std::move(dec_result.ValueOrDie());
+ auto dec = std::move(dec_result.value());
ASSERT_THAT(dec->Init(enc->get_header()), IsOk());
std::vector<uint8_t> ct(dec->get_ciphertext_segment_size() + 1, 'c');
@@ -368,11 +368,11 @@
auto enc_result =
AesCtrHmacStreamSegmentEncrypter::New(params, associated_data);
ASSERT_THAT(enc_result.status(), IsOk());
- auto enc = std::move(enc_result.ValueOrDie());
+ auto enc = std::move(enc_result.value());
auto dec_result =
AesCtrHmacStreamSegmentDecrypter::New(params, associated_data);
ASSERT_THAT(dec_result.status(), IsOk());
- auto dec = std::move(dec_result.ValueOrDie());
+ auto dec = std::move(dec_result.value());
ASSERT_THAT(dec->Init(enc->get_header()), IsOk());
std::vector<uint8_t> ct(dec->get_ciphertext_segment_size(), 'c');
@@ -413,7 +413,7 @@
params.tag_size = tag_size;
auto result = AesCtrHmacStreaming::New(params);
ASSERT_THAT(result.status(), IsOk());
- auto streaming_aead = std::move(result.ValueOrDie());
+ auto streaming_aead = std::move(result.value());
std::string plaintext(plaintext_size, 'p');
std::string associated_data = "associated data";
diff --git a/cc/subtle/aes_eax_aesni_test.cc b/cc/subtle/aes_eax_aesni_test.cc
index 3f02013..d3f9ff6 100644
--- a/cc/subtle/aes_eax_aesni_test.cc
+++ b/cc/subtle/aes_eax_aesni_test.cc
@@ -41,15 +41,15 @@
size_t nonce_size = 12;
auto res = AesEaxAesni::New(key, nonce_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string message = "Some data to encrypt.";
std::string aad = "Some data to authenticate.";
auto ct = cipher->Encrypt(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- EXPECT_EQ(ct.ValueOrDie().size(), message.size() + nonce_size + 16);
- auto pt = cipher->Decrypt(ct.ValueOrDie(), aad);
+ EXPECT_EQ(ct.value().size(), message.size() + nonce_size + 16);
+ auto pt = cipher->Decrypt(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
TEST(AesEaxAesniTest, testMessageSize) {
@@ -58,16 +58,16 @@
size_t nonce_size = 12;
auto res = AesEaxAesni::New(key, nonce_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
for (size_t size = 0; size < 260; size++) {
std::string message(size, 'x');
std::string aad = "";
auto ct = cipher->Encrypt(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- EXPECT_EQ(ct.ValueOrDie().size(), message.size() + nonce_size + 16);
- auto pt = cipher->Decrypt(ct.ValueOrDie(), aad);
+ EXPECT_EQ(ct.value().size(), message.size() + nonce_size + 16);
+ auto pt = cipher->Decrypt(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
}
@@ -77,16 +77,16 @@
size_t nonce_size = 12;
auto res = AesEaxAesni::New(key, nonce_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
for (size_t size = 0; size < 260; size++) {
std::string message("Some message");
std::string aad(size, 'x');
auto ct = cipher->Encrypt(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- EXPECT_EQ(ct.ValueOrDie().size(), message.size() + nonce_size + 16);
- auto pt = cipher->Decrypt(ct.ValueOrDie(), aad);
+ EXPECT_EQ(ct.value().size(), message.size() + nonce_size + 16);
+ auto pt = cipher->Decrypt(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
}
@@ -96,25 +96,25 @@
size_t nonce_size = 16;
auto res = AesEaxAesni::New(key, nonce_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string message = "Some data to encrypt.";
std::string aad = "Some data to authenticate.";
auto ct = cipher->Encrypt(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- EXPECT_EQ(ct.ValueOrDie().size(), message.size() + nonce_size + 16);
- auto pt = cipher->Decrypt(ct.ValueOrDie(), aad);
+ EXPECT_EQ(ct.value().size(), message.size() + nonce_size + 16);
+ auto pt = cipher->Decrypt(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
TEST(AesEaxAesniTest, testModification) {
size_t nonce_size = 12;
util::SecretData key = util::SecretDataFromStringView(
test::HexDecodeOrDie("000102030405060708090a0b0c0d0e0f"));
- auto cipher = std::move(AesEaxAesni::New(key, nonce_size).ValueOrDie());
+ auto cipher = std::move(AesEaxAesni::New(key, nonce_size).value());
std::string message = "Some data to encrypt.";
std::string aad = "Some data to authenticate.";
- std::string ct = cipher->Encrypt(message, aad).ValueOrDie();
+ std::string ct = cipher->Encrypt(message, aad).value();
EXPECT_TRUE(cipher->Decrypt(ct, aad).ok());
// Modify the ciphertext
for (size_t i = 0; i < ct.size() * 8; i++) {
@@ -127,7 +127,7 @@
std::string modified_aad = aad;
modified_aad[i / 8] ^= 1 << (i % 8);
auto decrypted = cipher->Decrypt(ct, modified_aad);
- EXPECT_FALSE(decrypted.ok()) << i << " pt:" << decrypted.ValueOrDie();
+ EXPECT_FALSE(decrypted.ok()) << i << " pt:" << decrypted.value();
}
// Truncate the ciphertext
for (size_t i = 0; i < ct.size(); i++) {
@@ -159,7 +159,7 @@
std::string ciphertext = nonce + tag;
auto res = AesEaxAesni::New(key, nonce_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
// Test decryption of the arguments above.
std::string empty_string("");
@@ -168,40 +168,40 @@
auto pt = cipher->Decrypt(ciphertext, empty_string);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
pt = cipher->Decrypt(ciphertext, empty_string_view);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
pt = cipher->Decrypt(ciphertext, null_string_view);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
// Test encryption.
auto ct = cipher->Encrypt(empty_string, empty_string);
EXPECT_TRUE(ct.ok());
- pt = cipher->Decrypt(ct.ValueOrDie(), empty_string);
+ pt = cipher->Decrypt(ct.value(), empty_string);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
ct = cipher->Encrypt(empty_string_view, empty_string_view);
EXPECT_TRUE(ct.ok());
- pt = cipher->Decrypt(ct.ValueOrDie(), empty_string);
+ pt = cipher->Decrypt(ct.value(), empty_string);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
ct = cipher->Encrypt(empty_string_view, empty_string_view);
EXPECT_TRUE(ct.ok());
- pt = cipher->Decrypt(ct.ValueOrDie(), empty_string);
+ pt = cipher->Decrypt(ct.value(), empty_string);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
ct = cipher->Encrypt(null_string_view, null_string_view);
EXPECT_TRUE(ct.ok());
- pt = cipher->Decrypt(ct.ValueOrDie(), empty_string);
+ pt = cipher->Decrypt(ct.value(), empty_string);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
}
// Test with test vectors from project Wycheproof.
@@ -239,12 +239,11 @@
std::string tag = WycheproofUtil::GetBytes(test["tag"]);
int id = test["tcId"].GetInt();
std::string expected = test["result"].GetString();
- auto cipher =
- std::move(AesEaxAesni::New(key, iv_size / 8).ValueOrDie());
+ auto cipher = std::move(AesEaxAesni::New(key, iv_size / 8).value());
auto result = cipher->Decrypt(iv + ct + tag, aad);
bool success = result.ok();
if (success) {
- std::string decrypted = result.ValueOrDie();
+ std::string decrypted = result.value();
if (expected == "invalid") {
ADD_FAILURE() << "decrypted invalid ciphertext:" << id;
errors++;
diff --git a/cc/subtle/aes_eax_boringssl.cc b/cc/subtle/aes_eax_boringssl.cc
index 481ab62..da34a38 100644
--- a/cc/subtle/aes_eax_boringssl.cc
+++ b/cc/subtle/aes_eax_boringssl.cc
@@ -91,7 +91,7 @@
return util::Status(absl::StatusCode::kInvalidArgument,
"Invalid key value");
}
- return aeskey;
+ return std::move(aeskey);
}
} // namespace
@@ -160,8 +160,8 @@
if (!aeskey_or.ok()) {
return aeskey_or.status();
}
- return {absl::WrapUnique(new AesEaxBoringSsl(
- std::move(aeskey_or).ValueOrDie(), nonce_size_in_bytes))};
+ return {absl::WrapUnique(
+ new AesEaxBoringSsl(std::move(aeskey_or).value(), nonce_size_in_bytes))};
}
AesEaxBoringSsl::Block AesEaxBoringSsl::Pad(
diff --git a/cc/subtle/aes_eax_boringssl_test.cc b/cc/subtle/aes_eax_boringssl_test.cc
index bc050ab..c4abae5 100644
--- a/cc/subtle/aes_eax_boringssl_test.cc
+++ b/cc/subtle/aes_eax_boringssl_test.cc
@@ -49,15 +49,15 @@
size_t nonce_size = 12;
auto res = AesEaxBoringSsl::New(key, nonce_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string message = "Some data to encrypt.";
std::string aad = "Some data to authenticate.";
auto ct = cipher->Encrypt(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- EXPECT_EQ(ct.ValueOrDie().size(), message.size() + nonce_size + 16);
- auto pt = cipher->Decrypt(ct.ValueOrDie(), aad);
+ EXPECT_EQ(ct.value().size(), message.size() + nonce_size + 16);
+ auto pt = cipher->Decrypt(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
TEST(AesEaxBoringSslTest, TestMessageSize) {
@@ -70,16 +70,16 @@
size_t nonce_size = 12;
auto res = AesEaxBoringSsl::New(key, nonce_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
for (size_t size = 0; size < 260; size++) {
std::string message(size, 'x');
std::string aad = "";
auto ct = cipher->Encrypt(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- EXPECT_EQ(ct.ValueOrDie().size(), message.size() + nonce_size + 16);
- auto pt = cipher->Decrypt(ct.ValueOrDie(), aad);
+ EXPECT_EQ(ct.value().size(), message.size() + nonce_size + 16);
+ auto pt = cipher->Decrypt(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
}
@@ -93,16 +93,16 @@
size_t nonce_size = 12;
auto res = AesEaxBoringSsl::New(key, nonce_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
for (size_t size = 0; size < 260; size++) {
std::string message("Some message");
std::string aad(size, 'x');
auto ct = cipher->Encrypt(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- EXPECT_EQ(ct.ValueOrDie().size(), message.size() + nonce_size + 16);
- auto pt = cipher->Decrypt(ct.ValueOrDie(), aad);
+ EXPECT_EQ(ct.value().size(), message.size() + nonce_size + 16);
+ auto pt = cipher->Decrypt(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
}
@@ -116,15 +116,15 @@
size_t nonce_size = 16;
auto res = AesEaxBoringSsl::New(key, nonce_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string message = "Some data to encrypt.";
std::string aad = "Some data to authenticate.";
auto ct = cipher->Encrypt(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- EXPECT_EQ(ct.ValueOrDie().size(), message.size() + nonce_size + 16);
- auto pt = cipher->Decrypt(ct.ValueOrDie(), aad);
+ EXPECT_EQ(ct.value().size(), message.size() + nonce_size + 16);
+ auto pt = cipher->Decrypt(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
TEST(AesEaxBoringSslTest, TestModification) {
@@ -135,10 +135,10 @@
size_t nonce_size = 12;
util::SecretData key = util::SecretDataFromStringView(
test::HexDecodeOrDie("000102030405060708090a0b0c0d0e0f"));
- auto cipher = std::move(AesEaxBoringSsl::New(key, nonce_size).ValueOrDie());
+ auto cipher = std::move(AesEaxBoringSsl::New(key, nonce_size).value());
std::string message = "Some data to encrypt.";
std::string aad = "Some data to authenticate.";
- std::string ct = cipher->Encrypt(message, aad).ValueOrDie();
+ std::string ct = cipher->Encrypt(message, aad).value();
EXPECT_TRUE(cipher->Decrypt(ct, aad).ok());
// Modify the ciphertext
for (size_t i = 0; i < ct.size() * 8; i++) {
@@ -151,7 +151,7 @@
std::string modified_aad = aad;
modified_aad[i / 8] ^= 1 << (i % 8);
auto decrypted = cipher->Decrypt(ct, modified_aad);
- EXPECT_FALSE(decrypted.ok()) << i << " pt:" << decrypted.ValueOrDie();
+ EXPECT_FALSE(decrypted.ok()) << i << " pt:" << decrypted.value();
}
// Truncate the ciphertext
for (size_t i = 0; i < ct.size(); i++) {
@@ -191,7 +191,7 @@
std::string ciphertext = nonce + tag;
auto res = AesEaxBoringSsl::New(key, nonce_size);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
// Test decryption of the arguments above.
std::string empty_string("");
@@ -200,40 +200,40 @@
auto pt = cipher->Decrypt(ciphertext, empty_string);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
pt = cipher->Decrypt(ciphertext, empty_string_view);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
pt = cipher->Decrypt(ciphertext, null_string_view);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
// Test encryption.
auto ct = cipher->Encrypt(empty_string, empty_string);
EXPECT_TRUE(ct.ok());
- pt = cipher->Decrypt(ct.ValueOrDie(), empty_string);
+ pt = cipher->Decrypt(ct.value(), empty_string);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
ct = cipher->Encrypt(empty_string_view, empty_string_view);
EXPECT_TRUE(ct.ok());
- pt = cipher->Decrypt(ct.ValueOrDie(), empty_string);
+ pt = cipher->Decrypt(ct.value(), empty_string);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
ct = cipher->Encrypt(empty_string_view, empty_string_view);
EXPECT_TRUE(ct.ok());
- pt = cipher->Decrypt(ct.ValueOrDie(), empty_string);
+ pt = cipher->Decrypt(ct.value(), empty_string);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
ct = cipher->Encrypt(null_string_view, null_string_view);
EXPECT_TRUE(ct.ok());
- pt = cipher->Decrypt(ct.ValueOrDie(), empty_string);
+ pt = cipher->Decrypt(ct.value(), empty_string);
EXPECT_TRUE(pt.ok());
- EXPECT_EQ(0, pt.ValueOrDie().size());
+ EXPECT_EQ(0, pt.value().size());
}
static std::string GetError() {
@@ -283,12 +283,11 @@
std::string tag = WycheproofUtil::GetBytes(test["tag"]);
std::string id = absl::StrCat(test["tcId"].GetInt());
std::string expected = test["result"].GetString();
- auto cipher =
- std::move(AesEaxBoringSsl::New(key, iv_size / 8).ValueOrDie());
+ auto cipher = std::move(AesEaxBoringSsl::New(key, iv_size / 8).value());
auto result = cipher->Decrypt(iv + ct + tag, aad);
bool success = result.ok();
if (success) {
- std::string decrypted = result.ValueOrDie();
+ std::string decrypted = result.value();
if (expected == "invalid") {
ADD_FAILURE() << "decrypted invalid ciphertext:" << id;
errors++;
diff --git a/cc/subtle/aes_gcm_hkdf_stream_segment_decrypter_test.cc b/cc/subtle/aes_gcm_hkdf_stream_segment_decrypter_test.cc
index fff27d0..8c3ed14 100644
--- a/cc/subtle/aes_gcm_hkdf_stream_segment_decrypter_test.cc
+++ b/cc/subtle/aes_gcm_hkdf_stream_segment_decrypter_test.cc
@@ -46,7 +46,7 @@
hkdf_hash, ikm, params.salt, associated_data,
derived_key_size);
if (!hkdf_result.ok()) return hkdf_result.status();
- params.key = hkdf_result.ValueOrDie();
+ params.key = hkdf_result.value();
params.ciphertext_offset = ciphertext_offset;
params.ciphertext_segment_size = ciphertext_segment_size;
return AesGcmHkdfStreamSegmentEncrypter::New(params);
@@ -79,7 +79,7 @@
params.associated_data = associated_data;
auto result = AesGcmHkdfStreamSegmentDecrypter::New(params);
EXPECT_TRUE(result.ok()) << result.status();
- auto dec = std::move(result.ValueOrDie());
+ auto dec = std::move(result.value());
// Try to use the decrypter.
std::vector<uint8_t> pt;
@@ -90,10 +90,11 @@
std::string(status.message()));
// Get an encrypter and initialize the decrypter.
- auto enc = std::move(
- GetEncrypter(params.ikm, hkdf_hash, derived_key_size,
- ciphertext_offset, ct_segment_size,
- associated_data).ValueOrDie());
+ auto enc =
+ std::move(GetEncrypter(params.ikm, hkdf_hash,
+ derived_key_size, ciphertext_offset,
+ ct_segment_size, associated_data)
+ .value());
status = dec->Init(enc->get_header());
EXPECT_TRUE(status.ok()) << status;
diff --git a/cc/subtle/aes_gcm_hkdf_stream_segment_encrypter_test.cc b/cc/subtle/aes_gcm_hkdf_stream_segment_encrypter_test.cc
index c41601d..44750f1 100644
--- a/cc/subtle/aes_gcm_hkdf_stream_segment_encrypter_test.cc
+++ b/cc/subtle/aes_gcm_hkdf_stream_segment_encrypter_test.cc
@@ -56,7 +56,7 @@
EXPECT_TRUE(result.ok()) << result.status();
// Use the Constructed encrypter.
- auto enc = std::move(result.ValueOrDie());
+ auto enc = std::move(result.value());
EXPECT_EQ(0, enc->get_segment_number());
int header_size = key_size + /* nonce_prefix_size = */ 7 + 1;
EXPECT_EQ(header_size, enc->get_header().size());
diff --git a/cc/subtle/aes_gcm_hkdf_streaming.cc b/cc/subtle/aes_gcm_hkdf_streaming.cc
index 5897446..cd6fbfd 100644
--- a/cc/subtle/aes_gcm_hkdf_streaming.cc
+++ b/cc/subtle/aes_gcm_hkdf_streaming.cc
@@ -78,7 +78,7 @@
auto hkdf_result = Hkdf::ComputeHkdf(hkdf_hash_, ikm_, params.salt,
associated_data, derived_key_size_);
if (!hkdf_result.ok()) return hkdf_result.status();
- params.key = std::move(hkdf_result).ValueOrDie();
+ params.key = std::move(hkdf_result).value();
params.ciphertext_offset = ciphertext_offset_;
params.ciphertext_segment_size = ciphertext_segment_size_;
return AesGcmHkdfStreamSegmentEncrypter::New(std::move(params));
diff --git a/cc/subtle/aes_gcm_hkdf_streaming_test.cc b/cc/subtle/aes_gcm_hkdf_streaming_test.cc
index 13cb460..d3c79ef 100644
--- a/cc/subtle/aes_gcm_hkdf_streaming_test.cc
+++ b/cc/subtle/aes_gcm_hkdf_streaming_test.cc
@@ -70,7 +70,7 @@
params.ciphertext_offset = ciphertext_offset;
auto result = AesGcmHkdfStreaming::New(std::move(params));
EXPECT_TRUE(result.ok()) << result.status();
- auto streaming_aead = std::move(result.ValueOrDie());
+ auto streaming_aead = std::move(result.value());
// Try to get an encrypting stream to a "null" ct_destination.
std::string associated_data = "some associated data";
diff --git a/cc/subtle/aes_siv_boringssl.cc b/cc/subtle/aes_siv_boringssl.cc
index 4cbba89..4dd8809 100644
--- a/cc/subtle/aes_siv_boringssl.cc
+++ b/cc/subtle/aes_siv_boringssl.cc
@@ -49,7 +49,7 @@
return util::Status(absl::StatusCode::kInternal,
"could not initialize aes key");
}
- return aes_key;
+ return std::move(aes_key);
}
} // namespace
@@ -67,13 +67,13 @@
if (!k1_or.ok()) {
return k1_or.status();
}
- util::SecretUniquePtr<AES_KEY> k1 = std::move(k1_or).ValueOrDie();
+ util::SecretUniquePtr<AES_KEY> k1 = std::move(k1_or).value();
auto k2_or = InitializeAesKey(absl::MakeSpan(key).subspan(key.size() / 2));
if (!k2_or.ok()) {
return k2_or.status();
}
- util::SecretUniquePtr<AES_KEY> k2 = std::move(k2_or).ValueOrDie();
+ util::SecretUniquePtr<AES_KEY> k2 = std::move(k2_or).value();
return {absl::WrapUnique(new AesSivBoringSsl(std::move(k1), std::move(k2)))};
}
diff --git a/cc/subtle/aes_siv_boringssl_test.cc b/cc/subtle/aes_siv_boringssl_test.cc
index 009b767..fe66e39 100644
--- a/cc/subtle/aes_siv_boringssl_test.cc
+++ b/cc/subtle/aes_siv_boringssl_test.cc
@@ -62,14 +62,14 @@
"00112233445566778899aabbccddeefff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"));
auto res = AesSivBoringSsl::New(key);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string aad = "Additional data";
std::string message = "Some data to encrypt.";
auto ct = cipher->EncryptDeterministically(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- auto pt = cipher->DecryptDeterministically(ct.ValueOrDie(), aad);
+ auto pt = cipher->DecryptDeterministically(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
TEST(AesSivBoringSslTest, testNullPtrStringView) {
@@ -82,26 +82,26 @@
auto res = AesSivBoringSsl::New(key);
EXPECT_TRUE(res.ok()) << res.status();
// Checks that a default constructed string_view works.
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
absl::string_view null;
auto ct = cipher->EncryptDeterministically(null, null);
EXPECT_TRUE(ct.ok()) << ct.status();
- auto pt = cipher->DecryptDeterministically(ct.ValueOrDie(), null);
+ auto pt = cipher->DecryptDeterministically(ct.value(), null);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ("", pt.ValueOrDie());
+ EXPECT_EQ("", pt.value());
// Decryption with ct == null should return an appropriate status.
pt = cipher->DecryptDeterministically(null, "");
EXPECT_FALSE(pt.ok());
// Additional data with an empty string view is the same an empty string.
std::string message("123456789abcdefghijklmnop");
ct = cipher->EncryptDeterministically(message, null);
- pt = cipher->DecryptDeterministically(ct.ValueOrDie(), "");
+ pt = cipher->DecryptDeterministically(ct.value(), "");
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(message, pt.ValueOrDie());
+ EXPECT_EQ(message, pt.value());
ct = cipher->EncryptDeterministically(message, "");
- pt = cipher->DecryptDeterministically(ct.ValueOrDie(), null);
+ pt = cipher->DecryptDeterministically(ct.value(), null);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(message, pt.ValueOrDie());
+ EXPECT_EQ(message, pt.value());
}
// Only 64 byte key sizes are supported.
@@ -137,23 +137,23 @@
"00112233445566778899aabbccddeefff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"));
auto res = AesSivBoringSsl::New(key);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string aad = "Additional data";
for (int i = 0; i < 1024; ++i) {
std::string message = std::string(i, 'a');
auto ct = cipher->EncryptDeterministically(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- auto pt = cipher->DecryptDeterministically(ct.ValueOrDie(), aad);
+ auto pt = cipher->DecryptDeterministically(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
for (int i = 1024; i < 100000; i+= 5000) {
std::string message = std::string(i, 'a');
auto ct = cipher->EncryptDeterministically(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- auto pt = cipher->DecryptDeterministically(ct.ValueOrDie(), aad);
+ auto pt = cipher->DecryptDeterministically(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
}
@@ -167,15 +167,15 @@
"00112233445566778899aabbccddeefff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"));
auto res = AesSivBoringSsl::New(key);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string message = "Some plaintext";
for (int i = 0; i < 1028; ++i) {
std::string aad = std::string(i, 'a');
auto ct = cipher->EncryptDeterministically(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- auto pt = cipher->DecryptDeterministically(ct.ValueOrDie(), aad);
+ auto pt = cipher->DecryptDeterministically(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
}
@@ -188,13 +188,13 @@
"00112233445566778899aabbccddeefff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"));
auto res = AesSivBoringSsl::New(key);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string aad = "Additional data";
for (int i = 0; i < 50; ++i) {
std::string message = std::string(i, 'a');
auto ct = cipher->EncryptDeterministically(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- std::string ciphertext = ct.ValueOrDie();
+ std::string ciphertext = ct.value();
for (size_t b = 0; b < ciphertext.size(); ++b) {
for (int bit = 0; bit < 8; ++bit) {
std::string modified = ciphertext;
@@ -226,12 +226,12 @@
std::string aad = WycheproofUtil::GetBytes(test["aad"]);
int id = test["tcId"].GetInt();
std::string result = test["result"].GetString();
- auto cipher = std::move(AesSivBoringSsl::New(key).ValueOrDie());
+ auto cipher = std::move(AesSivBoringSsl::New(key).value());
// Test encryption.
// Encryption should always succeed since msg and aad are valid inputs.
std::string encrypted =
- cipher->EncryptDeterministically(msg, aad).ValueOrDie();
+ cipher->EncryptDeterministically(msg, aad).value();
std::string encrypted_hex = test::HexEncode(encrypted);
std::string ct_hex = test::HexEncode(ct);
if (result == "valid" || result == "acceptable") {
@@ -248,8 +248,7 @@
if (result == "invalid") {
ADD_FAILURE() << "decrypted invalid ciphertext:" << id;
} else {
- EXPECT_EQ(test::HexEncode(msg),
- test::HexEncode(decrypted.ValueOrDie()))
+ EXPECT_EQ(test::HexEncode(msg), test::HexEncode(decrypted.value()))
<< "incorrect decryption: " << id << " " << comment;
}
} else {
diff --git a/cc/subtle/decrypting_random_access_stream.cc b/cc/subtle/decrypting_random_access_stream.cc
index 29599e26..0b6d33e 100644
--- a/cc/subtle/decrypting_random_access_stream.cc
+++ b/cc/subtle/decrypting_random_access_stream.cc
@@ -135,7 +135,7 @@
status_ = buf_result.status();
return;
}
- auto buf = std::move(buf_result.ValueOrDie());
+ auto buf = std::move(buf_result.value());
status_ = ct_source_->PRead(ct_offset_, header_size_, buf.get());
if (!status_.ok()) {
if (status_.code() == absl::StatusCode::kOutOfRange) {
@@ -157,7 +157,7 @@
status_ = ct_size_result.status();
return;
}
- int64_t ct_size = ct_size_result.ValueOrDie();
+ int64_t ct_size = ct_size_result.value();
// ct_segment_size_ is always larger than 1, thus full_segment_count is always
// smaller than std::numeric_limits<int64_t>::max().
int64_t full_segment_count = ct_size / ct_segment_size_;
@@ -256,7 +256,7 @@
auto pt_size_result = size();
if (pt_size_result.ok()) {
- auto pt_size = pt_size_result.ValueOrDie();
+ auto pt_size = pt_size_result.value();
if (position > pt_size) {
return Status(absl::StatusCode::kOutOfRange,
"position is larger than stream size");
@@ -267,7 +267,7 @@
return ToStatusF(absl::StatusCode::kInvalidArgument,
"Invalid ciphertext segment size %d.", ct_segment_size_);
}
- auto ct_buffer = std::move(ct_buffer_result.ValueOrDie());
+ auto ct_buffer = std::move(ct_buffer_result.value());
std::vector<uint8_t> pt_segment;
int remaining = count;
int read_count = 0;
diff --git a/cc/subtle/decrypting_random_access_stream_test.cc b/cc/subtle/decrypting_random_access_stream_test.cc
index 9c395a0..271416f 100644
--- a/cc/subtle/decrypting_random_access_stream_test.cc
+++ b/cc/subtle/decrypting_random_access_stream_test.cc
@@ -104,7 +104,7 @@
auto enc_stream_result =
saead->NewEncryptingStream(std::move(ct_destination), aad);
EXPECT_THAT(enc_stream_result.status(), IsOk());
- EXPECT_THAT(WriteToStream(enc_stream_result.ValueOrDie().get(), pt), IsOk());
+ EXPECT_THAT(WriteToStream(enc_stream_result.value().get(), pt), IsOk());
return ct_buf->str();
}
@@ -124,7 +124,7 @@
util::Status ReadAll(RandomAccessStream* ra_stream, std::string* contents) {
int chunk_size = 42;
contents->clear();
- auto buffer = std::move(util::Buffer::New(chunk_size).ValueOrDie());
+ auto buffer = std::move(util::Buffer::New(chunk_size).value());
int64_t position = 0;
auto status = util::OkStatus();
while (status.ok()) {
@@ -192,7 +192,7 @@
std::move(seg_decrypter),
absl::make_unique<DummyRandomAccessStream>(ciphertext_size, ct_offset));
EXPECT_THAT(dec_stream_result.status(), IsOk());
- auto dec_stream = std::move(dec_stream_result.ValueOrDie());
+ auto dec_stream = std::move(dec_stream_result.value());
auto result = dec_stream->size();
EXPECT_EQ(absl::StatusCode::kInvalidArgument, result.status().code());
@@ -219,8 +219,8 @@
auto dec_stream_result = DecryptingRandomAccessStream::New(
std::move(seg_decrypter), std::move(ciphertext));
EXPECT_THAT(dec_stream_result.status(), IsOk());
- auto dec_stream = std::move(dec_stream_result.ValueOrDie());
- EXPECT_EQ(pt_size, dec_stream->size().ValueOrDie());
+ auto dec_stream = std::move(dec_stream_result.value());
+ EXPECT_EQ(pt_size, dec_stream->size().value());
std::string decrypted;
auto status = ReadAll(dec_stream.get(), &decrypted);
EXPECT_THAT(status, StatusIs(absl::StatusCode::kOutOfRange,
@@ -251,13 +251,13 @@
auto dec_stream_result = DecryptingRandomAccessStream::New(
std::move(seg_decrypter), std::move(ciphertext));
EXPECT_THAT(dec_stream_result.status(), IsOk());
- auto dec_stream = std::move(dec_stream_result.ValueOrDie());
+ auto dec_stream = std::move(dec_stream_result.value());
for (int position : {0, 1, 2, pt_size / 2, pt_size - 1}) {
for (int chunk_size : {1, pt_size / 2, pt_size}) {
SCOPED_TRACE(absl::StrCat("position = ", position,
", chunk_size = ", chunk_size));
- auto buffer = std::move(
- util::Buffer::New(std::max(chunk_size, 1)).ValueOrDie());
+ auto buffer =
+ std::move(util::Buffer::New(std::max(chunk_size, 1)).value());
auto status =
dec_stream->PRead(position, chunk_size, buffer.get());
if (position <= pt_size) {
@@ -313,9 +313,8 @@
auto dec_stream_result = DecryptingRandomAccessStream::New(
std::move(per_stream_seg_decrypter), std::move(trunc_ct));
EXPECT_THAT(dec_stream_result.status(), IsOk());
- auto dec_stream = std::move(dec_stream_result.ValueOrDie());
- auto buffer =
- std::move(util::Buffer::New(chunk_size).ValueOrDie());
+ auto dec_stream = std::move(dec_stream_result.value());
+ auto buffer = std::move(util::Buffer::New(chunk_size).value());
auto status =
dec_stream->PRead(position, chunk_size, buffer.get());
EXPECT_THAT(status, StatusIs(absl::StatusCode::kInvalidArgument));
@@ -346,9 +345,9 @@
auto dec_stream_result = DecryptingRandomAccessStream::New(
std::move(seg_decrypter), std::move(ciphertext));
EXPECT_THAT(dec_stream_result.status(), IsOk());
- auto dec_stream = std::move(dec_stream_result.ValueOrDie());
+ auto dec_stream = std::move(dec_stream_result.value());
int chunk_size = 1;
- auto buffer = std::move(util::Buffer::New(chunk_size).ValueOrDie());
+ auto buffer = std::move(util::Buffer::New(chunk_size).value());
int position = pt_size;
// Negative chunk size.
auto status = dec_stream->PRead(position, -1, buffer.get());
@@ -384,11 +383,11 @@
auto dec_stream_result = DecryptingRandomAccessStream::New(
std::move(seg_decrypter), std::move(wrong_ct));
EXPECT_THAT(dec_stream_result.status(), IsOk());
- auto dec_stream = std::move(dec_stream_result.ValueOrDie());
+ auto dec_stream = std::move(dec_stream_result.value());
std::string decrypted;
int chunk_size = 1;
int position = 0;
- auto buffer = std::move(util::Buffer::New(chunk_size).ValueOrDie());
+ auto buffer = std::move(util::Buffer::New(chunk_size).value());
auto status = dec_stream->PRead(position, chunk_size, buffer.get());
EXPECT_THAT(status, StatusIs(absl::StatusCode::kInvalidArgument));
}
diff --git a/cc/subtle/ecdsa_sign_boringssl.cc b/cc/subtle/ecdsa_sign_boringssl.cc
index 23acdeb..e524033 100644
--- a/cc/subtle/ecdsa_sign_boringssl.cc
+++ b/cc/subtle/ecdsa_sign_boringssl.cc
@@ -173,7 +173,7 @@
if (!status_or_sig.ok()) {
return status_or_sig.status();
}
- return status_or_sig.ValueOrDie();
+ return status_or_sig.value();
}
return std::string(reinterpret_cast<char*>(buffer.data()), sig_length);
diff --git a/cc/subtle/ecdsa_sign_boringssl_test.cc b/cc/subtle/ecdsa_sign_boringssl_test.cc
index d695ea9..01ed3ec 100644
--- a/cc/subtle/ecdsa_sign_boringssl_test.cc
+++ b/cc/subtle/ecdsa_sign_boringssl_test.cc
@@ -50,20 +50,20 @@
subtle::EcdsaSignatureEncoding encodings[2] = {
EcdsaSignatureEncoding::DER, EcdsaSignatureEncoding::IEEE_P1363};
for (EcdsaSignatureEncoding encoding : encodings) {
- auto ec_key = SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256)
- .ValueOrDie();
+ auto ec_key =
+ SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256).value();
auto signer_result =
EcdsaSignBoringSsl::New(ec_key, HashType::SHA256, encoding);
ASSERT_TRUE(signer_result.ok()) << signer_result.status();
- auto signer = std::move(signer_result.ValueOrDie());
+ auto signer = std::move(signer_result.value());
auto verifier_result =
EcdsaVerifyBoringSsl::New(ec_key, HashType::SHA256, encoding);
ASSERT_TRUE(verifier_result.ok()) << verifier_result.status();
- auto verifier = std::move(verifier_result.ValueOrDie());
+ auto verifier = std::move(verifier_result.value());
std::string message = "some data to be signed";
- std::string signature = signer->Sign(message).ValueOrDie();
+ std::string signature = signer->Sign(message).value();
EXPECT_NE(signature, message);
auto status = verifier->Verify(signature, message);
EXPECT_TRUE(status.ok()) << status;
@@ -76,7 +76,7 @@
// Message is a null string_view.
const absl::string_view empty_message;
- signature = signer->Sign(empty_message).ValueOrDie();
+ signature = signer->Sign(empty_message).value();
EXPECT_NE(signature, empty_message);
status = verifier->Verify(signature, empty_message);
EXPECT_TRUE(status.ok()) << status;
@@ -91,12 +91,12 @@
subtle::EcdsaSignatureEncoding encodings[2] = {
EcdsaSignatureEncoding::DER, EcdsaSignatureEncoding::IEEE_P1363};
for (EcdsaSignatureEncoding encoding : encodings) {
- auto ec_key = SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256)
- .ValueOrDie();
+ auto ec_key =
+ SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256).value();
auto signer_result =
EcdsaSignBoringSsl::New(ec_key, HashType::SHA256, encoding);
ASSERT_TRUE(signer_result.ok()) << signer_result.status();
- auto signer = std::move(signer_result.ValueOrDie());
+ auto signer = std::move(signer_result.value());
auto verifier_result =
EcdsaVerifyBoringSsl::New(ec_key, HashType::SHA256,
@@ -104,10 +104,10 @@
? EcdsaSignatureEncoding::IEEE_P1363
: EcdsaSignatureEncoding::DER);
ASSERT_TRUE(verifier_result.ok()) << verifier_result.status();
- auto verifier = std::move(verifier_result.ValueOrDie());
+ auto verifier = std::move(verifier_result.value());
std::string message = "some data to be signed";
- std::string signature = signer->Sign(message).ValueOrDie();
+ std::string signature = signer->Sign(message).value();
EXPECT_NE(signature, message);
auto status = verifier->Verify(signature, message);
EXPECT_FALSE(status.ok()) << status;
@@ -123,19 +123,19 @@
EllipticCurveType::NIST_P384,
EllipticCurveType::NIST_P521};
for (EllipticCurveType curve : curves) {
- auto ec_key = SubtleUtilBoringSSL::GetNewEcKey(curve).ValueOrDie();
+ auto ec_key = SubtleUtilBoringSSL::GetNewEcKey(curve).value();
auto signer_result = EcdsaSignBoringSsl::New(
ec_key, HashType::SHA256, EcdsaSignatureEncoding::IEEE_P1363);
ASSERT_TRUE(signer_result.ok()) << signer_result.status();
- auto signer = std::move(signer_result.ValueOrDie());
+ auto signer = std::move(signer_result.value());
auto verifier_result = EcdsaVerifyBoringSsl::New(
ec_key, HashType::SHA256, EcdsaSignatureEncoding::IEEE_P1363);
ASSERT_TRUE(verifier_result.ok()) << verifier_result.status();
- auto verifier = std::move(verifier_result.ValueOrDie());
+ auto verifier = std::move(verifier_result.value());
std::string message = "some data to be signed";
- std::string signature = signer->Sign(message).ValueOrDie();
+ std::string signature = signer->Sign(message).value();
EXPECT_NE(signature, message);
auto status = verifier->Verify(signature, message);
EXPECT_TRUE(status.ok()) << status;
@@ -153,8 +153,8 @@
GTEST_SKIP()
<< "Test is skipped if kOnlyUseFips but BoringCrypto is unavailable.";
}
- auto ec_key = SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256)
- .ValueOrDie();
+ auto ec_key =
+ SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256).value();
auto signer_result = EcdsaSignBoringSsl::New(ec_key, HashType::SHA1,
EcdsaSignatureEncoding::DER);
EXPECT_FALSE(signer_result.ok()) << signer_result.status();
@@ -169,22 +169,22 @@
<< "Test assumes kOnlyUseFips but BoringCrypto is unavailable.";
}
- auto ec_key = SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256)
- .ValueOrDie();
+ auto ec_key =
+ SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256).value();
EXPECT_THAT(EcdsaSignBoringSsl::New(ec_key, HashType::SHA256,
EcdsaSignatureEncoding::DER)
.status(),
StatusIs(absl::StatusCode::kInternal));
- ec_key = SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P384)
- .ValueOrDie();
+ ec_key =
+ SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P384).value();
EXPECT_THAT(EcdsaSignBoringSsl::New(ec_key, HashType::SHA256,
EcdsaSignatureEncoding::DER)
.status(),
StatusIs(absl::StatusCode::kInternal));
- ec_key = SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P521)
- .ValueOrDie();
+ ec_key =
+ SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P521).value();
EXPECT_THAT(EcdsaSignBoringSsl::New(ec_key, HashType::SHA256,
EcdsaSignatureEncoding::DER)
.status(),
diff --git a/cc/subtle/ecdsa_verify_boringssl.cc b/cc/subtle/ecdsa_verify_boringssl.cc
index 2585de8..962d6d4 100644
--- a/cc/subtle/ecdsa_verify_boringssl.cc
+++ b/cc/subtle/ecdsa_verify_boringssl.cc
@@ -44,7 +44,7 @@
// Check curve.
auto group_result = internal::EcGroupFromCurveType(ec_key.curve);
if (!group_result.ok()) return group_result.status();
- internal::SslUniquePtr<EC_GROUP> group = std::move(group_result.ValueOrDie());
+ internal::SslUniquePtr<EC_GROUP> group = std::move(group_result.value());
internal::SslUniquePtr<EC_KEY> key(EC_KEY_new());
EC_KEY_set_group(key.get(), group.get());
@@ -52,8 +52,7 @@
auto ec_point_result =
internal::GetEcPoint(ec_key.curve, ec_key.pub_x, ec_key.pub_y);
if (!ec_point_result.ok()) return ec_point_result.status();
- internal::SslUniquePtr<EC_POINT> pub_key =
- std::move(ec_point_result.ValueOrDie());
+ internal::SslUniquePtr<EC_POINT> pub_key = std::move(ec_point_result.value());
if (!EC_KEY_set_public_key(key.get(), pub_key.get())) {
return util::Status(
absl::StatusCode::kInvalidArgument,
@@ -108,7 +107,7 @@
if (!status_or_der.ok()) {
return status_or_der.status();
}
- derSig = status_or_der.ValueOrDie();
+ derSig = status_or_der.value();
}
// Verify the signature.
diff --git a/cc/subtle/ecdsa_verify_boringssl_test.cc b/cc/subtle/ecdsa_verify_boringssl_test.cc
index 2afbf6d..b82dadd 100644
--- a/cc/subtle/ecdsa_verify_boringssl_test.cc
+++ b/cc/subtle/ecdsa_verify_boringssl_test.cc
@@ -56,22 +56,22 @@
auto ec_key_result =
SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256);
ASSERT_TRUE(ec_key_result.ok()) << ec_key_result.status();
- auto ec_key = std::move(ec_key_result.ValueOrDie());
+ auto ec_key = std::move(ec_key_result.value());
auto signer_result =
EcdsaSignBoringSsl::New(ec_key, HashType::SHA256, encoding);
ASSERT_TRUE(signer_result.ok()) << signer_result.status();
- auto signer = std::move(signer_result.ValueOrDie());
+ auto signer = std::move(signer_result.value());
auto verifier_result =
EcdsaVerifyBoringSsl::New(ec_key, HashType::SHA256, encoding);
ASSERT_TRUE(verifier_result.ok()) << verifier_result.status();
- auto verifier = std::move(verifier_result.ValueOrDie());
+ auto verifier = std::move(verifier_result.value());
std::string message = "some data to be signed";
auto sign_result = signer->Sign(message);
ASSERT_TRUE(sign_result.ok()) << sign_result.status();
- std::string signature = sign_result.ValueOrDie();
+ std::string signature = sign_result.value();
EXPECT_NE(signature, message);
auto status = verifier->Verify(signature, message);
EXPECT_TRUE(status.ok()) << status;
@@ -98,12 +98,12 @@
auto ec_key_result =
SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256);
ASSERT_TRUE(ec_key_result.ok()) << ec_key_result.status();
- auto ec_key = std::move(ec_key_result.ValueOrDie());
+ auto ec_key = std::move(ec_key_result.value());
auto signer_result =
EcdsaSignBoringSsl::New(ec_key, HashType::SHA256, encoding);
ASSERT_TRUE(signer_result.ok()) << signer_result.status();
- auto signer = std::move(signer_result.ValueOrDie());
+ auto signer = std::move(signer_result.value());
auto verifier_result =
EcdsaVerifyBoringSsl::New(ec_key, HashType::SHA256,
@@ -111,12 +111,12 @@
? EcdsaSignatureEncoding::IEEE_P1363
: EcdsaSignatureEncoding::DER);
ASSERT_TRUE(verifier_result.ok()) << verifier_result.status();
- auto verifier = std::move(verifier_result.ValueOrDie());
+ auto verifier = std::move(verifier_result.value());
std::string message = "some data to be signed";
auto sign_result = signer->Sign(message);
ASSERT_TRUE(sign_result.ok()) << sign_result.status();
- std::string signature = sign_result.ValueOrDie();
+ std::string signature = sign_result.value();
EXPECT_NE(signature, message);
auto status = verifier->Verify(signature, message);
EXPECT_FALSE(status.ok()) << status;
@@ -128,8 +128,8 @@
GTEST_SKIP()
<< "Test is skipped if kOnlyUseFips but BoringCrypto is unavailable.";
}
- auto ec_key = SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256)
- .ValueOrDie();
+ auto ec_key =
+ SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256).value();
auto verifier_result = EcdsaVerifyBoringSsl::New(
ec_key, HashType::SHA1, EcdsaSignatureEncoding::IEEE_P1363);
EXPECT_FALSE(verifier_result.ok()) << verifier_result.status();
@@ -178,7 +178,7 @@
}
continue;
}
- auto verifier = std::move(verifier_result.ValueOrDie());
+ auto verifier = std::move(verifier_result.value());
for (const rapidjson::Value& test : test_group["tests"].GetArray()) {
std::string expected = test["result"].GetString();
std::string msg = WycheproofUtil::GetBytes(test["msg"]);
@@ -263,22 +263,22 @@
<< "Test assumes kOnlyUseFips but BoringCrypto is unavailable.";
}
- auto ec_key = SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256)
- .ValueOrDie();
+ auto ec_key =
+ SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P256).value();
EXPECT_THAT(EcdsaVerifyBoringSsl::New(ec_key, HashType::SHA256,
EcdsaSignatureEncoding::DER)
.status(),
StatusIs(absl::StatusCode::kInternal));
- ec_key = SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P384)
- .ValueOrDie();
+ ec_key =
+ SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P384).value();
EXPECT_THAT(EcdsaVerifyBoringSsl::New(ec_key, HashType::SHA256,
EcdsaSignatureEncoding::DER)
.status(),
StatusIs(absl::StatusCode::kInternal));
- ec_key = SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P521)
- .ValueOrDie();
+ ec_key =
+ SubtleUtilBoringSSL::GetNewEcKey(EllipticCurveType::NIST_P521).value();
EXPECT_THAT(EcdsaVerifyBoringSsl::New(ec_key, HashType::SHA256,
EcdsaSignatureEncoding::DER)
.status(),
diff --git a/cc/subtle/ecies_hkdf_recipient_kem_boringssl.cc b/cc/subtle/ecies_hkdf_recipient_kem_boringssl.cc
index e711fb5..105672f 100644
--- a/cc/subtle/ecies_hkdf_recipient_kem_boringssl.cc
+++ b/cc/subtle/ecies_hkdf_recipient_kem_boringssl.cc
@@ -69,7 +69,7 @@
// TODO(przydatek): consider refactoring internal/ec_util,
// so that the saved group can be used for KEM operations.
return {absl::WrapUnique(new EciesHkdfNistPCurveRecipientKemBoringSsl(
- curve, std::move(priv_key), std::move(status_or_ec_group.ValueOrDie())))};
+ curve, std::move(priv_key), std::move(status_or_ec_group.value())))};
}
EciesHkdfNistPCurveRecipientKemBoringSsl::
@@ -93,7 +93,7 @@
status_or_ec_point.status().message());
}
internal::SslUniquePtr<EC_POINT> pub_key =
- std::move(status_or_ec_point.ValueOrDie());
+ std::move(status_or_ec_point.value());
internal::SslUniquePtr<BIGNUM> priv_key(
BN_bin2bn(priv_key_value_.data(), priv_key_value_.size(), nullptr));
auto shared_secret_or =
@@ -101,7 +101,7 @@
if (!shared_secret_or.ok()) {
return shared_secret_or.status();
}
- util::SecretData shared_secret = shared_secret_or.ValueOrDie();
+ util::SecretData shared_secret = shared_secret_or.value();
return Hkdf::ComputeEciesHkdfSymmetricKey(
hash, kem_bytes, shared_secret, hkdf_salt, hkdf_info, key_size_in_bytes);
}
diff --git a/cc/subtle/ecies_hkdf_recipient_kem_boringssl_test.cc b/cc/subtle/ecies_hkdf_recipient_kem_boringssl_test.cc
index 6cc3148..d957a5f 100644
--- a/cc/subtle/ecies_hkdf_recipient_kem_boringssl_test.cc
+++ b/cc/subtle/ecies_hkdf_recipient_kem_boringssl_test.cc
@@ -85,7 +85,7 @@
test.curve,
util::SecretDataFromStringView(absl::HexStringToBytes(test.priv_hex)));
ASSERT_TRUE(ecies_kem_or.ok());
- auto ecies_kem = std::move(ecies_kem_or).ValueOrDie();
+ auto ecies_kem = std::move(ecies_kem_or).value();
auto kem_key_or = ecies_kem->GenerateKey(
absl::HexStringToBytes(test.pub_encoded_hex), test.hash,
absl::HexStringToBytes(test.salt_hex),
@@ -93,7 +93,7 @@
ASSERT_TRUE(kem_key_or.ok());
EXPECT_EQ(test.out_key_hex,
absl::BytesToHexString(
- util::SecretDataAsStringView(kem_key_or.ValueOrDie())));
+ util::SecretDataAsStringView(kem_key_or.value())));
}
}
@@ -151,7 +151,7 @@
util::SecretDataFromStringView(
absl::HexStringToBytes(kNistP256PrivateKeyHex)));
ASSERT_TRUE(status_or_recipient_kem.ok());
- auto recipient_kem = std::move(status_or_recipient_kem.ValueOrDie());
+ auto recipient_kem = std::move(status_or_recipient_kem.value());
auto status_or_shared_key = recipient_kem->GenerateKey(
absl::HexStringToBytes(kNistP256PublicValueHex), HashType::SHA256,
@@ -159,8 +159,8 @@
EcPointFormat::UNCOMPRESSED);
ASSERT_TRUE(status_or_shared_key.ok());
- EXPECT_EQ(absl::BytesToHexString(util::SecretDataAsStringView(
- status_or_shared_key.ValueOrDie())),
+ EXPECT_EQ(absl::BytesToHexString(
+ util::SecretDataAsStringView(status_or_shared_key.value())),
kNistP256SharedKeyHex);
}
diff --git a/cc/subtle/ecies_hkdf_sender_kem_boringssl.cc b/cc/subtle/ecies_hkdf_sender_kem_boringssl.cc
index ac1f546..86f505c 100644
--- a/cc/subtle/ecies_hkdf_sender_kem_boringssl.cc
+++ b/cc/subtle/ecies_hkdf_sender_kem_boringssl.cc
@@ -73,7 +73,7 @@
if (!status_or_ec_point.ok()) return status_or_ec_point.status();
std::unique_ptr<const EciesHkdfSenderKemBoringSsl> sender_kem(
new EciesHkdfNistPCurveSendKemBoringSsl(
- curve, pubx, puby, std::move(status_or_ec_point.ValueOrDie())));
+ curve, pubx, puby, std::move(status_or_ec_point.value())));
return std::move(sender_kem);
}
@@ -92,7 +92,7 @@
return status_or_ec_group.status();
}
internal::SslUniquePtr<EC_GROUP> group =
- std::move(status_or_ec_group.ValueOrDie());
+ std::move(status_or_ec_group.value());
internal::SslUniquePtr<EC_KEY> ephemeral_key(EC_KEY_new());
if (1 != EC_KEY_set_group(ephemeral_key.get(), group.get())) {
return util::Status(absl::StatusCode::kInternal, "EC_KEY_set_group failed");
@@ -108,19 +108,19 @@
if (!status_or_string_kem.ok()) {
return status_or_string_kem.status();
}
- std::string kem_bytes = status_or_string_kem.ValueOrDie();
+ std::string kem_bytes = status_or_string_kem.value();
auto status_or_string_shared_secret = internal::ComputeEcdhSharedSecret(
curve_, ephemeral_priv, peer_pub_key_.get());
if (!status_or_string_shared_secret.ok()) {
return status_or_string_shared_secret.status();
}
- util::SecretData shared_secret = status_or_string_shared_secret.ValueOrDie();
+ util::SecretData shared_secret = status_or_string_shared_secret.value();
auto symmetric_key_or = Hkdf::ComputeEciesHkdfSymmetricKey(
hash, kem_bytes, shared_secret, hkdf_salt, hkdf_info, key_size_in_bytes);
if (!symmetric_key_or.ok()) {
return symmetric_key_or.status();
}
- util::SecretData symmetric_key = symmetric_key_or.ValueOrDie();
+ util::SecretData symmetric_key = symmetric_key_or.value();
return absl::make_unique<const KemKey>(std::move(kem_bytes),
std::move(symmetric_key));
}
diff --git a/cc/subtle/ecies_hkdf_sender_kem_boringssl_test.cc b/cc/subtle/ecies_hkdf_sender_kem_boringssl_test.cc
index 866e8f7..01df86f 100644
--- a/cc/subtle/ecies_hkdf_sender_kem_boringssl_test.cc
+++ b/cc/subtle/ecies_hkdf_sender_kem_boringssl_test.cc
@@ -85,19 +85,19 @@
for (const TestVector& test : test_vector) {
auto status_or_test_key = internal::NewEcKey(test.curve);
ASSERT_TRUE(status_or_test_key.ok());
- auto test_key = status_or_test_key.ValueOrDie();
+ auto test_key = status_or_test_key.value();
auto status_or_sender_kem = EciesHkdfSenderKemBoringSsl::New(
test.curve, test_key.pub_x, test_key.pub_y);
ASSERT_TRUE(status_or_sender_kem.ok());
- auto sender_kem = std::move(status_or_sender_kem.ValueOrDie());
+ auto sender_kem = std::move(status_or_sender_kem.value());
auto status_or_kem_key = sender_kem->GenerateKey(
test.hash, absl::HexStringToBytes(test.salt_hex),
absl::HexStringToBytes(test.info_hex), test.out_len, test.point_format);
ASSERT_TRUE(status_or_kem_key.ok());
- auto kem_key = std::move(status_or_kem_key.ValueOrDie());
+ auto kem_key = std::move(status_or_kem_key.value());
auto ecies_recipient(
std::move(EciesHkdfRecipientKemBoringSsl::New(test.curve, test_key.priv)
- .ValueOrDie()));
+ .value()));
auto status_or_shared_secret = ecies_recipient->GenerateKey(
kem_key->get_kem_bytes(), test.hash,
absl::HexStringToBytes(test.salt_hex),
@@ -107,7 +107,7 @@
EXPECT_EQ(absl::BytesToHexString(
util::SecretDataAsStringView(kem_key->get_symmetric_key())),
absl::BytesToHexString(util::SecretDataAsStringView(
- status_or_shared_secret.ValueOrDie())));
+ status_or_shared_secret.value())));
}
}
@@ -130,7 +130,7 @@
EllipticCurveType curve = EllipticCurveType::NIST_P256;
auto status_or_test_key = internal::NewEcKey(curve);
ASSERT_TRUE(status_or_test_key.ok());
- auto test_key = status_or_test_key.ValueOrDie();
+ auto test_key = status_or_test_key.value();
auto status_or_sender_kem = EciesHkdfNistPCurveSendKemBoringSsl::New(
curve, test_key.pub_x, test_key.pub_y);
ASSERT_TRUE(status_or_sender_kem.ok());
@@ -143,7 +143,7 @@
EllipticCurveType curve = EllipticCurveType::NIST_P256;
auto status_or_test_key = internal::NewEcKey(curve);
ASSERT_TRUE(status_or_test_key.ok());
- auto test_key = status_or_test_key.ValueOrDie();
+ auto test_key = status_or_test_key.value();
auto status_or_sender_kem = EciesHkdfNistPCurveSendKemBoringSsl::New(
EllipticCurveType::CURVE25519, test_key.pub_x, test_key.pub_y);
EXPECT_EQ(status_or_sender_kem.status().code(),
@@ -157,18 +157,18 @@
EllipticCurveType curve = EllipticCurveType::NIST_P256;
auto status_or_test_key = internal::NewEcKey(curve);
ASSERT_TRUE(status_or_test_key.ok());
- auto test_key = status_or_test_key.ValueOrDie();
+ auto test_key = status_or_test_key.value();
auto status_or_sender_kem = EciesHkdfNistPCurveSendKemBoringSsl::New(
curve, test_key.pub_x, test_key.pub_y);
ASSERT_TRUE(status_or_sender_kem.ok());
- auto sender_kem = std::move(status_or_sender_kem.ValueOrDie());
+ auto sender_kem = std::move(status_or_sender_kem.value());
uint32_t key_size_in_bytes = 128;
auto status_or_kem_key =
sender_kem->GenerateKey(HashType::SHA256, "hkdf_salt", "hkdf_info",
key_size_in_bytes, EcPointFormat::COMPRESSED);
ASSERT_TRUE(status_or_kem_key.ok());
- auto kem_key = std::move(status_or_kem_key.ValueOrDie());
+ auto kem_key = std::move(status_or_kem_key.value());
EXPECT_FALSE(kem_key->get_kem_bytes().empty());
EXPECT_EQ(kem_key->get_symmetric_key().size(), key_size_in_bytes);
}
@@ -182,7 +182,7 @@
EllipticCurveType curve = EllipticCurveType::CURVE25519;
auto status_or_test_key = internal::NewEcKey(curve);
ASSERT_TRUE(status_or_test_key.ok());
- auto test_key = status_or_test_key.ValueOrDie();
+ auto test_key = status_or_test_key.value();
auto status_or_sender_kem = EciesHkdfX25519SendKemBoringSsl::New(
curve, test_key.pub_x, test_key.pub_y);
ASSERT_TRUE(status_or_sender_kem.ok());
@@ -195,7 +195,7 @@
EllipticCurveType curve = EllipticCurveType::CURVE25519;
auto status_or_test_key = internal::NewEcKey(curve);
ASSERT_TRUE(status_or_test_key.ok());
- auto test_key = status_or_test_key.ValueOrDie();
+ auto test_key = status_or_test_key.value();
auto status_or_sender_kem = EciesHkdfX25519SendKemBoringSsl::New(
EllipticCurveType::NIST_P256, test_key.pub_x, test_key.pub_y);
EXPECT_EQ(status_or_sender_kem.status().code(),
@@ -209,7 +209,7 @@
EllipticCurveType curve = EllipticCurveType::CURVE25519;
auto status_or_test_key = internal::NewEcKey(curve);
ASSERT_TRUE(status_or_test_key.ok());
- auto test_key = status_or_test_key.ValueOrDie();
+ auto test_key = status_or_test_key.value();
test_key.pub_x.resize(test_key.pub_x.size() / 2);
auto status_or_sender_kem = EciesHkdfX25519SendKemBoringSsl::New(
curve, test_key.pub_x, test_key.pub_y);
@@ -224,7 +224,7 @@
EllipticCurveType curve = EllipticCurveType::CURVE25519;
auto status_or_test_key = internal::NewEcKey(curve);
ASSERT_TRUE(status_or_test_key.ok());
- auto test_key = status_or_test_key.ValueOrDie();
+ auto test_key = status_or_test_key.value();
test_key.pub_y = test_key.pub_x;
auto status_or_sender_kem = EciesHkdfX25519SendKemBoringSsl::New(
curve, test_key.pub_x, test_key.pub_y);
@@ -239,18 +239,18 @@
EllipticCurveType curve = EllipticCurveType::CURVE25519;
auto status_or_test_key = internal::NewEcKey(curve);
ASSERT_TRUE(status_or_test_key.ok());
- auto test_key = status_or_test_key.ValueOrDie();
+ auto test_key = status_or_test_key.value();
auto status_or_sender_kem = EciesHkdfX25519SendKemBoringSsl::New(
curve, test_key.pub_x, test_key.pub_y);
ASSERT_TRUE(status_or_sender_kem.ok());
- auto sender_kem = std::move(status_or_sender_kem.ValueOrDie());
+ auto sender_kem = std::move(status_or_sender_kem.value());
uint32_t key_size_in_bytes = 128;
auto status_or_kem_key =
sender_kem->GenerateKey(HashType::SHA256, "hkdf_salt", "hkdf_info",
key_size_in_bytes, EcPointFormat::COMPRESSED);
ASSERT_TRUE(status_or_kem_key.ok());
- auto kem_key = std::move(status_or_kem_key.ValueOrDie());
+ auto kem_key = std::move(status_or_kem_key.value());
EXPECT_EQ(kem_key->get_kem_bytes().size(), internal::Ed25519KeyPubKeySize());
EXPECT_EQ(kem_key->get_symmetric_key().size(), key_size_in_bytes);
}
@@ -262,11 +262,11 @@
EllipticCurveType curve = EllipticCurveType::CURVE25519;
auto status_or_test_key = internal::NewEcKey(curve);
ASSERT_TRUE(status_or_test_key.ok());
- auto test_key = status_or_test_key.ValueOrDie();
+ auto test_key = status_or_test_key.value();
auto status_or_sender_kem = EciesHkdfX25519SendKemBoringSsl::New(
curve, test_key.pub_x, test_key.pub_y);
ASSERT_TRUE(status_or_sender_kem.ok());
- auto sender_kem = std::move(status_or_sender_kem.ValueOrDie());
+ auto sender_kem = std::move(status_or_sender_kem.value());
auto status_or_kem_key =
sender_kem->GenerateKey(HashType::SHA256, "hkdf_salt", "hkdf_info", 32,
@@ -282,7 +282,7 @@
}
EllipticCurveType curve = EllipticCurveType::NIST_P256;
auto status_or_test_key = internal::NewEcKey(curve);
- auto test_key = status_or_test_key.ValueOrDie();
+ auto test_key = status_or_test_key.value();
EXPECT_THAT(EciesHkdfNistPCurveSendKemBoringSsl::New(curve, test_key.pub_x,
test_key.pub_y)
@@ -296,7 +296,7 @@
}
EllipticCurveType curve = EllipticCurveType::NIST_P256;
auto status_or_test_key = internal::NewEcKey(curve);
- auto test_key = status_or_test_key.ValueOrDie();
+ auto test_key = status_or_test_key.value();
EXPECT_THAT(EciesHkdfX25519SendKemBoringSsl::New(curve, test_key.pub_x,
test_key.pub_y)
diff --git a/cc/subtle/ed25519_sign_boringssl_test.cc b/cc/subtle/ed25519_sign_boringssl_test.cc
index 91600fb..392a5b3 100644
--- a/cc/subtle/ed25519_sign_boringssl_test.cc
+++ b/cc/subtle/ed25519_sign_boringssl_test.cc
@@ -74,16 +74,16 @@
// Create a new signer.
auto signer_result = Ed25519SignBoringSsl::New(key->private_key);
ASSERT_TRUE(signer_result.ok()) << signer_result.status();
- auto signer = std::move(signer_result.ValueOrDie());
+ auto signer = std::move(signer_result.value());
// Create a new verifier.
auto verifier_result = Ed25519VerifyBoringSsl::New(key->public_key);
ASSERT_TRUE(verifier_result.ok()) << verifier_result.status();
- auto verifier = std::move(verifier_result.ValueOrDie());
+ auto verifier = std::move(verifier_result.value());
// Sign a message.
std::string message = "some data to be signed";
- std::string signature = signer->Sign(message).ValueOrDie();
+ std::string signature = signer->Sign(message).value();
EXPECT_NE(signature, message);
EXPECT_EQ(signature.size(), kEd25519SignatureLenInBytes);
auto status = verifier->Verify(signature, message);
@@ -99,8 +99,8 @@
// that the signatures are the same.
for (size_t i = 0; i < 100; i++) {
message = subtle::Random::GetRandomBytes(i);
- std::string signature1 = signer->Sign(message).ValueOrDie();
- std::string signature2 = signer->Sign(message).ValueOrDie();
+ std::string signature1 = signer->Sign(message).value();
+ std::string signature2 = signer->Sign(message).value();
EXPECT_EQ(signature1, signature2);
// Verify that the signatures are valid.
status = verifier->Verify(signature1, message);
@@ -138,16 +138,16 @@
// Create a new signer.
auto signer_result = Ed25519SignBoringSsl::New(key->private_key);
ASSERT_TRUE(signer_result.ok()) << signer_result.status();
- auto signer = std::move(signer_result.ValueOrDie());
+ auto signer = std::move(signer_result.value());
// Create a new verifier.
auto verifier_result = Ed25519VerifyBoringSsl::New(key->public_key);
ASSERT_TRUE(verifier_result.ok()) << verifier_result.status();
- auto verifier = std::move(verifier_result.ValueOrDie());
+ auto verifier = std::move(verifier_result.value());
// Message is a null string_view.
const absl::string_view empty_message;
- auto signature = signer->Sign(empty_message).ValueOrDie();
+ auto signature = signer->Sign(empty_message).value();
EXPECT_NE(signature, empty_message);
EXPECT_EQ(signature.size(), kEd25519SignatureLenInBytes);
auto status = verifier->Verify(signature, empty_message);
@@ -155,14 +155,14 @@
// Message is an empty string.
const std::string message = "";
- signature = signer->Sign(message).ValueOrDie();
+ signature = signer->Sign(message).value();
EXPECT_EQ(signature.size(), kEd25519SignatureLenInBytes);
EXPECT_NE(signature, message);
status = verifier->Verify(signature, message);
EXPECT_TRUE(status.ok()) << status;
// Message is a default constructed string_view.
- signature = signer->Sign(absl::string_view()).ValueOrDie();
+ signature = signer->Sign(absl::string_view()).value();
EXPECT_EQ(signature.size(), kEd25519SignatureLenInBytes);
status = verifier->Verify(signature, absl::string_view());
EXPECT_TRUE(status.ok()) << status;
@@ -318,14 +318,14 @@
// Create a new signer.
auto signer_result = Ed25519SignBoringSsl::New(private_key);
ASSERT_TRUE(signer_result.ok()) << signer_result.status();
- auto signer = std::move(signer_result.ValueOrDie());
+ auto signer = std::move(signer_result.value());
// Create a new verifier.
auto verifier_result = Ed25519VerifyBoringSsl::New(v.public_key);
ASSERT_TRUE(verifier_result.ok()) << verifier_result.status();
- auto verifier = std::move(verifier_result.ValueOrDie());
+ auto verifier = std::move(verifier_result.value());
- std::string signature = signer->Sign(v.message).ValueOrDie();
+ std::string signature = signer->Sign(v.message).value();
EXPECT_TRUE(signature == v.expected_signature);
auto status = verifier->Verify(signature, v.message);
diff --git a/cc/subtle/ed25519_verify_boringssl_test.cc b/cc/subtle/ed25519_verify_boringssl_test.cc
index 981baa4..1032ac8 100644
--- a/cc/subtle/ed25519_verify_boringssl_test.cc
+++ b/cc/subtle/ed25519_verify_boringssl_test.cc
@@ -262,7 +262,7 @@
continue;
}
- auto verifier = std::move(verifier_result.ValueOrDie());
+ auto verifier = std::move(verifier_result.value());
for (const rapidjson::Value& test : test_group["tests"].GetArray()) {
std::string expected = test["result"].GetString();
std::string msg = WycheproofUtil::GetBytes(test["msg"]);
diff --git a/cc/subtle/encrypt_then_authenticate.cc b/cc/subtle/encrypt_then_authenticate.cc
index 82f916a..eb12da9 100644
--- a/cc/subtle/encrypt_then_authenticate.cc
+++ b/cc/subtle/encrypt_then_authenticate.cc
@@ -75,7 +75,7 @@
if (!ct.ok()) {
return ct.status();
}
- std::string ciphertext(ct.ValueOrDie());
+ std::string ciphertext(ct.value());
std::string toAuthData = absl::StrCat(additional_data, ciphertext,
longToBigEndianStr(aad_size_in_bits));
@@ -83,10 +83,10 @@
if (!tag.ok()) {
return tag.status();
}
- if (tag.ValueOrDie().size() != tag_size_) {
+ if (tag.value().size() != tag_size_) {
return util::Status(absl::StatusCode::kInternal, "invalid tag size");
}
- return ciphertext.append(tag.ValueOrDie());
+ return ciphertext.append(tag.value());
}
util::StatusOr<std::string> EncryptThenAuthenticate::Decrypt(
@@ -122,7 +122,7 @@
return pt.status();
}
- return pt.ValueOrDie();
+ return pt.value();
}
} // namespace subtle
diff --git a/cc/subtle/encrypt_then_authenticate_test.cc b/cc/subtle/encrypt_then_authenticate_test.cc
index fbbe5fe..b51406c 100644
--- a/cc/subtle/encrypt_then_authenticate_test.cc
+++ b/cc/subtle/encrypt_then_authenticate_test.cc
@@ -101,13 +101,12 @@
if (!mac_res.ok()) {
return mac_res.status();
}
- auto cipher_res =
- EncryptThenAuthenticate::New(std::move(ind_cipher_res.ValueOrDie()),
- std::move(mac_res.ValueOrDie()), tag_size);
+ auto cipher_res = EncryptThenAuthenticate::New(
+ std::move(ind_cipher_res.value()), std::move(mac_res.value()), tag_size);
if (!cipher_res.ok()) {
return cipher_res.status();
}
- return std::move(cipher_res.ValueOrDie());
+ return std::move(cipher_res.value());
}
util::StatusOr<std::unique_ptr<Aead>> createAead(int encryption_key_size,
@@ -132,7 +131,7 @@
auto res = createAead2(std::move(enc_key), test.iv_size, std::move(mac_key),
test.tag_size, test.hash_type);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
auto pt = cipher->Decrypt(ct, aad);
EXPECT_TRUE(pt.ok()) << pt.status();
}
@@ -146,16 +145,16 @@
auto res = createAead(encryption_key_size, iv_size, mac_key_size, tag_size,
HashType::SHA1);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string message = "Some data to encrypt.";
std::string aad = "Some data to authenticate.";
auto ct = cipher->Encrypt(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- EXPECT_EQ(ct.ValueOrDie().size(), message.size() + iv_size + tag_size);
- auto pt = cipher->Decrypt(ct.ValueOrDie(), aad);
+ EXPECT_EQ(ct.value().size(), message.size() + iv_size + tag_size);
+ auto pt = cipher->Decrypt(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
TEST(EncryptThenAuthenticateTest, testEncryptDecrypt_randomMessage) {
@@ -166,17 +165,17 @@
auto res = createAead(encryption_key_size, iv_size, mac_key_size, tag_size,
HashType::SHA1);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
for (int i = 0; i < 256; i++) {
std::string message = Random::GetRandomBytes(i);
std::string aad = Random::GetRandomBytes(i);
auto ct = cipher->Encrypt(message, aad);
EXPECT_TRUE(ct.ok()) << ct.status();
- EXPECT_EQ(ct.ValueOrDie().size(), message.size() + iv_size + tag_size);
- auto pt = cipher->Decrypt(ct.ValueOrDie(), aad);
+ EXPECT_EQ(ct.value().size(), message.size() + iv_size + tag_size);
+ auto pt = cipher->Decrypt(ct.value(), aad);
EXPECT_TRUE(pt.ok()) << pt.status();
- EXPECT_EQ(pt.ValueOrDie(), message);
+ EXPECT_EQ(pt.value(), message);
}
}
@@ -188,13 +187,13 @@
auto res = createAead(encryption_key_size, iv_size, mac_key_size, tag_size,
HashType::SHA1);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string message = Random::GetRandomBytes(20);
std::string aad = Random::GetRandomBytes(20);
auto ct1 = cipher->Encrypt(message, aad);
auto ct2 = cipher->Encrypt(message, aad);
- EXPECT_NE(ct1.ValueOrDie(), ct2.ValueOrDie());
+ EXPECT_NE(ct1.value(), ct2.value());
}
TEST(EncryptThenAuthenticateTest, testEncryptDecrypt_invalidTagSize) {
@@ -215,11 +214,11 @@
auto res = createAead(encryption_key_size, iv_size, mac_key_size, tag_size,
HashType::SHA1);
EXPECT_TRUE(res.ok()) << res.status();
- auto cipher = std::move(res.ValueOrDie());
+ auto cipher = std::move(res.value());
std::string message = "Some data to encrypt.";
std::string aad = "Some data to authenticate.";
- std::string ct = cipher->Encrypt(message, aad).ValueOrDie();
+ std::string ct = cipher->Encrypt(message, aad).value();
EXPECT_TRUE(cipher->Decrypt(ct, aad).ok());
// Modify the ciphertext
for (size_t i = 0; i < ct.size() * 8; i++) {
@@ -233,7 +232,7 @@
std::string modified_aad = aad;
modified_aad[i / 8] ^= 1 << (i % 8);
auto decrypted = cipher->Decrypt(ct, modified_aad);
- EXPECT_FALSE(decrypted.ok()) << i << " pt:" << decrypted.ValueOrDie();
+ EXPECT_FALSE(decrypted.ok()) << i << " pt:" << decrypted.value();
}
// Truncate the ciphertext
@@ -248,20 +247,20 @@
int iv_size = 12;
int mac_key_size = 16;
int tag_size = 16;
- auto cipher = std::move(
- createAead(encryption_key_size, iv_size, mac_key_size, tag_size,
- HashType::SHA1).ValueOrDie());
+ auto cipher = std::move(createAead(encryption_key_size, iv_size, mac_key_size,
+ tag_size, HashType::SHA1)
+ .value());
{ // AAD null string_view.
const std::string message = "Some data to encrypt.";
const absl::string_view aad;
- const std::string ct = cipher->Encrypt(message, "").ValueOrDie();
+ const std::string ct = cipher->Encrypt(message, "").value();
EXPECT_TRUE(cipher->Decrypt(ct, aad).ok());
}
{ // Both message and AAD null string_view.
const absl::string_view message;
const absl::string_view aad;
- const std::string ct = cipher->Encrypt(message, "").ValueOrDie();
+ const std::string ct = cipher->Encrypt(message, "").value();
EXPECT_TRUE(cipher->Decrypt(ct, aad).ok());
}
}
@@ -284,7 +283,7 @@
int tag_size = 16;
auto cipher = std::move(createAead(encryption_key_size, iv_size, mac_key_size,
tag_size, HashType::SHA1)
- .ValueOrDie());
+ .value());
// Encrypt a message...
const std::string message = "Some data to encrypt.";
@@ -293,7 +292,7 @@
const std::string aad = std::string(1 << 29, 'a');
auto encrypted = cipher->Encrypt(message, aad);
EXPECT_TRUE(encrypted.ok()) << encrypted.status();
- auto ct = encrypted.ValueOrDie();
+ auto ct = encrypted.value();
auto decrypted = cipher->Decrypt(ct, aad);
EXPECT_TRUE(decrypted.ok()) << decrypted.status();
diff --git a/cc/subtle/hkdf_test.cc b/cc/subtle/hkdf_test.cc
index c76198c..77d272c 100644
--- a/cc/subtle/hkdf_test.cc
+++ b/cc/subtle/hkdf_test.cc
@@ -100,7 +100,7 @@
absl::HexStringToBytes(test.salt_hex),
absl::HexStringToBytes(test.info_hex), test.out_len);
ASSERT_TRUE(hkdf_or.ok());
- EXPECT_EQ(absl::BytesToHexString(hkdf_or.ValueOrDie()), test.out_key_hex);
+ EXPECT_EQ(absl::BytesToHexString(hkdf_or.value()), test.out_key_hex);
}
}
@@ -112,9 +112,9 @@
absl::HexStringToBytes(test.salt_hex),
absl::HexStringToBytes(test.info_hex), test.out_len);
ASSERT_TRUE(hkdf_or.ok());
- EXPECT_EQ(absl::BytesToHexString(
- util::SecretDataAsStringView(hkdf_or.ValueOrDie())),
- test.out_key_hex);
+ EXPECT_EQ(
+ absl::BytesToHexString(util::SecretDataAsStringView(hkdf_or.value())),
+ test.out_key_hex);
}
}
@@ -139,9 +139,9 @@
absl::HexStringToBytes(test.salt_hex),
absl::HexStringToBytes(test.info_hex), test.out_len);
ASSERT_TRUE(hkdf_or.ok());
- EXPECT_EQ(absl::BytesToHexString(
- util::SecretDataAsStringView(hkdf_or.ValueOrDie())),
- test.out_key_hex);
+ EXPECT_EQ(
+ absl::BytesToHexString(util::SecretDataAsStringView(hkdf_or.value())),
+ test.out_key_hex);
}
}
diff --git a/cc/subtle/hmac_boringssl_test.cc b/cc/subtle/hmac_boringssl_test.cc
index 25d67c4..79a45d4 100644
--- a/cc/subtle/hmac_boringssl_test.cc
+++ b/cc/subtle/hmac_boringssl_test.cc
@@ -50,7 +50,7 @@
std::string data = absl::HexStringToBytes(data_hex);
auto hmac_result = HmacBoringSsl::New(hash, tag_size, key);
EXPECT_TRUE(hmac_result.ok()) << hmac_result.status();
- auto hmac = std::move(hmac_result.ValueOrDie());
+ auto hmac = std::move(hmac_result.value());
auto result = hmac->VerifyMac(tag, data);
return result.ok();
}
@@ -67,12 +67,12 @@
size_t tag_size = 16;
auto hmac_result = HmacBoringSsl::New(HashType::SHA1, tag_size, key);
EXPECT_TRUE(hmac_result.ok()) << hmac_result.status();
- auto hmac = std::move(hmac_result.ValueOrDie());
+ auto hmac = std::move(hmac_result.value());
{ // Test with some example data.
std::string data = "Some data to test.";
auto res = hmac->ComputeMac(data);
EXPECT_TRUE(res.ok()) << res.status().ToString();
- std::string tag = res.ValueOrDie();
+ std::string tag = res.value();
EXPECT_EQ(tag_size, tag.size());
EXPECT_EQ(tag, absl::HexStringToBytes("9ccdca5b7fffb690df396e4ac49b9cd4"));
auto status = hmac->VerifyMac(tag, data);
@@ -83,7 +83,7 @@
absl::string_view data;
auto res = hmac->ComputeMac(data);
EXPECT_TRUE(res.ok()) << res.status().ToString();
- std::string tag = res.ValueOrDie();
+ std::string tag = res.value();
EXPECT_EQ(tag_size, tag.size());
EXPECT_EQ(tag, absl::HexStringToBytes("5433122f77bcf8a4d9b874b4149823ef"));
auto status = hmac->VerifyMac(tag, data);
@@ -102,9 +102,9 @@
absl::HexStringToBytes("000102030405060708090a0b0c0d0e0f"));
auto hmac_result = HmacBoringSsl::New(HashType::SHA1, 16, key);
EXPECT_TRUE(hmac_result.ok()) << hmac_result.status();
- auto hmac = std::move(hmac_result.ValueOrDie());
+ auto hmac = std::move(hmac_result.value());
std::string data = "Some data to test";
- std::string tag = hmac->ComputeMac(data).ValueOrDie();
+ std::string tag = hmac->ComputeMac(data).value();
auto status = hmac->VerifyMac(tag, data);
EXPECT_TRUE(status.ok()) << status.ToString();
size_t bits = tag.size() * 8;
@@ -127,9 +127,9 @@
absl::HexStringToBytes("000102030405060708090a0b0c0d0e0f"));
auto hmac_result = HmacBoringSsl::New(HashType::SHA1, 20, key);
EXPECT_TRUE(hmac_result.ok()) << hmac_result.status();
- auto hmac = std::move(hmac_result.ValueOrDie());
+ auto hmac = std::move(hmac_result.value());
std::string data = "Some data to test";
- std::string tag = hmac->ComputeMac(data).ValueOrDie();
+ std::string tag = hmac->ComputeMac(data).value();
auto status = hmac->VerifyMac(tag, data);
EXPECT_TRUE(status.ok()) << status.ToString();
for (size_t i = 0; i < tag.size(); i++) {
diff --git a/cc/subtle/hybrid_test_util.cc b/cc/subtle/hybrid_test_util.cc
index 9140793..6a236b7 100644
--- a/cc/subtle/hybrid_test_util.cc
+++ b/cc/subtle/hybrid_test_util.cc
@@ -27,11 +27,10 @@
auto ciphertext = encrypter->Encrypt(plaintext, context_info);
if (!ciphertext.ok()) return ciphertext.status();
- auto decryption =
- decrypter->Decrypt(ciphertext.ValueOrDie(), context_info);
+ auto decryption = decrypter->Decrypt(ciphertext.value(), context_info);
if (!decryption.ok()) return decryption.status();
- if (decryption.ValueOrDie() != plaintext) {
+ if (decryption.value() != plaintext) {
return crypto::tink::util::Status(absl::StatusCode::kInvalidArgument,
"decryption and encryption differ");
}
diff --git a/cc/subtle/nonce_based_streaming_aead.cc b/cc/subtle/nonce_based_streaming_aead.cc
index 1e72c22..15e9768 100644
--- a/cc/subtle/nonce_based_streaming_aead.cc
+++ b/cc/subtle/nonce_based_streaming_aead.cc
@@ -41,7 +41,7 @@
auto segment_encrypter_result = NewSegmentEncrypter(associated_data);
if (!segment_encrypter_result.ok()) return segment_encrypter_result.status();
return StreamingAeadEncryptingStream::New(
- std::move(segment_encrypter_result.ValueOrDie()),
+ std::move(segment_encrypter_result.value()),
std::move(ciphertext_destination));
}
@@ -52,7 +52,7 @@
auto segment_decrypter_result = NewSegmentDecrypter(associated_data);
if (!segment_decrypter_result.ok()) return segment_decrypter_result.status();
return StreamingAeadDecryptingStream::New(
- std::move(segment_decrypter_result.ValueOrDie()),
+ std::move(segment_decrypter_result.value()),
std::move(ciphertext_source));
}
@@ -63,7 +63,7 @@
auto segment_decrypter_result = NewSegmentDecrypter(associated_data);
if (!segment_decrypter_result.ok()) return segment_decrypter_result.status();
return DecryptingRandomAccessStream::New(
- std::move(segment_decrypter_result.ValueOrDie()),
+ std::move(segment_decrypter_result.value()),
std::move(ciphertext_source));
}
diff --git a/cc/subtle/pem_parser_boringssl.cc b/cc/subtle/pem_parser_boringssl.cc
index fb6ea69..bebc04e 100644
--- a/cc/subtle/pem_parser_boringssl.cc
+++ b/cc/subtle/pem_parser_boringssl.cc
@@ -219,7 +219,7 @@
rsa_public_key->e = *std::move(e_str);
rsa_public_key->n = *std::move(n_str);
- return rsa_public_key;
+ return std::move(rsa_public_key);
}
util::StatusOr<std::unique_ptr<internal::RsaPrivateKey>>
@@ -301,7 +301,7 @@
rsa_private_key->dq = *std::move(dq_str);
rsa_private_key->crt = *std::move(crt_str);
- return rsa_private_key;
+ return std::move(rsa_private_key);
}
util::StatusOr<std::string> PemParser::WriteRsaPublicKey(
@@ -394,7 +394,7 @@
ecdsa_public_key->pub_y = *std::move(y_string);
ecdsa_public_key->curve = *std::move(curve);
- return ecdsa_public_key;
+ return std::move(ecdsa_public_key);
}
util::StatusOr<std::unique_ptr<SubtleUtilBoringSSL::EcKey>>
@@ -454,7 +454,7 @@
ecdsa_private_key->priv = *std::move(priv);
ecdsa_private_key->curve = *std::move(curve);
- return ecdsa_private_key;
+ return std::move(ecdsa_private_key);
}
util::StatusOr<std::string> PemParser::WriteEcPublicKey(
diff --git a/cc/subtle/prf/hkdf_streaming_prf_test.cc b/cc/subtle/prf/hkdf_streaming_prf_test.cc
index f31124d..cb6e0cc 100644
--- a/cc/subtle/prf/hkdf_streaming_prf_test.cc
+++ b/cc/subtle/prf/hkdf_streaming_prf_test.cc
@@ -58,11 +58,11 @@
ASSERT_THAT(streaming_prf_or.status(), IsOk());
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf("input");
+ streaming_prf_or.value()->ComputePrf("input");
auto result_or = ReadBytesFromStream(10, stream.get());
ASSERT_THAT(result_or.status(), IsOk());
- EXPECT_THAT(result_or.ValueOrDie(), SizeIs(10));
+ EXPECT_THAT(result_or.value(), SizeIs(10));
}
TEST(HkdfStreamingPrf, DifferentInputsGiveDifferentvalues) {
@@ -74,16 +74,16 @@
ASSERT_THAT(streaming_prf_or.status(), IsOk());
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf("input");
+ streaming_prf_or.value()->ComputePrf("input");
auto result_or = ReadBytesFromStream(10, stream.get());
ASSERT_THAT(result_or.status(), IsOk());
// Different input.
std::unique_ptr<InputStream> stream2 =
- streaming_prf_or.ValueOrDie()->ComputePrf("input2");
+ streaming_prf_or.value()->ComputePrf("input2");
auto result_or2 = ReadBytesFromStream(10, stream2.get());
ASSERT_THAT(result_or2.status(), IsOk());
- EXPECT_THAT(result_or2.ValueOrDie(), Ne(result_or.ValueOrDie()));
+ EXPECT_THAT(result_or2.value(), Ne(result_or.value()));
}
TEST(HkdfStreamingPrf, SameInputTwice) {
@@ -95,16 +95,16 @@
ASSERT_THAT(streaming_prf_or.status(), IsOk());
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf("input");
+ streaming_prf_or.value()->ComputePrf("input");
auto result_or = ReadBytesFromStream(10, stream.get());
ASSERT_THAT(result_or.status(), IsOk());
// Same input.
std::unique_ptr<InputStream> stream2 =
- streaming_prf_or.ValueOrDie()->ComputePrf("input");
+ streaming_prf_or.value()->ComputePrf("input");
auto result_or2 = ReadBytesFromStream(10, stream2.get());
ASSERT_THAT(result_or2.status(), IsOk());
- EXPECT_THAT(result_or2.ValueOrDie(), Eq(result_or.ValueOrDie()));
+ EXPECT_THAT(result_or2.value(), Eq(result_or.value()));
}
// STREAM HANDLING TESTS =======================================================
@@ -122,12 +122,12 @@
ASSERT_THAT(streaming_prf_or.status(), IsOk());
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf("input");
+ streaming_prf_or.value()->ComputePrf("input");
const void* data;
crypto::tink::util::StatusOr<int> result = stream->Next(&data);
ASSERT_THAT(result.status(), IsOk());
- int bytes_read = result.ValueOrDie();
+ int bytes_read = result.value();
std::string first_read =
std::string(static_cast<const char*>(data), bytes_read);
@@ -138,7 +138,7 @@
// We typically read at least as many bytes the second time -- strictly
// speaking this might not be satisfied by every InputStream, but it usually
// will be.
- ASSERT_THAT(result.ValueOrDie(), Ge(bytes_read));
+ ASSERT_THAT(result.value(), Ge(bytes_read));
std::string second_read =
std::string(static_cast<const char*>(data), bytes_read);
@@ -155,12 +155,12 @@
ASSERT_THAT(streaming_prf_or.status(), IsOk());
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf("input");
+ streaming_prf_or.value()->ComputePrf("input");
const void* data;
crypto::tink::util::StatusOr<int> result = stream->Next(&data);
ASSERT_THAT(result.status(), IsOk());
- int bytes_read = result.ValueOrDie();
+ int bytes_read = result.value();
int backup_amount = bytes_read / 2;
std::string first_read =
std::string(static_cast<const char*>(data) + bytes_read - backup_amount,
@@ -173,7 +173,7 @@
// We typically read at least as many bytes the second time -- strictly
// speaking this might not be satisfied by every InputStream, but it usually
// will be.
- ASSERT_THAT(result.ValueOrDie(), Ge(backup_amount));
+ ASSERT_THAT(result.value(), Ge(backup_amount));
std::string second_read =
std::string(static_cast<const char*>(data), backup_amount);
@@ -190,7 +190,7 @@
ASSERT_THAT(streaming_prf_or.status(), IsOk());
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf("input");
+ streaming_prf_or.value()->ComputePrf("input");
EXPECT_THAT(stream->Position(), Eq(0));
}
@@ -205,12 +205,12 @@
ASSERT_THAT(streaming_prf_or.status(), IsOk());
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf("input");
+ streaming_prf_or.value()->ComputePrf("input");
const void* data;
crypto::tink::util::StatusOr<int> result = stream->Next(&data);
ASSERT_THAT(result.status(), IsOk());
- EXPECT_THAT(stream->Position(), Eq(result.ValueOrDie()));
+ EXPECT_THAT(stream->Position(), Eq(result.value()));
}
// Tests that after Position is correct after a two reads.
@@ -223,7 +223,7 @@
ASSERT_THAT(streaming_prf_or.status(), IsOk());
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf("input");
+ streaming_prf_or.value()->ComputePrf("input");
const void* data;
crypto::tink::util::StatusOr<int> result = stream->Next(&data);
@@ -232,8 +232,7 @@
crypto::tink::util::StatusOr<int> result2 = stream->Next(&data);
ASSERT_THAT(result.status(), IsOk());
- EXPECT_THAT(stream->Position(),
- Eq(result.ValueOrDie() + result2.ValueOrDie()));
+ EXPECT_THAT(stream->Position(), Eq(result.value() + result2.value()));
}
// Tests that we can backup the first read completely.
@@ -246,12 +245,12 @@
ASSERT_THAT(streaming_prf_or.status(), IsOk());
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf("input");
+ streaming_prf_or.value()->ComputePrf("input");
const void* data;
crypto::tink::util::StatusOr<int> result = stream->Next(&data);
ASSERT_THAT(result.status(), IsOk());
- stream->BackUp(result.ValueOrDie());
+ stream->BackUp(result.value());
EXPECT_THAT(stream->Position(), Eq(0));
}
@@ -265,7 +264,7 @@
ASSERT_THAT(streaming_prf_or.status(), IsOk());
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf("input");
+ streaming_prf_or.value()->ComputePrf("input");
const void* data;
crypto::tink::util::StatusOr<int> result = stream->Next(&data);
@@ -274,9 +273,9 @@
crypto::tink::util::StatusOr<int> result2 = stream->Next(&data);
ASSERT_THAT(result.status(), IsOk());
- stream->BackUp(result2.ValueOrDie());
+ stream->BackUp(result2.value());
- EXPECT_THAT(stream->Position(), Eq(result.ValueOrDie()));
+ EXPECT_THAT(stream->Position(), Eq(result.value()));
}
// Tests that we can partially backup and position is correct.
@@ -289,16 +288,15 @@
ASSERT_THAT(streaming_prf_or.status(), IsOk());
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf("input");
+ streaming_prf_or.value()->ComputePrf("input");
const void* data;
crypto::tink::util::StatusOr<int> result = stream->Next(&data);
ASSERT_THAT(result.status(), IsOk());
- stream->BackUp(result.ValueOrDie() / 2);
+ stream->BackUp(result.value() / 2);
- EXPECT_THAT(stream->Position(),
- Eq(result.ValueOrDie() - result.ValueOrDie() / 2));
+ EXPECT_THAT(stream->Position(), Eq(result.value() - result.value() / 2));
}
// HKDF Specific tests =========================================================
@@ -313,10 +311,10 @@
const int max_output_length = 255 * (512 / 8);
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf("input");
+ streaming_prf_or.value()->ComputePrf("input");
auto result_or = ReadBytesFromStream(max_output_length, stream.get());
ASSERT_THAT(result_or.status(), IsOk());
- EXPECT_THAT(result_or.ValueOrDie(), SizeIs(max_output_length));
+ EXPECT_THAT(result_or.value(), SizeIs(max_output_length));
result_or = ReadBytesFromStream(50, stream.get());
ASSERT_THAT(result_or.status(), Not(IsOk()));
}
@@ -342,10 +340,10 @@
auto streaming_prf_or = HkdfStreamingPrf::New(hash, ikm, salt);
ASSERT_THAT(streaming_prf_or.status(), IsOk());
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf(info);
+ streaming_prf_or.value()->ComputePrf(info);
auto result_or = ReadBytesFromStream(expected_result.size(), stream.get());
ASSERT_THAT(result_or.status(), IsOk());
- EXPECT_THAT(result_or.ValueOrDie(), Eq(expected_result));
+ EXPECT_THAT(result_or.value(), Eq(expected_result));
}
crypto::tink::util::StatusOr<std::string> ComputeWithHkdfStreamingPrf(
@@ -356,7 +354,7 @@
return streaming_prf_or.status();
}
std::unique_ptr<InputStream> stream =
- streaming_prf_or.ValueOrDie()->ComputePrf(info);
+ streaming_prf_or.value()->ComputePrf(info);
return ReadBytesFromStream(length, stream.get());
}
@@ -395,7 +393,7 @@
auto result_or = ComputeWithHkdfStreamingPrf(hash, std::move(ikm), salt, info,
expected_result.size());
ASSERT_THAT(result_or.status(), IsOk());
- EXPECT_THAT(result_or.ValueOrDie(), Eq(expected_result));
+ EXPECT_THAT(result_or.value(), Eq(expected_result));
}
TEST(HkdfStreamingPrf, TestVector3) {
@@ -416,7 +414,7 @@
auto result_or = ComputeWithHkdfStreamingPrf(hash, std::move(ikm), salt, info,
expected_result.size());
ASSERT_THAT(result_or.status(), IsOk());
- EXPECT_THAT(result_or.ValueOrDie(), Eq(expected_result));
+ EXPECT_THAT(result_or.value(), Eq(expected_result));
}
TEST(HkdfStreamingPrf, TestVector4) {
@@ -437,7 +435,7 @@
auto result_or = ComputeWithHkdfStreamingPrf(hash, std::move(ikm), salt, info,
expected_result.size());
ASSERT_THAT(result_or.status(), IsOk());
- EXPECT_THAT(result_or.ValueOrDie(), Eq(expected_result));
+ EXPECT_THAT(result_or.value(), Eq(expected_result));
}
TEST(HkdfStreamingPrf, TestVector5) {
@@ -475,7 +473,7 @@
auto result_or = ComputeWithHkdfStreamingPrf(hash, std::move(ikm), salt, info,
expected_result.size());
ASSERT_THAT(result_or.status(), IsOk());
- EXPECT_THAT(result_or.ValueOrDie(), Eq(expected_result));
+ EXPECT_THAT(result_or.value(), Eq(expected_result));
}
TEST(HkdfStreamingPrf, TestVector6) {
@@ -496,7 +494,7 @@
auto result_or = ComputeWithHkdfStreamingPrf(hash, std::move(ikm), salt, info,
expected_result.size());
ASSERT_THAT(result_or.status(), IsOk());
- EXPECT_THAT(result_or.ValueOrDie(), Eq(expected_result));
+ EXPECT_THAT(result_or.value(), Eq(expected_result));
}
TEST(HkdfStreamingPrf, TestVector7) {
@@ -518,7 +516,7 @@
auto result_or = ComputeWithHkdfStreamingPrf(hash, std::move(ikm), salt, info,
expected_result.size());
ASSERT_THAT(result_or.status(), IsOk());
- EXPECT_THAT(result_or.ValueOrDie(), Eq(expected_result));
+ EXPECT_THAT(result_or.value(), Eq(expected_result));
}
TEST(HkdfStreamingPrf, TestAgainstHkdfUtil) {
@@ -537,9 +535,9 @@
auto compute_hkdf_result_or = Hkdf::ComputeHkdf(
hash, ikm, salt, info, 456);
util::SecretData compute_hkdf_result =
- std::move(compute_hkdf_result_or).ValueOrDie();
+ std::move(compute_hkdf_result_or).value();
ASSERT_THAT(compute_hkdf_result_or.status(), IsOk());
- EXPECT_THAT(streaming_result_or.ValueOrDie(),
+ EXPECT_THAT(streaming_result_or.value(),
Eq(util::SecretDataAsStringView(compute_hkdf_result)));
}
diff --git a/cc/subtle/prf/prf_set_util.cc b/cc/subtle/prf/prf_set_util.cc
index aed8447..5dc5f6b 100644
--- a/cc/subtle/prf/prf_set_util.cc
+++ b/cc/subtle/prf/prf_set_util.cc
@@ -43,7 +43,7 @@
if (!output_result.ok()) {
return output_result.status();
}
- std::string output = output_result.ValueOrDie();
+ std::string output = output_result.value();
return output;
}
@@ -62,7 +62,7 @@
if (!stateful_mac_result.ok()) {
return stateful_mac_result.status();
}
- auto stateful_mac = std::move(stateful_mac_result.ValueOrDie());
+ auto stateful_mac = std::move(stateful_mac_result.value());
auto status = stateful_mac->Update(input);
if (!status.ok()) {
return status;
@@ -71,7 +71,7 @@
if (!output_result.ok()) {
return output_result.status();
}
- std::string output = std::move(output_result.ValueOrDie());
+ std::string output = std::move(output_result.value());
if (output.size() < output_length) {
return util::Status(
absl::StatusCode::kInvalidArgument,
diff --git a/cc/subtle/prf/prf_set_util_test.cc b/cc/subtle/prf/prf_set_util_test.cc
index 76871d0..39c1734 100644
--- a/cc/subtle/prf/prf_set_util_test.cc
+++ b/cc/subtle/prf/prf_set_util_test.cc
@@ -106,7 +106,7 @@
SetUpWithResult(util::OkStatus(), std::string("mock_stateful_mac"));
auto output_result = prf()->Compute("test_input", 5);
ASSERT_TRUE(output_result.ok()) << output_result.status();
- EXPECT_THAT(output_result.ValueOrDie(), StrEq("mock_"));
+ EXPECT_THAT(output_result.value(), StrEq("mock_"));
}
TEST_F(PrfFromStatefulMacFactoryTest, ComputePrfUpdateFails) {
@@ -149,34 +149,34 @@
TEST_F(PrfFromStreamingPrfTest, ComputePrfBasic) {
auto output_result = prf()->Compute("input", 5);
ASSERT_THAT(output_result.status(), IsOk());
- EXPECT_THAT(output_result.ValueOrDie(), StrEq("outpu"));
+ EXPECT_THAT(output_result.value(), StrEq("outpu"));
}
TEST_F(PrfFromStreamingPrfTest, ComputeTwice) {
auto output_result = prf()->Compute("input", 5);
ASSERT_THAT(output_result.status(), IsOk());
- EXPECT_THAT(output_result.ValueOrDie(), StrEq("outpu"));
+ EXPECT_THAT(output_result.value(), StrEq("outpu"));
output_result = prf()->Compute("input", 5);
ASSERT_THAT(output_result.status(), IsOk());
- EXPECT_THAT(output_result.ValueOrDie(), StrEq("outpu"));
+ EXPECT_THAT(output_result.value(), StrEq("outpu"));
}
TEST_F(PrfFromStreamingPrfTest, ComputeSubstring) {
auto output_result = prf()->Compute("input", 5);
ASSERT_THAT(output_result.status(), IsOk());
- EXPECT_THAT(output_result.ValueOrDie(), StrEq("outpu"));
+ EXPECT_THAT(output_result.value(), StrEq("outpu"));
output_result = prf()->Compute("input", 6);
ASSERT_THAT(output_result.status(), IsOk());
- EXPECT_THAT(output_result.ValueOrDie(), StrEq("output"));
+ EXPECT_THAT(output_result.value(), StrEq("output"));
output_result = prf()->Compute("input", 2);
ASSERT_THAT(output_result.status(), IsOk());
- EXPECT_THAT(output_result.ValueOrDie(), StrEq("ou"));
+ EXPECT_THAT(output_result.value(), StrEq("ou"));
}
TEST_F(PrfFromStreamingPrfTest, ComputeTooMuch) {
auto output_result = prf()->Compute("input", 5);
ASSERT_THAT(output_result.status(), IsOk());
- EXPECT_THAT(output_result.ValueOrDie(), StrEq("outpu"));
+ EXPECT_THAT(output_result.value(), StrEq("outpu"));
output_result = prf()->Compute("input", 100);
EXPECT_THAT(output_result.status(), Not(IsOk()))
<< "Output should not be okay, too much output requested";
diff --git a/cc/subtle/prf/streaming_prf_wrapper_test.cc b/cc/subtle/prf/streaming_prf_wrapper_test.cc
index 9efc4ac..a443083 100644
--- a/cc/subtle/prf/streaming_prf_wrapper_test.cc
+++ b/cc/subtle/prf/streaming_prf_wrapper_test.cc
@@ -80,16 +80,16 @@
auto entry_or = prf_set->AddPrimitive(
absl::make_unique<DummyStreamingPrf>("single_key"), key_info);
ASSERT_THAT(entry_or.status(), IsOk());
- EXPECT_THAT(prf_set->set_primary(entry_or.ValueOrDie()), IsOk());
+ EXPECT_THAT(prf_set->set_primary(entry_or.value()), IsOk());
auto wrapped_prf = StreamingPrfWrapper().Wrap(std::move(prf_set));
ASSERT_THAT(wrapped_prf.status(), IsOk());
auto prf_output = ReadBytesFromStream(
- 23, wrapped_prf.ValueOrDie()->ComputePrf("input_text").get());
+ 23, wrapped_prf.value()->ComputePrf("input_text").get());
ASSERT_THAT(prf_output.status(), IsOk());
- EXPECT_THAT(prf_output.ValueOrDie(), Eq("10:single_keyinput_text"));
+ EXPECT_THAT(prf_output.value(), Eq("10:single_keyinput_text"));
}
TEST(KeysetDeriverWrapperTest, WrapNonRaw) {
@@ -102,7 +102,7 @@
auto entry_or = prf_set->AddPrimitive(
absl::make_unique<DummyStreamingPrf>("single_key"), key_info);
ASSERT_THAT(entry_or.status(), IsOk());
- EXPECT_THAT(prf_set->set_primary(entry_or.ValueOrDie()), IsOk());
+ EXPECT_THAT(prf_set->set_primary(entry_or.value()), IsOk());
EXPECT_THAT(StreamingPrfWrapper().Wrap(std::move(prf_set)).status(),
StatusIs(absl::StatusCode::kInvalidArgument,
@@ -120,7 +120,7 @@
auto entry_or = prf_set->AddPrimitive(
absl::make_unique<DummyStreamingPrf>("single_key"), key_info);
ASSERT_THAT(entry_or.status(), IsOk());
- EXPECT_THAT(prf_set->set_primary(entry_or.ValueOrDie()), IsOk());
+ EXPECT_THAT(prf_set->set_primary(entry_or.value()), IsOk());
key_info.set_key_id(2345);
EXPECT_THAT(
prf_set
diff --git a/cc/subtle/rsa_ssa_pkcs1_sign_boringssl_test.cc b/cc/subtle/rsa_ssa_pkcs1_sign_boringssl_test.cc
index 80b7a8d..8b0aa29 100644
--- a/cc/subtle/rsa_ssa_pkcs1_sign_boringssl_test.cc
+++ b/cc/subtle/rsa_ssa_pkcs1_sign_boringssl_test.cc
@@ -67,15 +67,14 @@
auto signer_or = RsaSsaPkcs1SignBoringSsl::New(private_key_, params);
ASSERT_THAT(signer_or.status(), IsOk());
- auto signature_or = signer_or.ValueOrDie()->Sign("testdata");
+ auto signature_or = signer_or.value()->Sign("testdata");
ASSERT_THAT(signature_or.status(), IsOk());
- EXPECT_THAT(signature_or.ValueOrDie(), Not(IsEmpty()));
+ EXPECT_THAT(signature_or.value(), Not(IsEmpty()));
auto verifier_or = RsaSsaPkcs1VerifyBoringSsl::New(public_key_, params);
ASSERT_THAT(verifier_or.status(), IsOk());
- EXPECT_THAT(
- verifier_or.ValueOrDie()->Verify(signature_or.ValueOrDie(), "testdata"),
- IsOk());
+ EXPECT_THAT(verifier_or.value()->Verify(signature_or.value(), "testdata"),
+ IsOk());
}
TEST_F(RsaPkcs1SignBoringsslTest, EncodesPkcs1WithSeparateHashes) {
@@ -88,15 +87,14 @@
auto signer_or = RsaSsaPkcs1SignBoringSsl::New(private_key_, params);
ASSERT_THAT(signer_or.status(), IsOk());
- auto signature_or = signer_or.ValueOrDie()->Sign("testdata");
+ auto signature_or = signer_or.value()->Sign("testdata");
ASSERT_THAT(signature_or.status(), IsOk());
- EXPECT_THAT(signature_or.ValueOrDie(), Not(IsEmpty()));
+ EXPECT_THAT(signature_or.value(), Not(IsEmpty()));
auto verifier_or = RsaSsaPkcs1VerifyBoringSsl::New(public_key_, params);
ASSERT_THAT(verifier_or.status(), IsOk());
- EXPECT_THAT(
- verifier_or.ValueOrDie()->Verify(signature_or.ValueOrDie(), "testdata"),
- IsOk());
+ EXPECT_THAT(verifier_or.value()->Verify(signature_or.value(), "testdata"),
+ IsOk());
}
TEST_F(RsaPkcs1SignBoringsslTest, RejectsUnsafeHash) {
diff --git a/cc/subtle/rsa_ssa_pkcs1_verify_boringssl_test.cc b/cc/subtle/rsa_ssa_pkcs1_verify_boringssl_test.cc
index 500f6c0..b4d8d82 100644
--- a/cc/subtle/rsa_ssa_pkcs1_verify_boringssl_test.cc
+++ b/cc/subtle/rsa_ssa_pkcs1_verify_boringssl_test.cc
@@ -95,7 +95,7 @@
auto verifier_result = RsaSsaPkcs1VerifyBoringSsl::New(pub_key, params);
ASSERT_TRUE(verifier_result.ok()) << verifier_result.status();
- auto verifier = std::move(verifier_result.ValueOrDie());
+ auto verifier = std::move(verifier_result.value());
auto status =
verifier->Verify(nist_test_vector.signature, nist_test_vector.message);
EXPECT_TRUE(status.ok()) << status << internal::GetSslErrors();
@@ -141,7 +141,7 @@
auto verifier_result = RsaSsaPkcs1VerifyBoringSsl::New(pub_key, params);
ASSERT_TRUE(verifier_result.ok()) << verifier_result.status();
- auto verifier = std::move(verifier_result.ValueOrDie());
+ auto verifier = std::move(verifier_result.value());
// Modify the message.
for (std::size_t i = 0; i < nist_test_vector.message.length(); i++) {
std::string modified_message = nist_test_vector.message;
@@ -214,7 +214,7 @@
}
continue;
}
- auto verifier = std::move(verifier_result.ValueOrDie());
+ auto verifier = std::move(verifier_result.value());
for (const rapidjson::Value& test : test_group["tests"].GetArray()) {
std::string expected = test["result"].GetString();
std::string msg = WycheproofUtil::GetBytes(test["msg"]);
diff --git a/cc/subtle/rsa_ssa_pss_sign_boringssl_test.cc b/cc/subtle/rsa_ssa_pss_sign_boringssl_test.cc
index 09fe68d..d73eb4d 100644
--- a/cc/subtle/rsa_ssa_pss_sign_boringssl_test.cc
+++ b/cc/subtle/rsa_ssa_pss_sign_boringssl_test.cc
@@ -66,15 +66,14 @@
auto signer_or = RsaSsaPssSignBoringSsl::New(private_key_, params);
ASSERT_THAT(signer_or.status(), IsOk());
- auto signature_or = signer_or.ValueOrDie()->Sign("testdata");
+ auto signature_or = signer_or.value()->Sign("testdata");
ASSERT_THAT(signature_or.status(), IsOk());
- EXPECT_THAT(signature_or.ValueOrDie(), Not(IsEmpty()));
+ EXPECT_THAT(signature_or.value(), Not(IsEmpty()));
auto verifier_or = RsaSsaPssVerifyBoringSsl::New(public_key_, params);
ASSERT_THAT(verifier_or.status(), IsOk());
- EXPECT_THAT(
- verifier_or.ValueOrDie()->Verify(signature_or.ValueOrDie(), "testdata"),
- IsOk());
+ EXPECT_THAT(verifier_or.value()->Verify(signature_or.value(), "testdata"),
+ IsOk());
}
TEST_F(RsaPssSignBoringsslTest, EncodesPssWithSeparateHashes) {
@@ -89,15 +88,14 @@
auto signer_or = RsaSsaPssSignBoringSsl::New(private_key_, params);
ASSERT_THAT(signer_or.status(), IsOk());
- auto signature_or = signer_or.ValueOrDie()->Sign("testdata");
+ auto signature_or = signer_or.value()->Sign("testdata");
ASSERT_THAT(signature_or.status(), IsOk());
- EXPECT_THAT(signature_or.ValueOrDie(), Not(IsEmpty()));
+ EXPECT_THAT(signature_or.value(), Not(IsEmpty()));
auto verifier_or = RsaSsaPssVerifyBoringSsl::New(public_key_, params);
ASSERT_THAT(verifier_or.status(), IsOk());
- EXPECT_THAT(
- verifier_or.ValueOrDie()->Verify(signature_or.ValueOrDie(), "testdata"),
- IsOk());
+ EXPECT_THAT(verifier_or.value()->Verify(signature_or.value(), "testdata"),
+ IsOk());
}
TEST_F(RsaPssSignBoringsslTest, RejectsInvalidPaddingHash) {
diff --git a/cc/subtle/stateful_hmac_boringssl_test.cc b/cc/subtle/stateful_hmac_boringssl_test.cc
index 198a775..8817d25 100644
--- a/cc/subtle/stateful_hmac_boringssl_test.cc
+++ b/cc/subtle/stateful_hmac_boringssl_test.cc
@@ -50,11 +50,11 @@
auto hmac_result = StatefulHmacBoringSsl::New(
hash_type, tag_size, util::SecretDataFromStringView(key));
EXPECT_THAT(hmac_result.status(), IsOk());
- auto hmac = std::move(hmac_result.ValueOrDie());
+ auto hmac = std::move(hmac_result.value());
auto result = hmac->Finalize();
EXPECT_THAT(result.status(), IsOk());
- auto tag = result.ValueOrDie();
+ auto tag = result.value();
EXPECT_EQ(tag.size(), tag_size);
EXPECT_EQ(tag, expected);
}
@@ -82,14 +82,14 @@
auto hmac_result = StatefulHmacBoringSsl::New(
hash_type, tag_size, util::SecretDataFromStringView(key));
EXPECT_THAT(hmac_result.status(), IsOk());
- auto hmac = std::move(hmac_result.ValueOrDie());
+ auto hmac = std::move(hmac_result.value());
auto update_result = hmac->Update(data);
EXPECT_THAT(update_result, IsOk());
auto result = hmac->Finalize();
EXPECT_THAT(result.status(), IsOk());
- auto tag = result.ValueOrDie();
+ auto tag = result.value();
EXPECT_EQ(tag.size(), tag_size);
EXPECT_EQ(tag, expected);
}
@@ -119,7 +119,7 @@
auto hmac_result = StatefulHmacBoringSsl::New(
hash_type, tag_size, util::SecretDataFromStringView(key));
EXPECT_THAT(hmac_result.status(), IsOk());
- auto hmac = std::move(hmac_result.ValueOrDie());
+ auto hmac = std::move(hmac_result.value());
auto update_1 = hmac->Update(data1);
EXPECT_THAT(update_1, IsOk());
@@ -133,7 +133,7 @@
auto result = hmac->Finalize();
EXPECT_THAT(result.status(), IsOk());
- auto tag = result.ValueOrDie();
+ auto tag = result.value();
EXPECT_EQ(tag.size(), tag_size);
EXPECT_EQ(tag, expected);
}
@@ -192,11 +192,11 @@
HashType::SHA256, kTagSize, util::SecretDataFromStringView(key));
auto stateful_hmac_or = factory->Create();
ASSERT_THAT(stateful_hmac_or.status(), IsOk());
- auto stateful_hmac = std::move(stateful_hmac_or.ValueOrDie());
+ auto stateful_hmac = std::move(stateful_hmac_or.value());
EXPECT_THAT(stateful_hmac->Update(data), IsOk());
auto output_or = stateful_hmac->Finalize();
ASSERT_THAT(output_or.status(), IsOk());
- auto output = output_or.ValueOrDie();
+ auto output = output_or.value();
EXPECT_THAT(output, StrEq(expected));
}
@@ -214,14 +214,14 @@
auto create_result = StatefulHmacBoringSsl::New(
HashType::SHA1, tag.size(), util::SecretDataFromStringView(key));
EXPECT_THAT(create_result.status(), IsOk());
- auto hmac = std::move(create_result.ValueOrDie());
+ auto hmac = std::move(create_result.value());
auto update_result = hmac->Update(msg);
EXPECT_THAT(update_result, IsOk());
auto finalize_result = hmac->Finalize();
EXPECT_THAT(finalize_result.status(), IsOk());
- auto result = finalize_result.ValueOrDie();
+ auto result = finalize_result.value();
EXPECT_EQ(result, tag);
}
diff --git a/cc/subtle/streaming_aead_decrypting_stream.cc b/cc/subtle/streaming_aead_decrypting_stream.cc
index 2916042..01c26b8 100644
--- a/cc/subtle/streaming_aead_decrypting_stream.cc
+++ b/cc/subtle/streaming_aead_decrypting_stream.cc
@@ -64,7 +64,7 @@
return next_result.status();
}
if (!next_result.ok()) return next_result.status();
- read_bytes = next_result.ValueOrDie();
+ read_bytes = next_result.value();
needed_bytes = std::min(read_bytes, bytes_to_be_read);
memcpy(output->data() + (count - bytes_to_be_read), buffer, needed_bytes);
bytes_to_be_read -= needed_bytes;
diff --git a/cc/subtle/streaming_aead_decrypting_stream_test.cc b/cc/subtle/streaming_aead_decrypting_stream_test.cc
index 0503330..f8579f7 100644
--- a/cc/subtle/streaming_aead_decrypting_stream_test.cc
+++ b/cc/subtle/streaming_aead_decrypting_stream_test.cc
@@ -65,7 +65,8 @@
// A reference to the segment decrypter, for later validation.
refs->seg_dec = seg_dec.get();
auto dec_stream = std::move(StreamingAeadDecryptingStream::New(
- std::move(seg_dec), std::move(ct_source)).ValueOrDie());
+ std::move(seg_dec), std::move(ct_source))
+ .value());
EXPECT_EQ(0, dec_stream->Position());
return dec_stream;
}
@@ -101,7 +102,7 @@
const void* buffer;
auto next_result = dec_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- int buffer_size = next_result.ValueOrDie();
+ int buffer_size = next_result.value();
int exp_buffer_size = pt_segment_size - (header_size + ct_offset);
if (exp_buffer_size > pt_size) exp_buffer_size = pt_size;
EXPECT_EQ(exp_buffer_size, buffer_size);
@@ -205,7 +206,7 @@
auto next_result = dec_stream->Next(&buffer);
int buffer_size = pt_segment_size - header_size;
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(buffer_size, dec_stream->Position());
EXPECT_EQ(pt,
std::string(reinterpret_cast<const char*>(buffer), buffer_size));
@@ -239,7 +240,7 @@
auto next_result = dec_stream->Next(&buffer);
int buffer_size = pt_segment_size - header_size;
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(buffer_size, dec_stream->Position());
EXPECT_EQ(pt.substr(0, buffer_size),
std::string(reinterpret_cast<const char*>(buffer), buffer_size));
@@ -247,7 +248,7 @@
// Get the second segment.
next_result = dec_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(1, next_result.ValueOrDie());
+ EXPECT_EQ(1, next_result.value());
EXPECT_EQ(pt.size(), dec_stream->Position());
EXPECT_EQ(pt.at(pt.size()-1), *(reinterpret_cast<const char*>(buffer)));
@@ -276,7 +277,7 @@
auto next_result = dec_stream->Next(&buffer);
int buffer_size = pt_segment_size - header_size;
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(buffer_size, dec_stream->Position());
EXPECT_EQ(pt.substr(0, buffer_size),
std::string(reinterpret_cast<const char*>(buffer), buffer_size));
@@ -289,7 +290,7 @@
EXPECT_EQ(buffer_size - backup_size, dec_stream->Position());
next_result = dec_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(backup_size, next_result.ValueOrDie());
+ EXPECT_EQ(backup_size, next_result.value());
EXPECT_EQ(buffer_size, dec_stream->Position());
EXPECT_EQ(pt.substr(buffer_size - backup_size, backup_size),
std::string(reinterpret_cast<const char*>(buffer), backup_size));
@@ -300,7 +301,7 @@
EXPECT_EQ(buffer_size - backup2_size, dec_stream->Position());
next_result = dec_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(backup2_size, next_result.ValueOrDie());
+ EXPECT_EQ(backup2_size, next_result.value());
EXPECT_EQ(buffer_size, dec_stream->Position());
EXPECT_EQ(pt.substr(buffer_size - backup2_size, backup2_size),
std::string(reinterpret_cast<const char*>(buffer), backup2_size));
@@ -332,7 +333,7 @@
auto next_result = dec_stream->Next(&buffer);
int buffer_size = pt_segment_size - header_size;
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(buffer_size, dec_stream->Position());
std::string decrypted_first_segment(reinterpret_cast<const char*>(buffer),
buffer_size);
@@ -345,12 +346,12 @@
total_backup_size += std::max(0, backup_size);
EXPECT_EQ(buffer_size - total_backup_size, dec_stream->Position());
}
- EXPECT_LT(total_backup_size, next_result.ValueOrDie());
+ EXPECT_LT(total_backup_size, next_result.value());
// Call Next(), it should succeed (backuped bytes of 1st segment).
next_result = dec_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(total_backup_size, next_result.ValueOrDie());
+ EXPECT_EQ(total_backup_size, next_result.value());
EXPECT_EQ(buffer_size, dec_stream->Position());
// BackUp() some bytes, again fewer than returned by Next().
@@ -361,12 +362,12 @@
total_backup_size += std::max(0, backup_size);
EXPECT_EQ(buffer_size - total_backup_size, dec_stream->Position());
}
- EXPECT_LT(total_backup_size, next_result.ValueOrDie());
+ EXPECT_LT(total_backup_size, next_result.value());
// Call Next(), it should succeed (backuped bytes of 1st segment).
next_result = dec_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(total_backup_size, next_result.ValueOrDie());
+ EXPECT_EQ(total_backup_size, next_result.value());
EXPECT_EQ(buffer_size, dec_stream->Position());
// Call Next() again, it should return a full block (2nd segment).
@@ -374,7 +375,7 @@
buffer_size = pt_segment_size;
next_result = dec_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(prev_position + buffer_size, dec_stream->Position());
// BackUp a few times, with total over the returned buffer_size.
@@ -395,7 +396,7 @@
// Call Next() again, it should return a full segment (2nd segment);
next_result = dec_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(prev_position + buffer_size, dec_stream->Position());
EXPECT_EQ(2 * pt_segment_size - header_size, dec_stream->Position());
diff --git a/cc/subtle/streaming_aead_encrypting_stream.cc b/cc/subtle/streaming_aead_encrypting_stream.cc
index d9eef1a..5fb4741 100644
--- a/cc/subtle/streaming_aead_encrypting_stream.cc
+++ b/cc/subtle/streaming_aead_encrypting_stream.cc
@@ -50,7 +50,7 @@
while (remaining > 0) {
auto next_result = output_stream->Next(&buffer);
if (!next_result.ok()) return next_result.status();
- available_space = next_result.ValueOrDie();
+ available_space = next_result.value();
available_bytes = std::min(available_space, remaining);
memcpy(buffer, contents.data() + pos, available_bytes);
remaining -= available_bytes;
diff --git a/cc/subtle/streaming_aead_encrypting_stream_test.cc b/cc/subtle/streaming_aead_encrypting_stream_test.cc
index 977b261..aa2a5e8 100644
--- a/cc/subtle/streaming_aead_encrypting_stream_test.cc
+++ b/cc/subtle/streaming_aead_encrypting_stream_test.cc
@@ -66,7 +66,8 @@
// A reference to the segment encrypter, for later validation.
refs->seg_enc = seg_enc.get();
auto enc_stream = std::move(StreamingAeadEncryptingStream::New(
- std::move(seg_enc), std::move(ct_destination)).ValueOrDie());
+ std::move(seg_enc), std::move(ct_destination))
+ .value());
EXPECT_EQ(0, enc_stream->Position());
return enc_stream;
}
@@ -97,7 +98,7 @@
void* buffer;
auto next_result = enc_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- int buffer_size = next_result.ValueOrDie();
+ int buffer_size = next_result.value();
EXPECT_EQ(pt_segment_size - (header_size + ct_offset), buffer_size);
EXPECT_EQ(buffer_size, enc_stream->Position());
@@ -167,7 +168,7 @@
auto next_result = enc_stream->Next(&buffer);
int buffer_size = pt_segment_size - header_size;
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(buffer_size, enc_stream->Position());
// Backup the entire segment, and close the stream.
@@ -204,7 +205,7 @@
auto next_result = enc_stream->Next(&buffer);
int buffer_size = pt_segment_size - header_size;
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(buffer_size, enc_stream->Position());
auto close_status = enc_stream->Close();
EXPECT_TRUE(close_status.ok()) << close_status;
@@ -239,7 +240,7 @@
auto next_result = enc_stream->Next(&buffer);
int buffer_size = pt_segment_size - header_size;
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(buffer_size, enc_stream->Position());
// Backup so that only part1_size bytes are written.
@@ -250,7 +251,7 @@
void* backedup_buffer;
next_result = enc_stream->Next(&backedup_buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size - part1_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size - part1_size, next_result.value());
EXPECT_EQ(reinterpret_cast<uint8_t*>(buffer) + part1_size,
reinterpret_cast<uint8_t*>(backedup_buffer));
@@ -261,7 +262,7 @@
// Get backed up space again.
next_result = enc_stream->Next(&backedup_buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size - (part1_size + part2_size), next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size - (part1_size + part2_size), next_result.value());
EXPECT_EQ(reinterpret_cast<uint8_t*>(buffer) + part1_size + part2_size,
reinterpret_cast<uint8_t*>(backedup_buffer));
@@ -285,7 +286,7 @@
auto next_result = enc_stream->Next(&buffer);
int buffer_size = pt_segment_size - header_size;
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(buffer_size, enc_stream->Position());
// Backup so that only pt_size bytes are written, and close the stream.
@@ -324,14 +325,14 @@
auto next_result = enc_stream->Next(&buffer);
int first_buffer_size = pt_segment_size - header_size;
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(first_buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(first_buffer_size, next_result.value());
EXPECT_EQ(first_buffer_size, enc_stream->Position());
// Get remaining segments.
for (int i = 1; i < seg_count; i++) {
next_result = enc_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(pt_segment_size, next_result.ValueOrDie());
+ EXPECT_EQ(pt_segment_size, next_result.value());
EXPECT_EQ(first_buffer_size + i * pt_segment_size, enc_stream->Position());
}
@@ -376,14 +377,14 @@
auto next_result = enc_stream->Next(&buffer);
int first_buffer_size = pt_segment_size - header_size;
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(first_buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(first_buffer_size, next_result.value());
EXPECT_EQ(first_buffer_size, enc_stream->Position());
// Get remaining segments.
for (int i = 1; i < seg_count; i++) {
next_result = enc_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(pt_segment_size, next_result.ValueOrDie());
+ EXPECT_EQ(pt_segment_size, next_result.value());
EXPECT_EQ(first_buffer_size + i * pt_segment_size, enc_stream->Position());
}
// Backup part of the last segment, and close the stream.
@@ -430,14 +431,14 @@
auto next_result = enc_stream->Next(&buffer);
int first_buffer_size = pt_segment_size - header_size;
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(first_buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(first_buffer_size, next_result.value());
EXPECT_EQ(first_buffer_size, enc_stream->Position());
// Get remaining segments.
for (int i = 1; i < seg_count; i++) {
next_result = enc_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(pt_segment_size, next_result.ValueOrDie());
+ EXPECT_EQ(pt_segment_size, next_result.value());
EXPECT_EQ(first_buffer_size + i * pt_segment_size, enc_stream->Position());
}
// Backup the entire last segment, and close the stream.
@@ -482,7 +483,7 @@
auto next_result = enc_stream->Next(&buffer);
int buffer_size = pt_segment_size - header_size;
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(buffer_size, enc_stream->Position());
// BackUp several times, but in total fewer bytes than returned by Next().
@@ -493,12 +494,12 @@
total_backup_size += std::max(0, backup_size);
EXPECT_EQ(buffer_size - total_backup_size, enc_stream->Position());
}
- EXPECT_LT(total_backup_size, next_result.ValueOrDie());
+ EXPECT_LT(total_backup_size, next_result.value());
// Call Next(), it should succeed (backuped bytes of 1st segment).
next_result = enc_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(total_backup_size, next_result.ValueOrDie());
+ EXPECT_EQ(total_backup_size, next_result.value());
EXPECT_EQ(buffer_size, enc_stream->Position());
// BackUp() some bytes, again fewer than returned by Next().
@@ -509,12 +510,12 @@
total_backup_size += std::max(0, backup_size);
EXPECT_EQ(buffer_size - total_backup_size, enc_stream->Position());
}
- EXPECT_LT(total_backup_size, next_result.ValueOrDie());
+ EXPECT_LT(total_backup_size, next_result.value());
// Call Next(), it should succeed (backuped bytes of 1st segment).
next_result = enc_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(total_backup_size, next_result.ValueOrDie());
+ EXPECT_EQ(total_backup_size, next_result.value());
EXPECT_EQ(buffer_size, enc_stream->Position());
// Call Next() again, it should return a full segment (2nd segment).
@@ -522,7 +523,7 @@
buffer_size = pt_segment_size;
next_result = enc_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(prev_position + buffer_size, enc_stream->Position());
// BackUp a few times, with total over the returned buffer_size.
@@ -543,7 +544,7 @@
// Call Next() again, it should return a full segment (2nd segment);
next_result = enc_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(prev_position + buffer_size, enc_stream->Position());
EXPECT_EQ(2 * pt_segment_size - header_size, enc_stream->Position());
diff --git a/cc/subtle/streaming_aead_test_util.cc b/cc/subtle/streaming_aead_test_util.cc
index cce01af..9c21c00 100644
--- a/cc/subtle/streaming_aead_test_util.cc
+++ b/cc/subtle/streaming_aead_test_util.cc
@@ -59,7 +59,7 @@
return Status(absl::StatusCode::kInternal,
absl::StrCat("Could not allocate buffer of size ", count));
}
- auto buf = std::move(buf_result.ValueOrDie());
+ auto buf = std::move(buf_result.value());
int full_size = full_contents.size();
auto status = ras->PRead(pos, count, buf.get());
if (!status.ok() && status.code() != absl::StatusCode::kOutOfRange) {
@@ -105,7 +105,7 @@
auto enc_stream_result = encrypter->NewEncryptingStream(
std::move(ct_destination), associated_data);
if (!enc_stream_result.ok()) return enc_stream_result.status();
- auto enc_stream = std::move(enc_stream_result.ValueOrDie());
+ auto enc_stream = std::move(enc_stream_result.value());
status = subtle::test::WriteToStream(enc_stream.get(), plaintext);
if (!status.ok()) return status;
if (plaintext.size() != enc_stream->Position()) {
@@ -124,7 +124,7 @@
auto dec_stream_result = decrypter->NewDecryptingStream(
std::move(ct_source), associated_data);
if (!dec_stream_result.ok()) return dec_stream_result.status();
- auto dec_stream = std::move(dec_stream_result.ValueOrDie());
+ auto dec_stream = std::move(dec_stream_result.value());
std::string decrypted;
status = subtle::test::ReadFromStream(dec_stream.get(), &decrypted);
if (!status.ok()) {
@@ -142,7 +142,7 @@
auto dec_ras_result = decrypter->NewDecryptingRandomAccessStream(
std::move(ct_ras), associated_data);
if (!dec_ras_result.ok()) return dec_ras_result.status();
- auto dec_ras = std::move(dec_ras_result.ValueOrDie());
+ auto dec_ras = std::move(dec_ras_result.value());
int pt_size = plaintext.size();
for (int pos : {0, pt_size / 2, std::max(pt_size - 10, 0)}) {
for (int count : {1, 10, std::max(pt_size / 2, 1), std::max(pt_size, 1)}) {
diff --git a/cc/subtle/streaming_mac_impl.cc b/cc/subtle/streaming_mac_impl.cc
index 6b25b9d..6b6e176 100644
--- a/cc/subtle/streaming_mac_impl.cc
+++ b/cc/subtle/streaming_mac_impl.cc
@@ -68,9 +68,8 @@
}
std::unique_ptr<OutputStreamWithResult<std::string>> string_to_return =
- absl::make_unique<ComputeMacOutputStream>(
- std::move(mac_status.ValueOrDie()));
- return string_to_return;
+ absl::make_unique<ComputeMacOutputStream>(std::move(mac_status.value()));
+ return std::move(string_to_return);
}
util::StatusOr<int> ComputeMacOutputStream::NextBuffer(void** buffer) {
@@ -167,7 +166,7 @@
if (!mac_actual.ok()) {
return mac_actual.status();
}
- if (mac_actual.ValueOrDie() == expected_) {
+ if (mac_actual.value() == expected_) {
return util::OkStatus();
}
return util::Status(absl::StatusCode::kInvalidArgument, "Incorrect MAC");
@@ -198,8 +197,8 @@
return mac_status.status();
}
return std::unique_ptr<OutputStreamWithResult<util::Status>>(
- absl::make_unique<VerifyMacOutputStream>(
- mac_value, std::move(mac_status.ValueOrDie())));
+ absl::make_unique<VerifyMacOutputStream>(mac_value,
+ std::move(mac_status.value())));
}
} // namespace subtle
} // namespace tink
diff --git a/cc/subtle/test_util.cc b/cc/subtle/test_util.cc
index b4749f6..ee17d4a 100644
--- a/cc/subtle/test_util.cc
+++ b/cc/subtle/test_util.cc
@@ -40,7 +40,7 @@
while (remaining > 0) {
auto next_result = output_stream->Next(&buffer);
if (!next_result.ok()) return next_result.status();
- available_space = next_result.ValueOrDie();
+ available_space = next_result.value();
available_bytes = std::min(available_space, remaining);
memcpy(buffer, contents.data() + pos, available_bytes);
remaining -= available_bytes;
@@ -66,7 +66,7 @@
return util::OkStatus();
}
if (!next_result.ok()) return next_result.status();
- auto read_bytes = next_result.ValueOrDie();
+ auto read_bytes = next_result.value();
if (read_bytes > 0) {
output->append(
std::string(reinterpret_cast<const char*>(buffer), read_bytes));
diff --git a/cc/subtle/wycheproof_util.cc b/cc/subtle/wycheproof_util.cc
index 9e018d8..a69a147 100644
--- a/cc/subtle/wycheproof_util.cc
+++ b/cc/subtle/wycheproof_util.cc
@@ -62,7 +62,7 @@
}
std::string HexDecodeOrDie(absl::string_view hex) {
- return HexDecode(hex).ValueOrDie();
+ return HexDecode(hex).value();
}
} // namespace
@@ -134,7 +134,7 @@
hex = "0" + hex;
}
}
- return HexDecode(hex).ValueOrDie();
+ return HexDecode(hex).value();
}
} // namespace subtle
diff --git a/cc/subtle/xchacha20_poly1305_boringssl.cc b/cc/subtle/xchacha20_poly1305_boringssl.cc
index b73f0c9..cd32ca7 100644
--- a/cc/subtle/xchacha20_poly1305_boringssl.cc
+++ b/cc/subtle/xchacha20_poly1305_boringssl.cc
@@ -57,7 +57,7 @@
}
std::unique_ptr<Aead> aead_impl =
absl::WrapUnique(new XChacha20Poly1305BoringSsl(*std::move(aead)));
- return aead_impl;
+ return std::move(aead_impl);
}
util::StatusOr<std::string> XChacha20Poly1305BoringSsl::Encrypt(
diff --git a/cc/util/buffer_test.cc b/cc/util/buffer_test.cc
index 47d45cc..19aa460 100644
--- a/cc/util/buffer_test.cc
+++ b/cc/util/buffer_test.cc
@@ -42,7 +42,7 @@
auto mem_block = absl::make_unique<char[]>(buf_size);
auto buf_result = Buffer::NewNonOwning(mem_block.get(), buf_size);
ASSERT_THAT(buf_result.status(), IsOk());
- auto buf = std::move(buf_result.ValueOrDie());
+ auto buf = std::move(buf_result.value());
EXPECT_EQ(buf_size, buf->size());
EXPECT_EQ(buf_size, buf->allocated_size());
EXPECT_EQ(mem_block.get(), buf->get_mem_block());
@@ -64,7 +64,7 @@
SCOPED_TRACE(absl::StrCat("buf_size = ", buf_size));
auto buf_result = Buffer::New(buf_size);
ASSERT_THAT(buf_result.status(), IsOk());
- auto buf = std::move(buf_result.ValueOrDie());
+ auto buf = std::move(buf_result.value());
EXPECT_EQ(buf_size, buf->size());
EXPECT_EQ(buf_size, buf->allocated_size());
for (auto new_size : {0, 1, buf_size/2, buf_size}) {
@@ -109,7 +109,7 @@
TEST(BufferTest, BadNewSize_ExternalMemoryBlock) {
for (auto buf_size : {1, 10, 100, 1000, 10000}) {
SCOPED_TRACE(absl::StrCat("buf_size = ", buf_size));
- auto buf = std::move(Buffer::New(buf_size).ValueOrDie());
+ auto buf = std::move(Buffer::New(buf_size).value());
for (auto new_size : {-10, -1, buf_size + 1, 2 * buf_size}) {
SCOPED_TRACE(absl::StrCat("new_size = ", buf_size));
EXPECT_THAT(buf->set_size(new_size),
@@ -123,8 +123,8 @@
for (auto buf_size : {1, 10, 100, 1000, 10000}) {
SCOPED_TRACE(absl::StrCat("buf_size = ", buf_size));
auto mem_block = absl::make_unique<char[]>(buf_size);
- auto buf = std::move(
- Buffer::NewNonOwning(mem_block.get(), buf_size).ValueOrDie());
+ auto buf =
+ std::move(Buffer::NewNonOwning(mem_block.get(), buf_size).value());
for (auto new_size : {-10, -1, buf_size + 1, 2 * buf_size}) {
SCOPED_TRACE(absl::StrCat("new_size = ", buf_size));
EXPECT_THAT(buf->set_size(new_size),
diff --git a/cc/util/enums_test.cc b/cc/util/enums_test.cc
index b7062ad..8b5c6b3 100644
--- a/cc/util/enums_test.cc
+++ b/cc/util/enums_test.cc
@@ -114,9 +114,9 @@
}
TEST_F(EnumsTest, testHashSize) {
- EXPECT_EQ(Enums::HashLength(pb::HashType::SHA256).ValueOrDie(), 32);
- EXPECT_EQ(Enums::HashLength(pb::HashType::SHA384).ValueOrDie(), 48);
- EXPECT_EQ(Enums::HashLength(pb::HashType::SHA512).ValueOrDie(), 64);
+ EXPECT_EQ(Enums::HashLength(pb::HashType::SHA256).value(), 32);
+ EXPECT_EQ(Enums::HashLength(pb::HashType::SHA384).value(), 48);
+ EXPECT_EQ(Enums::HashLength(pb::HashType::SHA512).value(), 64);
EXPECT_TRUE(!Enums::HashLength(pb::HashType::UNKNOWN_HASH).ok());
EXPECT_TRUE(!Enums::HashLength(pb::HashType::SHA1).ok());
}
diff --git a/cc/util/fake_kms_client.cc b/cc/util/fake_kms_client.cc
index b57b110..cb5f9ed 100644
--- a/cc/util/fake_kms_client.cc
+++ b/cc/util/fake_kms_client.cc
@@ -104,11 +104,11 @@
return reader_result.status();
}
auto handle_result =
- CleartextKeysetHandle::Read(std::move(reader_result.ValueOrDie()));
+ CleartextKeysetHandle::Read(std::move(reader_result.value()));
if (!handle_result.ok()) {
return handle_result.status();
}
- return handle_result.ValueOrDie()->GetPrimitive<crypto::tink::Aead>();
+ return handle_result.value()->GetPrimitive<crypto::tink::Aead>();
}
Status FakeKmsClient::RegisterNewClient(absl::string_view key_uri,
@@ -118,7 +118,7 @@
return client_result.status();
}
- return KmsClients::Add(std::move(client_result.ValueOrDie()));
+ return KmsClients::Add(std::move(client_result.value()));
}
StatusOr<std::string> FakeKmsClient::CreateFakeKeyUri() {
@@ -134,8 +134,8 @@
if (!writer_result.ok()) {
return writer_result.status();
}
- auto status = CleartextKeysetHandle::Write(writer_result.ValueOrDie().get(),
- *handle_result.ValueOrDie());
+ auto status = CleartextKeysetHandle::Write(writer_result.value().get(),
+ *handle_result.value());
if (!status.ok()) {
return status;
}
diff --git a/cc/util/fake_kms_client_test.cc b/cc/util/fake_kms_client_test.cc
index 1d481a0..b1039c7 100644
--- a/cc/util/fake_kms_client_test.cc
+++ b/cc/util/fake_kms_client_test.cc
@@ -76,25 +76,25 @@
TEST_F(FakeKmsClientTest, CreateNewAeadSuccess) {
auto uri_result = FakeKmsClient::CreateFakeKeyUri();
EXPECT_TRUE(uri_result.ok()) << uri_result.status();
- std::string key_uri = uri_result.ValueOrDie();
+ std::string key_uri = uri_result.value();
auto client_result = FakeKmsClient::New(key_uri, "");
EXPECT_TRUE(client_result.ok()) << client_result.status();
- auto client = std::move(client_result.ValueOrDie());
+ auto client = std::move(client_result.value());
EXPECT_TRUE(client->DoesSupport(key_uri));
auto aead_result = client->GetAead(key_uri);
EXPECT_TRUE(aead_result.ok()) << aead_result.status();
- auto aead = std::move(aead_result.ValueOrDie());
+ auto aead = std::move(aead_result.value());
std::string plaintext = "some_plaintext";
std::string aad = "some_aad";
auto encrypt_result = aead->Encrypt(plaintext, aad);
EXPECT_TRUE(encrypt_result.ok()) << encrypt_result.status();
- std::string ciphertext = encrypt_result.ValueOrDie();
+ std::string ciphertext = encrypt_result.value();
auto decrypt_result = aead->Decrypt(ciphertext, aad);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
}
TEST_F(FakeKmsClientTest, ClientIsBound) {
@@ -104,7 +104,7 @@
"YXhLZXkSFhICCBAaEPFnQNgtxEG0vEek8bBfgL8YARABGL3oi0kgAQ";
auto client_result = FakeKmsClient::New(key_uri, "");
EXPECT_TRUE(client_result.ok()) << client_result.status();
- auto client = std::move(client_result.ValueOrDie());
+ auto client = std::move(client_result.value());
// No other key_uri is accepted, even a valid one.
std::string another_key_uri =
@@ -119,7 +119,7 @@
TEST_F(FakeKmsClientTest, ClientIsUnbound) {
auto client_result = FakeKmsClient::New("", "");
EXPECT_TRUE(client_result.ok()) << client_result.status();
- auto client = std::move(client_result.ValueOrDie());
+ auto client = std::move(client_result.value());
// All valid 'fake-kms' key_uris are accepted.
std::string uri =
@@ -142,32 +142,31 @@
TEST_F(FakeKmsClientTest, RegisterAndEncryptDecryptWithKmsAead) {
auto uri_result = FakeKmsClient::CreateFakeKeyUri();
EXPECT_TRUE(uri_result.ok()) << uri_result.status();
- std::string key_uri = uri_result.ValueOrDie();
+ std::string key_uri = uri_result.value();
auto status = FakeKmsClient::RegisterNewClient(key_uri, "");
EXPECT_THAT(status, IsOk());
KeyTemplate key_template = NewKmsAeadKeyTemplate(key_uri);
auto handle_result = KeysetHandle::GenerateNew(key_template);
EXPECT_TRUE(handle_result.ok()) << handle_result.status();
- auto aead_result =
- handle_result.ValueOrDie()->GetPrimitive<crypto::tink::Aead>();
+ auto aead_result = handle_result.value()->GetPrimitive<crypto::tink::Aead>();
EXPECT_TRUE(aead_result.ok()) << aead_result.status();
- auto aead = std::move(aead_result.ValueOrDie());
+ auto aead = std::move(aead_result.value());
std::string plaintext = "some_plaintext";
std::string aad = "some_aad";
auto encrypt_result = aead->Encrypt(plaintext, aad);
EXPECT_TRUE(encrypt_result.ok()) << encrypt_result.status();
- std::string ciphertext = encrypt_result.ValueOrDie();
+ std::string ciphertext = encrypt_result.value();
auto decrypt_result = aead->Decrypt(ciphertext, aad);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
}
TEST_F(FakeKmsClientTest, RegisterAndEncryptDecryptWithKmsEnvelopeAead) {
auto uri_result = FakeKmsClient::CreateFakeKeyUri();
EXPECT_TRUE(uri_result.ok()) << uri_result.status();
- std::string key_uri = uri_result.ValueOrDie();
+ std::string key_uri = uri_result.value();
auto status = FakeKmsClient::RegisterNewClient(key_uri, "");
EXPECT_THAT(status, IsOk());
@@ -175,19 +174,18 @@
NewKmsEnvelopeKeyTemplate(key_uri, AeadKeyTemplates::Aes128Gcm());
auto handle_result = KeysetHandle::GenerateNew(key_template);
EXPECT_TRUE(handle_result.ok()) << handle_result.status();
- auto aead_result =
- handle_result.ValueOrDie()->GetPrimitive<crypto::tink::Aead>();
+ auto aead_result = handle_result.value()->GetPrimitive<crypto::tink::Aead>();
EXPECT_TRUE(aead_result.ok()) << aead_result.status();
- auto aead = std::move(aead_result.ValueOrDie());
+ auto aead = std::move(aead_result.value());
std::string plaintext = "some_plaintext";
std::string aad = "some_aad";
auto encrypt_result = aead->Encrypt(plaintext, aad);
EXPECT_TRUE(encrypt_result.ok()) << encrypt_result.status();
- std::string ciphertext = encrypt_result.ValueOrDie();
+ std::string ciphertext = encrypt_result.value();
auto decrypt_result = aead->Decrypt(ciphertext, aad);
EXPECT_TRUE(decrypt_result.ok()) << decrypt_result.status();
- EXPECT_EQ(plaintext, decrypt_result.ValueOrDie());
+ EXPECT_EQ(plaintext, decrypt_result.value());
}
// TODO(b/174740983): Add test where an unbounded KeyClient is registered.
diff --git a/cc/util/file_input_stream_test.cc b/cc/util/file_input_stream_test.cc
index e092d9a..14ecc1a 100644
--- a/cc/util/file_input_stream_test.cc
+++ b/cc/util/file_input_stream_test.cc
@@ -38,8 +38,7 @@
const void* buffer;
auto next_result = input_stream->Next(&buffer);
while (next_result.ok()) {
- contents->append(static_cast<const char*>(buffer),
- next_result.ValueOrDie());
+ contents->append(static_cast<const char*>(buffer), next_result.value());
next_result = input_stream->Next(&buffer);
}
return next_result.status();
@@ -79,7 +78,7 @@
const void* buffer;
auto next_result = input_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(file_contents.substr(0, buffer_size),
std::string(static_cast<const char*>(buffer), buffer_size));
}
@@ -101,7 +100,7 @@
EXPECT_EQ(0, input_stream->Position());
auto next_result = input_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(buffer_size, input_stream->Position());
EXPECT_EQ(file_contents.substr(0, buffer_size),
std::string(static_cast<const char*>(buffer), buffer_size));
@@ -117,7 +116,7 @@
// Call Next(), it should return exactly the backed up bytes.
next_result = input_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(total_backup_size, next_result.ValueOrDie());
+ EXPECT_EQ(total_backup_size, next_result.value());
EXPECT_EQ(buffer_size, input_stream->Position());
EXPECT_EQ(
file_contents.substr(buffer_size - total_backup_size, total_backup_size),
@@ -135,7 +134,7 @@
// Call Next(), it should return exactly the backed up bytes.
next_result = input_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(total_backup_size, next_result.ValueOrDie());
+ EXPECT_EQ(total_backup_size, next_result.value());
EXPECT_EQ(buffer_size, input_stream->Position());
EXPECT_EQ(
file_contents.substr(buffer_size - total_backup_size, total_backup_size),
@@ -144,7 +143,7 @@
// Call Next() again, it should return the second block.
next_result = input_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(2 * buffer_size, input_stream->Position());
EXPECT_EQ(file_contents.substr(buffer_size, buffer_size),
std::string(static_cast<const char*>(buffer), buffer_size));
@@ -163,7 +162,7 @@
// Call Next() again, it should return the second block.
next_result = input_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(2 * buffer_size, input_stream->Position());
EXPECT_EQ(file_contents.substr(buffer_size, buffer_size),
std::string(static_cast<const char*>(buffer), buffer_size));
diff --git a/cc/util/file_output_stream_test.cc b/cc/util/file_output_stream_test.cc
index 5b1f3e6..dbdf7f2 100644
--- a/cc/util/file_output_stream_test.cc
+++ b/cc/util/file_output_stream_test.cc
@@ -43,7 +43,7 @@
while (remaining > 0) {
auto next_result = output_stream->Next(&buffer);
if (!next_result.ok()) return next_result.status();
- available_space = next_result.ValueOrDie();
+ available_space = next_result.value();
available_bytes = std::min(available_space, remaining);
memcpy(buffer, contents.data() + pos, available_bytes);
remaining -= available_bytes;
@@ -85,7 +85,7 @@
void* buffer;
auto next_result = output_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
output_stream->BackUp(buffer_size);
auto status = WriteToStream(output_stream.get(), stream_contents);
EXPECT_TRUE(status.ok()) << status;
@@ -110,7 +110,7 @@
EXPECT_EQ(0, output_stream->Position());
auto next_result = output_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(buffer_size, output_stream->Position());
std::memcpy(buffer, stream_contents.data(), buffer_size);
@@ -122,7 +122,7 @@
total_backup_size += std::max(0, backup_size);
EXPECT_EQ(buffer_size - total_backup_size, output_stream->Position());
}
- EXPECT_LT(total_backup_size, next_result.ValueOrDie());
+ EXPECT_LT(total_backup_size, next_result.value());
// Call Next(), it should succeed.
next_result = output_stream->Next(&buffer);
@@ -136,7 +136,7 @@
total_backup_size += std::max(0, backup_size);
EXPECT_EQ(buffer_size - total_backup_size, output_stream->Position());
}
- EXPECT_LT(total_backup_size, next_result.ValueOrDie());
+ EXPECT_LT(total_backup_size, next_result.value());
// Call Next(), it should succeed;
next_result = output_stream->Next(&buffer);
@@ -146,7 +146,7 @@
auto prev_position = output_stream->Position();
next_result = output_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(prev_position + buffer_size, output_stream->Position());
std::memcpy(buffer, stream_contents.data() + buffer_size, buffer_size);
@@ -167,7 +167,7 @@
// Call Next() again, it should return a full block.
next_result = output_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(prev_position + buffer_size, output_stream->Position());
std::memcpy(buffer, stream_contents.data() + buffer_size, buffer_size);
diff --git a/cc/util/file_random_access_stream_test.cc b/cc/util/file_random_access_stream_test.cc
index 7b3e220..70c510a 100644
--- a/cc/util/file_random_access_stream_test.cc
+++ b/cc/util/file_random_access_stream_test.cc
@@ -38,7 +38,7 @@
util::Status ReadAll(RandomAccessStream* ra_stream, int chunk_size,
std::string* contents) {
contents->clear();
- auto buffer = std::move(Buffer::New(chunk_size).ValueOrDie());
+ auto buffer = std::move(Buffer::New(chunk_size).value());
int64_t position = 0;
auto status = ra_stream->PRead(position, chunk_size, buffer.get());
while (status.ok()) {
@@ -61,8 +61,8 @@
SCOPED_TRACE(absl::StrCat("stream_size = ", file_contents.size(),
", position = ", position,
", count = ", count));
- auto buffer = std::move(Buffer::New(count).ValueOrDie());
- int stream_size = ra_stream->size().ValueOrDie();
+ auto buffer = std::move(Buffer::New(count).value());
+ int stream_size = ra_stream->size().value();
EXPECT_EQ(file_contents.size(), stream_size);
auto status = ra_stream->PRead(position, count, buffer.get());
EXPECT_TRUE(status.ok());
@@ -91,7 +91,7 @@
EXPECT_EQ(absl::StatusCode::kOutOfRange, status.code());
EXPECT_EQ("EOF", status.message());
EXPECT_EQ(file_contents, stream_contents);
- EXPECT_EQ(stream_size, ra_stream->size().ValueOrDie());
+ EXPECT_EQ(stream_size, ra_stream->size().value());
}
}
@@ -104,13 +104,13 @@
test::GetTestFileDescriptor(filename, stream_size, &file_contents);
EXPECT_EQ(stream_size, file_contents.size());
auto ra_stream = absl::make_unique<util::FileRandomAccessStream>(input_fd);
- auto buffer = std::move(Buffer::New(stream_size).ValueOrDie());
+ auto buffer = std::move(Buffer::New(stream_size).value());
// Read from the beginning till the last byte.
auto status = ra_stream->PRead(/* position = */ 0,
stream_size, buffer.get());
EXPECT_TRUE(status.ok());
- EXPECT_EQ(stream_size, ra_stream->size().ValueOrDie());
+ EXPECT_EQ(stream_size, ra_stream->size().value());
EXPECT_EQ(0, memcmp(&file_contents[0],
buffer->get_mem_block(), stream_size));
}
@@ -148,7 +148,7 @@
test::GetTestFileDescriptor(filename, stream_size, &file_contents);
auto ra_stream = absl::make_unique<util::FileRandomAccessStream>(input_fd);
int count = 42;
- auto buffer = std::move(Buffer::New(count).ValueOrDie());
+ auto buffer = std::move(Buffer::New(count).value());
for (auto position : {-100, -10, -1}) {
SCOPED_TRACE(absl::StrCat("stream_size = ", stream_size,
" position = ", position));
@@ -166,7 +166,7 @@
int input_fd =
test::GetTestFileDescriptor(filename, stream_size, &file_contents);
auto ra_stream = absl::make_unique<util::FileRandomAccessStream>(input_fd);
- auto buffer = std::move(Buffer::New(42).ValueOrDie());
+ auto buffer = std::move(Buffer::New(42).value());
int64_t position = 0;
for (auto count : {-100, -10, -1, 0}) {
SCOPED_TRACE(absl::StrCat("stream_size = ", stream_size,
@@ -185,7 +185,7 @@
test::GetTestFileDescriptor(filename, stream_size, &file_contents);
auto ra_stream = absl::make_unique<util::FileRandomAccessStream>(input_fd);
int count = 42;
- auto buffer = std::move(Buffer::New(count).ValueOrDie());
+ auto buffer = std::move(Buffer::New(count).value());
for (auto position : {stream_size + 1, stream_size + 10}) {
SCOPED_TRACE(absl::StrCat("stream_size = ", stream_size,
" position = ", position));
diff --git a/cc/util/input_stream_util.cc b/cc/util/input_stream_util.cc
index 600353d..cc3dbb9 100644
--- a/cc/util/input_stream_util.cc
+++ b/cc/util/input_stream_util.cc
@@ -43,7 +43,7 @@
auto next_result = input_stream->Next(&buffer);
if (!next_result.ok()) return next_result.status();
- int num_bytes_in_chunk = next_result.ValueOrDie();
+ int num_bytes_in_chunk = next_result.value();
int num_bytes_to_copy =
std::min(num_bytes - num_bytes_read, num_bytes_in_chunk);
absl::c_copy(absl::MakeSpan(reinterpret_cast<const char*>(buffer),
diff --git a/cc/util/input_stream_util_test.cc b/cc/util/input_stream_util_test.cc
index a6133a7..d88184d 100644
--- a/cc/util/input_stream_util_test.cc
+++ b/cc/util/input_stream_util_test.cc
@@ -43,7 +43,7 @@
absl::make_unique<std::stringstream>(content)};
auto text_or = ReadBytesFromStream(content.size(), &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- std::string text = std::move(text_or).ValueOrDie();
+ std::string text = std::move(text_or).value();
EXPECT_THAT(text, Eq(content));
}
@@ -59,7 +59,7 @@
absl::make_unique<std::stringstream>("0123456789abcdefghijklmnop")};
auto text_or = ReadBytesFromStream(7, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- EXPECT_THAT(text_or.ValueOrDie(), Eq("0123456"));
+ EXPECT_THAT(text_or.value(), Eq("0123456"));
}
TEST(ReadBytesTest, ReadTwice) {
@@ -67,11 +67,11 @@
absl::make_unique<std::stringstream>("0123456789abcdefghijklmnop")};
auto text_or = ReadBytesFromStream(7, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- EXPECT_THAT(text_or.ValueOrDie(), Eq("0123456"));
+ EXPECT_THAT(text_or.value(), Eq("0123456"));
text_or = ReadBytesFromStream(5, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- EXPECT_THAT(text_or.ValueOrDie(), Eq("789ab"));
+ EXPECT_THAT(text_or.value(), Eq("789ab"));
}
TEST(ReadBytesTest, ReadMoreThanBlockSize) {
@@ -81,11 +81,11 @@
absl::make_unique<std::stringstream>("0123456789abcdefghijklmnop"), 4};
auto text_or = ReadBytesFromStream(11, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- EXPECT_THAT(text_or.ValueOrDie(), Eq("0123456789a"));
+ EXPECT_THAT(text_or.value(), Eq("0123456789a"));
text_or = ReadBytesFromStream(5, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- EXPECT_THAT(text_or.ValueOrDie(), Eq("bcdef"));
+ EXPECT_THAT(text_or.value(), Eq("bcdef"));
}
TEST(ReadBytesTest, Request0) {
@@ -93,16 +93,16 @@
absl::make_unique<std::stringstream>("012345678"));
auto text_or = ReadBytesFromStream(4, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- EXPECT_THAT(text_or.ValueOrDie(), Eq("0123"));
+ EXPECT_THAT(text_or.value(), Eq("0123"));
text_or = ReadBytesFromStream(0, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- EXPECT_THAT(text_or.ValueOrDie(), Eq(""));
+ EXPECT_THAT(text_or.value(), Eq(""));
text_or = ReadBytesFromStream(5, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- EXPECT_THAT(text_or.ValueOrDie(), Eq("45678"));
+ EXPECT_THAT(text_or.value(), Eq("45678"));
text_or = ReadBytesFromStream(0, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- EXPECT_THAT(text_or.ValueOrDie(), Eq(""));
+ EXPECT_THAT(text_or.value(), Eq(""));
}
TEST(ReadBytesTest, RequestNegative) {
@@ -110,14 +110,14 @@
absl::make_unique<std::stringstream>("012345678"));
auto text_or = ReadBytesFromStream(-1, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- EXPECT_THAT(text_or.ValueOrDie(), Eq(""));
+ EXPECT_THAT(text_or.value(), Eq(""));
}
TEST(ReadBytesTest, EmptyInput) {
IstreamInputStream input_stream(absl::make_unique<std::stringstream>(""));
auto text_or = ReadBytesFromStream(0, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- EXPECT_THAT(text_or.ValueOrDie(), Eq(""));
+ EXPECT_THAT(text_or.value(), Eq(""));
text_or = ReadBytesFromStream(1, &input_stream);
EXPECT_THAT(text_or.status(), StatusIs(absl::StatusCode::kOutOfRange));
}
@@ -128,8 +128,7 @@
absl::make_unique<std::stringstream>(content)};
auto text_or = ReadSecretBytesFromStream(content.size(), &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- std::string text(
- util::SecretDataAsStringView(std::move(text_or).ValueOrDie()));
+ std::string text(util::SecretDataAsStringView(std::move(text_or).value()));
EXPECT_THAT(text, Eq(content));
}
@@ -145,8 +144,7 @@
absl::make_unique<std::stringstream>("0123456789abcdefghijklmnop")};
auto text_or = ReadSecretBytesFromStream(7, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- std::string text(
- util::SecretDataAsStringView(std::move(text_or).ValueOrDie()));
+ std::string text(util::SecretDataAsStringView(std::move(text_or).value()));
EXPECT_THAT(text, Eq("0123456"));
}
@@ -154,14 +152,12 @@
IstreamInputStream input_stream{
absl::make_unique<std::stringstream>("0123456789abcdefghijklmnop")};
auto text_or = ReadSecretBytesFromStream(7, &input_stream);
- std::string text(
- util::SecretDataAsStringView(std::move(text_or).ValueOrDie()));
+ std::string text(util::SecretDataAsStringView(std::move(text_or).value()));
EXPECT_THAT(text, Eq("0123456"));
text_or = ReadSecretBytesFromStream(5, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- text = std::string(
- util::SecretDataAsStringView(std::move(text_or).ValueOrDie()));
+ text = std::string(util::SecretDataAsStringView(std::move(text_or).value()));
EXPECT_THAT(text, Eq("789ab"));
}
@@ -172,14 +168,12 @@
absl::make_unique<std::stringstream>("0123456789abcdefghijklmnop"), 4};
auto text_or = ReadSecretBytesFromStream(11, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- std::string text(
- util::SecretDataAsStringView(std::move(text_or).ValueOrDie()));
+ std::string text(util::SecretDataAsStringView(std::move(text_or).value()));
EXPECT_THAT(text, Eq("0123456789a"));
text_or = ReadSecretBytesFromStream(5, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- text = std::string(
- util::SecretDataAsStringView(std::move(text_or).ValueOrDie()));
+ text = std::string(util::SecretDataAsStringView(std::move(text_or).value()));
EXPECT_THAT(text, Eq("bcdef"));
}
@@ -188,23 +182,19 @@
absl::make_unique<std::stringstream>("012345678"));
auto text_or = ReadSecretBytesFromStream(4, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- std::string text(
- util::SecretDataAsStringView(std::move(text_or).ValueOrDie()));
+ std::string text(util::SecretDataAsStringView(std::move(text_or).value()));
EXPECT_THAT(text, Eq("0123"));
text_or = ReadSecretBytesFromStream(0, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- text = std::string(
- util::SecretDataAsStringView(std::move(text_or).ValueOrDie()));
+ text = std::string(util::SecretDataAsStringView(std::move(text_or).value()));
EXPECT_THAT(text, Eq(""));
text_or = ReadSecretBytesFromStream(5, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- text = std::string(
- util::SecretDataAsStringView(std::move(text_or).ValueOrDie()));
+ text = std::string(util::SecretDataAsStringView(std::move(text_or).value()));
EXPECT_THAT(text, Eq("45678"));
text_or = ReadSecretBytesFromStream(0, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- text = std::string(
- util::SecretDataAsStringView(std::move(text_or).ValueOrDie()));
+ text = std::string(util::SecretDataAsStringView(std::move(text_or).value()));
EXPECT_THAT(text, Eq(""));
}
@@ -213,8 +203,7 @@
absl::make_unique<std::stringstream>("012345678"));
auto text_or = ReadSecretBytesFromStream(-1, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- std::string text(
- util::SecretDataAsStringView(std::move(text_or).ValueOrDie()));
+ std::string text(util::SecretDataAsStringView(std::move(text_or).value()));
EXPECT_THAT(text, Eq(""));
}
@@ -223,8 +212,7 @@
absl::make_unique<std::stringstream>(""));
auto text_or = ReadSecretBytesFromStream(0, &input_stream);
ASSERT_THAT(text_or.status(), IsOk());
- std::string text(
- util::SecretDataAsStringView(std::move(text_or).ValueOrDie()));
+ std::string text(util::SecretDataAsStringView(std::move(text_or).value()));
EXPECT_THAT(text, Eq(""));
text_or = ReadSecretBytesFromStream(1, &input_stream);
EXPECT_THAT(text_or.status(), StatusIs(absl::StatusCode::kOutOfRange));
diff --git a/cc/util/istream_input_stream_test.cc b/cc/util/istream_input_stream_test.cc
index 6b52fa3..2586348 100644
--- a/cc/util/istream_input_stream_test.cc
+++ b/cc/util/istream_input_stream_test.cc
@@ -66,8 +66,7 @@
const void* buffer;
auto next_result = input_stream->Next(&buffer);
while (next_result.ok()) {
- contents->append(static_cast<const char*>(buffer),
- next_result.ValueOrDie());
+ contents->append(static_cast<const char*>(buffer), next_result.value());
next_result = input_stream->Next(&buffer);
}
return next_result.status();
@@ -104,7 +103,7 @@
const void* buffer;
auto next_result = input_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(file_contents.substr(0, buffer_size),
std::string(static_cast<const char*>(buffer), buffer_size));
}
@@ -125,7 +124,7 @@
EXPECT_EQ(0, input_stream->Position());
auto next_result = input_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(buffer_size, input_stream->Position());
EXPECT_EQ(file_contents.substr(0, buffer_size),
std::string(static_cast<const char*>(buffer), buffer_size));
@@ -140,7 +139,7 @@
// Call Next(), it should return exactly the backed up bytes.
next_result = input_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(total_backup_size, next_result.ValueOrDie());
+ EXPECT_EQ(total_backup_size, next_result.value());
EXPECT_EQ(buffer_size, input_stream->Position());
EXPECT_EQ(
file_contents.substr(buffer_size - total_backup_size, total_backup_size),
@@ -157,7 +156,7 @@
// Call Next(), it should return exactly the backed up bytes.
next_result = input_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(total_backup_size, next_result.ValueOrDie());
+ EXPECT_EQ(total_backup_size, next_result.value());
EXPECT_EQ(buffer_size, input_stream->Position());
EXPECT_EQ(
file_contents.substr(buffer_size - total_backup_size, total_backup_size),
@@ -166,7 +165,7 @@
// Call Next() again, it should return the second block.
next_result = input_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(2 * buffer_size, input_stream->Position());
EXPECT_EQ(file_contents.substr(buffer_size, buffer_size),
std::string(static_cast<const char*>(buffer), buffer_size));
@@ -184,7 +183,7 @@
// Call Next() again, it should return the second block.
next_result = input_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(2 * buffer_size, input_stream->Position());
EXPECT_EQ(file_contents.substr(buffer_size, buffer_size),
std::string(static_cast<const char*>(buffer), buffer_size));
diff --git a/cc/util/ostream_output_stream_test.cc b/cc/util/ostream_output_stream_test.cc
index 9f31910..05db8e54 100644
--- a/cc/util/ostream_output_stream_test.cc
+++ b/cc/util/ostream_output_stream_test.cc
@@ -56,7 +56,7 @@
while (remaining > 0) {
auto next_result = output_stream->Next(&buffer);
if (!next_result.ok()) return next_result.status();
- available_space = next_result.ValueOrDie();
+ available_space = next_result.value();
available_bytes = std::min(available_space, remaining);
memcpy(buffer, contents.data() + pos, available_bytes);
remaining -= available_bytes;
@@ -99,7 +99,7 @@
void* buffer;
auto next_result = output_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
output_stream->BackUp(buffer_size);
auto status = WriteToStream(output_stream.get(), stream_contents);
EXPECT_TRUE(status.ok()) << status;
@@ -123,7 +123,7 @@
EXPECT_EQ(0, output_stream->Position());
auto next_result = output_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(buffer_size, output_stream->Position());
std::memcpy(buffer, stream_contents.data(), buffer_size);
@@ -135,7 +135,7 @@
total_backup_size += std::max(backup_size, 0);
EXPECT_EQ(buffer_size - total_backup_size, output_stream->Position());
}
- EXPECT_LT(total_backup_size, next_result.ValueOrDie());
+ EXPECT_LT(total_backup_size, next_result.value());
// Call Next(), it should succeed.
next_result = output_stream->Next(&buffer);
@@ -149,7 +149,7 @@
total_backup_size += std::max(0, backup_size);
EXPECT_EQ(buffer_size - total_backup_size, output_stream->Position());
}
- EXPECT_LT(total_backup_size, next_result.ValueOrDie());
+ EXPECT_LT(total_backup_size, next_result.value());
// Call Next(), it should succeed;
next_result = output_stream->Next(&buffer);
@@ -159,7 +159,7 @@
auto prev_position = output_stream->Position();
next_result = output_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(prev_position + buffer_size, output_stream->Position());
std::memcpy(buffer, stream_contents.data() + buffer_size, buffer_size);
@@ -180,7 +180,7 @@
// Call Next() again, it should return a full block.
next_result = output_stream->Next(&buffer);
EXPECT_TRUE(next_result.ok()) << next_result.status();
- EXPECT_EQ(buffer_size, next_result.ValueOrDie());
+ EXPECT_EQ(buffer_size, next_result.value());
EXPECT_EQ(prev_position + buffer_size, output_stream->Position());
std::memcpy(buffer, stream_contents.data() + buffer_size, buffer_size);
diff --git a/cc/util/test_matchers.h b/cc/util/test_matchers.h
index 4ff03e2..04db3df 100644
--- a/cc/util/test_matchers.h
+++ b/cc/util/test_matchers.h
@@ -39,7 +39,8 @@
class IsOkAndHoldsMatcherImpl
: public ::testing::MatcherInterface<StatusOrType> {
public:
- using value_type = typename std::remove_reference<StatusOrType>::type::type;
+ using value_type =
+ typename std::remove_reference<StatusOrType>::type::value_type;
template <typename InnerMatcher>
explicit IsOkAndHoldsMatcherImpl(InnerMatcher&& inner_matcher)
diff --git a/cc/util/test_util.cc b/cc/util/test_util.cc
index 35c37ce..7dbaa4a 100644
--- a/cc/util/test_util.cc
+++ b/cc/util/test_util.cc
@@ -167,7 +167,7 @@
}
std::string HexDecodeOrDie(absl::string_view hex) {
- return HexDecode(hex).ValueOrDie();
+ return HexDecode(hex).value();
}
std::string HexEncode(absl::string_view bytes) {
@@ -263,8 +263,7 @@
google::crypto::tink::EllipticCurveType curve_type,
google::crypto::tink::EcPointFormat ec_point_format,
google::crypto::tink::HashType hash_type) {
- auto test_key = internal::NewEcKey(
- Enums::ProtoToSubtle(curve_type)).ValueOrDie();
+ auto test_key = internal::NewEcKey(Enums::ProtoToSubtle(curve_type)).value();
EciesAeadHkdfPrivateKey ecies_key;
ecies_key.set_version(0);
ecies_key.set_key_value(
@@ -379,8 +378,7 @@
google::crypto::tink::EllipticCurveType curve_type,
google::crypto::tink::HashType hash_type,
google::crypto::tink::EcdsaSignatureEncoding encoding) {
- auto test_key = internal::NewEcKey(
- Enums::ProtoToSubtle(curve_type)).ValueOrDie();
+ auto test_key = internal::NewEcKey(Enums::ProtoToSubtle(curve_type)).value();
EcdsaPrivateKey ecdsa_key;
ecdsa_key.set_version(0);
ecdsa_key.set_key_value(
@@ -397,7 +395,7 @@
}
Ed25519PrivateKey GetEd25519TestPrivateKey() {
- auto test_key = internal::NewEd25519Key().ValueOrDie();
+ auto test_key = internal::NewEd25519Key().value();
Ed25519PrivateKey ed25519_key;
ed25519_key.set_version(0);
ed25519_key.set_key_value(test_key->private_key);
diff --git a/cc/util/test_util.h b/cc/util/test_util.h
index 37cf6f5..10de4e3 100644
--- a/cc/util/test_util.h
+++ b/cc/util/test_util.h
@@ -282,7 +282,7 @@
if (!ciphertext.ok()) return ciphertext.status();
absl::Cord ciphertext_cord;
- ciphertext_cord.Append(ciphertext.ValueOrDie());
+ ciphertext_cord.Append(ciphertext.value());
return ciphertext_cord;
}
@@ -294,7 +294,7 @@
if (!plaintext.ok()) return plaintext.status();
absl::Cord plaintext_cord;
- plaintext_cord.Append(plaintext.ValueOrDie());
+ plaintext_cord.Append(plaintext.value());
return plaintext_cord;
}
@@ -385,12 +385,12 @@
status_ = next_result.status();
return status_;
}
- if (next_result.ValueOrDie() < header_.size()) {
+ if (next_result.value() < header_.size()) {
status_ =
util::Status(absl::StatusCode::kInternal, "Buffer too small");
} else {
memcpy(*data, header_.data(), static_cast<int>(header_.size()));
- ct_dest_->BackUp(next_result.ValueOrDie() - header_.size());
+ ct_dest_->BackUp(next_result.value() - header_.size());
}
}
if (!status_.ok()) return status_;
@@ -415,7 +415,7 @@
void* buf;
auto next_result = Next(&buf);
if (next_result.ok()) {
- BackUp(next_result.ValueOrDie());
+ BackUp(next_result.value());
} else {
status_ = next_result.status();
return status_;
@@ -456,7 +456,7 @@
}
return status_;
}
- if (next_result.ValueOrDie() < exp_header_.size()) {
+ if (next_result.value() < exp_header_.size()) {
status_ =
util::Status(absl::StatusCode::kInternal, "Buffer too small");
} else if (memcmp((*data), exp_header_.data(),
@@ -465,7 +465,7 @@
"Corrupted header");
}
if (status_.ok()) {
- ct_source_->BackUp(next_result.ValueOrDie() - exp_header_.size());
+ ct_source_->BackUp(next_result.value() - exp_header_.size());
}
}
if (!status_.ok()) return status_;
@@ -530,14 +530,14 @@
}
auto ct_size_result = ct_source_->size();
if (!ct_size_result.ok()) return ct_size_result.status();
- auto pt_size = ct_size_result.ValueOrDie() - exp_header_.size();
+ auto pt_size = ct_size_result.value() - exp_header_.size();
if (pt_size >= 0) return pt_size;
return util::Status(absl::StatusCode::kUnavailable, "size not available");
}
private:
void Initialize() ABSL_EXCLUSIVE_LOCKS_REQUIRED(status_mutex_) {
- auto buf = std::move(util::Buffer::New(exp_header_.size()).ValueOrDie());
+ auto buf = std::move(util::Buffer::New(exp_header_.size()).value());
status_ = ct_source_->PRead(0, exp_header_.size(), buf.get());
if (!status_.ok() && status_.code() != absl::StatusCode::kOutOfRange)
return;
diff --git a/cc/util/test_util_test.cc b/cc/util/test_util_test.cc
index d0cfd50..4b8fdf9 100644
--- a/cc/util/test_util_test.cc
+++ b/cc/util/test_util_test.cc
@@ -47,7 +47,7 @@
}
TEST(DummyTests, Aead) {
- EXPECT_THAT(DummyAead("dummy").Encrypt("foo", "bar").ValueOrDie(),
+ EXPECT_THAT(DummyAead("dummy").Encrypt("foo", "bar").value(),
Eq("5:3:dummybarfoo"));
}
@@ -57,7 +57,7 @@
absl::Cord aad;
aad.Append("bar");
- EXPECT_THAT(DummyCordAead("dummy").Encrypt(plaintext, aad).ValueOrDie(),
+ EXPECT_THAT(DummyCordAead("dummy").Encrypt(plaintext, aad).value(),
Eq("5:3:dummybarfoo"));
}
@@ -71,7 +71,7 @@
aad.Append("a");
aad.Append("r");
- EXPECT_THAT(DummyCordAead("dummy").Encrypt(plaintext, aad).ValueOrDie(),
+ EXPECT_THAT(DummyCordAead("dummy").Encrypt(plaintext, aad).value(),
Eq("5:3:dummybarfoo"));
}
diff --git a/go/hybrid/hpke/BUILD.bazel b/go/hybrid/hpke/BUILD.bazel
index 34a78e5..368711e 100644
--- a/go/hybrid/hpke/BUILD.bazel
+++ b/go/hybrid/hpke/BUILD.bazel
@@ -15,6 +15,7 @@
"kdf.go",
"kem.go",
"primitive_factory.go",
+ "private_key_manager.go",
"public_key_manager.go",
"x25519_kem.go",
],
@@ -41,6 +42,7 @@
"hkdf_kdf_test.go",
"hpke_test.go",
"primitive_factory_test.go",
+ "private_key_manager_test.go",
"public_key_manager_test.go",
"x25519_kem_test.go",
],
@@ -49,10 +51,13 @@
deps = [
"//core/registry",
"//proto/hpke_go_proto",
+ "//proto/tink_go_proto",
"//subtle",
"//subtle/random",
"//testutil",
+ "@com_github_google_go_cmp//cmp",
"@org_golang_google_protobuf//proto",
+ "@org_golang_google_protobuf//testing/protocmp",
],
)
diff --git a/go/hybrid/hpke/hpke.go b/go/hybrid/hpke/hpke.go
index 70319c2..99cd685 100644
--- a/go/hybrid/hpke/hpke.go
+++ b/go/hybrid/hpke/hpke.go
@@ -55,6 +55,9 @@
if err := registry.RegisterKeyManager(new(publicKeyManager)); err != nil {
panic(fmt.Sprintf("hpke.init() failed: %v", err))
}
+ if err := registry.RegisterKeyManager(new(privateKeyManager)); err != nil {
+ panic(fmt.Sprintf("hpke.init() failed: %v", err))
+ }
}
// kemSuiteID generates the KEM suite ID from kemID according to
diff --git a/go/hybrid/hpke/private_key_manager.go b/go/hybrid/hpke/private_key_manager.go
new file mode 100644
index 0000000..f28a4de
--- /dev/null
+++ b/go/hybrid/hpke/private_key_manager.go
@@ -0,0 +1,143 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package hpke
+
+import (
+ "errors"
+ "fmt"
+
+ "google.golang.org/protobuf/proto"
+ "github.com/google/tink/go/core/registry"
+ "github.com/google/tink/go/keyset"
+ hpkepb "github.com/google/tink/go/proto/hpke_go_proto"
+ tinkpb "github.com/google/tink/go/proto/tink_go_proto"
+)
+
+const (
+ // maxSupportedPrivateKeyVersion is the max supported private key version. It
+ // must be incremented when support for new versions are implemented.
+ maxSupportedPrivateKeyVersion uint32 = 0
+ privateKeyTypeURL = "type.googleapis.com/google.crypto.tink.HpkePrivateKey"
+)
+
+var (
+ errInvalidPrivateKey = errors.New("invalid HPKE private key")
+ errInvalidPrivateKeyFormat = errors.New("invalid HPKE private key format")
+)
+
+// privateKeyManager implements the KeyManager interface for HybridDecrypt.
+type privateKeyManager struct{}
+
+var _ registry.PrivateKeyManager = (*privateKeyManager)(nil)
+
+func (p *privateKeyManager) Primitive(serializedKey []byte) (interface{}, error) {
+ if len(serializedKey) == 0 {
+ return nil, errInvalidPrivateKey
+ }
+ key := new(hpkepb.HpkePrivateKey)
+ if err := proto.Unmarshal(serializedKey, key); err != nil {
+ return nil, errInvalidPrivateKey
+ }
+ if err := keyset.ValidateKeyVersion(key.GetVersion(), maxSupportedPrivateKeyVersion); err != nil {
+ return nil, err
+ }
+ return newDecrypt(key)
+}
+
+// NewKey returns a set of private and public keys of key version 0.
+func (p *privateKeyManager) NewKey(serializedKeyFormat []byte) (proto.Message, error) {
+ if len(serializedKeyFormat) == 0 {
+ return nil, errInvalidPrivateKeyFormat
+ }
+ keyFormat := new(hpkepb.HpkeKeyFormat)
+ if err := proto.Unmarshal(serializedKeyFormat, keyFormat); err != nil {
+ return nil, errInvalidPrivateKeyFormat
+ }
+ if err := validateKeyFormat(keyFormat); err != nil {
+ return nil, err
+ }
+
+ privKeyBytes, err := x25519KEMGeneratePrivateKey()
+ if err != nil {
+ return nil, fmt.Errorf("generate X25519 private key: %v", err)
+ }
+ pubKeyBytes, err := x25519KEMPublicFromPrivate(privKeyBytes)
+ if err != nil {
+ return nil, fmt.Errorf("get X25519 public key from private key: %v", err)
+ }
+
+ return &hpkepb.HpkePrivateKey{
+ Version: 0,
+ PublicKey: &hpkepb.HpkePublicKey{
+ Version: 0,
+ Params: keyFormat.GetParams(),
+ PublicKey: pubKeyBytes,
+ },
+ PrivateKey: privKeyBytes,
+ }, nil
+}
+
+func (p *privateKeyManager) NewKeyData(serializedKeyFormat []byte) (*tinkpb.KeyData, error) {
+ key, err := p.NewKey(serializedKeyFormat)
+ if err != nil {
+ return nil, err
+ }
+ serializedKey, err := proto.Marshal(key)
+ if err != nil {
+ return nil, err
+ }
+ return &tinkpb.KeyData{
+ TypeUrl: privateKeyTypeURL,
+ Value: serializedKey,
+ KeyMaterialType: tinkpb.KeyData_ASYMMETRIC_PRIVATE,
+ }, nil
+}
+
+func (p *privateKeyManager) PublicKeyData(serializedPrivKey []byte) (*tinkpb.KeyData, error) {
+ privKey := new(hpkepb.HpkePrivateKey)
+ if err := proto.Unmarshal(serializedPrivKey, privKey); err != nil {
+ return nil, errInvalidPrivateKey
+ }
+ serializedPubKey, err := proto.Marshal(privKey.GetPublicKey())
+ if err != nil {
+ return nil, errInvalidPrivateKey
+ }
+ return &tinkpb.KeyData{
+ TypeUrl: publicKeyTypeURL,
+ Value: serializedPubKey,
+ KeyMaterialType: tinkpb.KeyData_ASYMMETRIC_PUBLIC,
+ }, nil
+}
+
+func (p *privateKeyManager) DoesSupport(typeURL string) bool {
+ return typeURL == privateKeyTypeURL
+}
+
+func (p *privateKeyManager) TypeURL() string {
+ return privateKeyTypeURL
+}
+
+func validateKeyFormat(kf *hpkepb.HpkeKeyFormat) error {
+ params := kf.GetParams()
+ kem, kdf, aead := params.GetKem(), params.GetKdf(), params.GetAead()
+ if kem != hpkepb.HpkeKem_DHKEM_X25519_HKDF_SHA256 ||
+ kdf != hpkepb.HpkeKdf_HKDF_SHA256 ||
+ (aead != hpkepb.HpkeAead_AES_128_GCM && aead != hpkepb.HpkeAead_AES_256_GCM) {
+ return errInvalidPrivateKeyFormat
+ }
+ return nil
+}
diff --git a/go/hybrid/hpke/private_key_manager_test.go b/go/hybrid/hpke/private_key_manager_test.go
new file mode 100644
index 0000000..27d615f
--- /dev/null
+++ b/go/hybrid/hpke/private_key_manager_test.go
@@ -0,0 +1,440 @@
+// Copyright 2022 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+package hpke
+
+import (
+ "bytes"
+ "testing"
+
+ "github.com/google/go-cmp/cmp"
+ "google.golang.org/protobuf/proto"
+ "google.golang.org/protobuf/testing/protocmp"
+ "github.com/google/tink/go/core/registry"
+ "github.com/google/tink/go/subtle/random"
+ hpkepb "github.com/google/tink/go/proto/hpke_go_proto"
+ tinkpb "github.com/google/tink/go/proto/tink_go_proto"
+)
+
+func TestPrivateKeyManagerPrimitiveRejectsInvalidKeyVersion(t *testing.T) {
+ km, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+ _, privKey := pubPrivKeys(t, validParams(t))
+ privKey.Version = 1
+ serializedPrivKey, err := proto.Marshal(privKey)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := km.Primitive(serializedPrivKey); err == nil {
+ t.Error("Primitive() err = nil, want error")
+ }
+}
+
+func TestPrivateKeyManagerPrimitiveRejectsInvalidParams(t *testing.T) {
+ km, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+
+ tests := []struct {
+ name string
+ params *hpkepb.HpkeParams
+ }{
+ {"kem", &hpkepb.HpkeParams{
+ Kem: hpkepb.HpkeKem_KEM_UNKNOWN,
+ Kdf: hpkepb.HpkeKdf_HKDF_SHA256,
+ Aead: hpkepb.HpkeAead_AES_256_GCM,
+ }},
+ {"kdf", &hpkepb.HpkeParams{
+ Kem: hpkepb.HpkeKem_DHKEM_X25519_HKDF_SHA256,
+ Kdf: hpkepb.HpkeKdf_KDF_UNKNOWN,
+ Aead: hpkepb.HpkeAead_AES_256_GCM,
+ }},
+ {"aead", &hpkepb.HpkeParams{
+ Kem: hpkepb.HpkeKem_DHKEM_X25519_HKDF_SHA256,
+ Kdf: hpkepb.HpkeKdf_HKDF_SHA256,
+ Aead: hpkepb.HpkeAead_AEAD_UNKNOWN,
+ }},
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ _, privKey := pubPrivKeys(t, test.params)
+ serializedPrivKey, err := proto.Marshal(privKey)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := km.Primitive(serializedPrivKey); err == nil {
+ t.Error("Primitive() err = nil, want error")
+ }
+ })
+ }
+}
+
+func TestPrivateKeyManagerPrimitiveRejectsMissingParams(t *testing.T) {
+ km, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+ _, privKey := pubPrivKeys(t, nil /*=params*/)
+ serializedPrivKey, err := proto.Marshal(privKey)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := km.Primitive(serializedPrivKey); err == nil {
+ t.Error("Primitive() err = nil, want error")
+ }
+}
+
+func TestPrivateKeyManagerPrimitiveRejectsNilKey(t *testing.T) {
+ km, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+ if _, err := km.Primitive(nil); err == nil {
+ t.Error("Primitive() err = nil, want error")
+ }
+}
+
+func TestPrivateKeyManagerPrimitiveEncryptDecrypt(t *testing.T) {
+ km, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+ pt := random.GetRandomBytes(200)
+ ctxInfo := random.GetRandomBytes(100)
+
+ aeadIDs := []hpkepb.HpkeAead{hpkepb.HpkeAead_AES_128_GCM, hpkepb.HpkeAead_AES_256_GCM}
+ for _, aeadID := range aeadIDs {
+ params := &hpkepb.HpkeParams{
+ Kem: hpkepb.HpkeKem_DHKEM_X25519_HKDF_SHA256,
+ Kdf: hpkepb.HpkeKdf_HKDF_SHA256,
+ Aead: aeadID,
+ }
+ pubKey, privKey := pubPrivKeys(t, params)
+ serializedPrivKey, err := proto.Marshal(privKey)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ enc, err := newEncrypt(pubKey)
+ if err != nil {
+ t.Fatalf("newEncrypt() err = %v, want nil", err)
+ }
+ d, err := km.Primitive(serializedPrivKey)
+ if err != nil {
+ t.Fatalf("Primitive() err = %v, want nil", err)
+ }
+ dec, ok := d.(*Decrypt)
+ if !ok {
+ t.Fatal("primitive is not Decrypt")
+ }
+
+ ct, err := enc.Encrypt(pt, ctxInfo)
+ if err != nil {
+ t.Fatalf("Encrypt() err = %v, want nil", err)
+ }
+ gotPT, err := dec.Decrypt(ct, ctxInfo)
+ if err != nil {
+ t.Fatalf("Decrypt() err = %v, want nil", err)
+ }
+ if want := pt; !bytes.Equal(gotPT, want) {
+ t.Errorf("Decrypt() = %x, want %x", gotPT, want)
+ }
+ }
+}
+
+func TestPrivateKeyManagerNewKeyRejectsNilKeyFormat(t *testing.T) {
+ km, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+ if _, err := km.NewKey(nil); err == nil {
+ t.Error("NewKey() err = nil, want error")
+ }
+}
+
+func TestPrivateKeyManagerNewKeyRejectsInvalidKeyFormat(t *testing.T) {
+ km, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+ serializedKeyFormatUnknownKEM, err := proto.Marshal(
+ &hpkepb.HpkeParams{
+ Kem: hpkepb.HpkeKem_KEM_UNKNOWN,
+ Kdf: hpkepb.HpkeKdf_HKDF_SHA256,
+ Aead: hpkepb.HpkeAead_AES_256_GCM,
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ serializedKeyFormatUnknownKDF, err := proto.Marshal(
+ &hpkepb.HpkeParams{
+ Kem: hpkepb.HpkeKem_DHKEM_X25519_HKDF_SHA256,
+ Kdf: hpkepb.HpkeKdf_KDF_UNKNOWN,
+ Aead: hpkepb.HpkeAead_AES_256_GCM,
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ serializedKeyFormatUnknownAEAD, err := proto.Marshal(
+ &hpkepb.HpkeParams{
+ Kem: hpkepb.HpkeKem_DHKEM_X25519_HKDF_SHA256,
+ Kdf: hpkepb.HpkeKdf_HKDF_SHA256,
+ Aead: hpkepb.HpkeAead_AEAD_UNKNOWN,
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ tests := []struct {
+ name string
+ keyFormat []byte
+ }{
+ {"kem", serializedKeyFormatUnknownKEM},
+ {"kdf", serializedKeyFormatUnknownKDF},
+ {"aead", serializedKeyFormatUnknownAEAD},
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ if _, err := km.NewKey(test.keyFormat); err == nil {
+ t.Error("NewKey() err = nil, want error")
+ }
+ })
+ }
+}
+
+func TestPrivateKeyManagerNewKeyEncryptDecrypt(t *testing.T) {
+ km, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+
+ wantPT := random.GetRandomBytes(200)
+ ctxInfo := random.GetRandomBytes(100)
+
+ aeadIDs := []hpkepb.HpkeAead{hpkepb.HpkeAead_AES_128_GCM, hpkepb.HpkeAead_AES_256_GCM}
+ for _, aeadID := range aeadIDs {
+ keyFormat := &hpkepb.HpkeKeyFormat{
+ Params: &hpkepb.HpkeParams{
+ Kem: hpkepb.HpkeKem_DHKEM_X25519_HKDF_SHA256,
+ Kdf: hpkepb.HpkeKdf_HKDF_SHA256,
+ Aead: aeadID,
+ },
+ }
+ serializedKeyFormat, err := proto.Marshal(keyFormat)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ privKeyProto, err := km.NewKey(serializedKeyFormat)
+ if err != nil {
+ t.Fatalf("NewKey() err = %v, want nil", err)
+ }
+ privKey, ok := privKeyProto.(*hpkepb.HpkePrivateKey)
+ if !ok {
+ t.Fatal("primitive is not HpkePrivateKey")
+ }
+ if privKey.GetVersion() != 0 {
+ t.Errorf("private key version = %d, want %d", privKey.GetVersion(), 0)
+ }
+ if len(privKey.GetPrivateKey()) == 0 {
+ t.Error("private key is missing")
+ }
+
+ pubKey := privKey.GetPublicKey()
+ if pubKey.GetVersion() != 0 {
+ t.Errorf("public key version = %d, want %d", pubKey.GetVersion(), 0)
+ }
+ if !cmp.Equal(pubKey.GetParams(), keyFormat.GetParams(), protocmp.Transform()) {
+ t.Errorf("key params = %v, want %v", pubKey.GetParams(), keyFormat.GetParams())
+ }
+ if len(pubKey.GetPublicKey()) == 0 {
+ t.Error("public key is missing")
+ }
+
+ enc, err := newEncrypt(pubKey)
+ if err != nil {
+ t.Fatalf("newEncrypt() err = %v, want nil", err)
+ }
+ serializedPrivKey, err := proto.Marshal(privKeyProto)
+ if err != nil {
+ t.Fatal(err)
+ }
+ d, err := km.Primitive(serializedPrivKey)
+ if err != nil {
+ t.Fatalf("Primitive() err = %v, want nil", err)
+ }
+ dec, ok := d.(*Decrypt)
+ if !ok {
+ t.Fatal("primitive is not Decrypt")
+ }
+
+ ct, err := enc.Encrypt(wantPT, ctxInfo)
+ if err != nil {
+ t.Fatalf("Encrypt() err = %v, want nil", err)
+ }
+ gotPT, err := dec.Decrypt(ct, ctxInfo)
+ if err != nil {
+ t.Fatalf("Decrypt() err = %v, want nil", err)
+ }
+ if !bytes.Equal(gotPT, wantPT) {
+ t.Errorf("Decrypt() = %x, want %x", gotPT, wantPT)
+ }
+ }
+}
+
+func TestPrivateKeyManagerNewKeyDataRejectsNilKeyFormat(t *testing.T) {
+ km, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+ if _, err := km.NewKeyData(nil); err == nil {
+ t.Error("NewKey() err = nil, want error")
+ }
+}
+
+func TestPrivateKeyManagerNewKeyData(t *testing.T) {
+ km, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+
+ aeadIDs := []hpkepb.HpkeAead{hpkepb.HpkeAead_AES_128_GCM, hpkepb.HpkeAead_AES_256_GCM}
+ for _, aeadID := range aeadIDs {
+ keyFormat := &hpkepb.HpkeKeyFormat{
+ Params: &hpkepb.HpkeParams{
+ Kem: hpkepb.HpkeKem_DHKEM_X25519_HKDF_SHA256,
+ Kdf: hpkepb.HpkeKdf_HKDF_SHA256,
+ Aead: aeadID,
+ },
+ }
+ serializedKeyFormat, err := proto.Marshal(keyFormat)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ keyData, err := km.NewKeyData(serializedKeyFormat)
+ if err != nil {
+ t.Fatalf("NewKeyData() err = %v, want nil", err)
+ }
+ if got, want := keyData.GetTypeUrl(), privateKeyTypeURL; got != want {
+ t.Errorf("type URL = %q, want %q", got, want)
+ }
+ if got, want := keyData.GetKeyMaterialType(), tinkpb.KeyData_ASYMMETRIC_PRIVATE; got != want {
+ t.Errorf("key material type = %d, want %d", got, want)
+ }
+
+ privKey := new(hpkepb.HpkePrivateKey)
+ if err := proto.Unmarshal(keyData.GetValue(), privKey); err != nil {
+ t.Fatalf("Unmarshal err = %v, want nil", err)
+ }
+ if privKey.GetVersion() != 0 {
+ t.Errorf("private key version = %d, want %d", privKey.GetVersion(), 0)
+ }
+ if len(privKey.GetPrivateKey()) == 0 {
+ t.Error("private key is missing")
+ }
+
+ pubKey := privKey.GetPublicKey()
+ if pubKey.GetVersion() != 0 {
+ t.Errorf("public key version = %d, want %d", pubKey.GetVersion(), 0)
+ }
+ if !cmp.Equal(pubKey.GetParams(), keyFormat.GetParams(), protocmp.Transform()) {
+ t.Errorf("key params = %v, want %v", pubKey.GetParams(), keyFormat.GetParams())
+ }
+ if len(pubKey.GetPublicKey()) == 0 {
+ t.Error("public key is missing")
+ }
+ }
+}
+
+func TestPrivateKeyManagerPublicKeyDataAcceptsNilKey(t *testing.T) {
+ k, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+ km, ok := k.(registry.PrivateKeyManager)
+ if !ok {
+ t.Errorf("primitive is not PrivateKeyManager")
+ }
+ if _, err := km.PublicKeyData(nil); err != nil {
+ t.Errorf("PublicKeyData() err = %v, want nil", err)
+ }
+}
+
+func TestPrivateKeyManagerPublicKeyData(t *testing.T) {
+ k, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+ km, ok := k.(registry.PrivateKeyManager)
+ if !ok {
+ t.Errorf("primitive is not PrivateKeyManager")
+ }
+
+ _, privKey := pubPrivKeys(t, validParams(t))
+ serializedPrivKey, err := proto.Marshal(privKey)
+ if err != nil {
+ t.Fatal(err)
+ }
+ wantPubKey := privKey.GetPublicKey()
+ serializedPubKey, err := proto.Marshal(wantPubKey)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ pubKey, err := km.PublicKeyData(serializedPrivKey)
+ if err != nil {
+ t.Fatalf("PublicKeyData() err = %v, want nil", err)
+ }
+ if got, want := pubKey.GetTypeUrl(), publicKeyTypeURL; got != want {
+ t.Errorf("type URL = %q, want %q", got, want)
+ }
+ if !bytes.Equal(pubKey.GetValue(), serializedPubKey) {
+ t.Errorf("value = %v, want %v", pubKey.GetValue(), serializedPubKey)
+ }
+ if got, want := pubKey.GetKeyMaterialType(), tinkpb.KeyData_ASYMMETRIC_PUBLIC; got != want {
+ t.Errorf("Key material type = %d, want %d", got, want)
+ }
+}
+
+func TestPrivateKeyManagerDoesSupport(t *testing.T) {
+ km, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+ if !km.DoesSupport(privateKeyTypeURL) {
+ t.Errorf("DoesSupport(%q) = false, want true", privateKeyTypeURL)
+ }
+ unsupportedKeyTypeURL := "unsupported.key.type"
+ if km.DoesSupport(unsupportedKeyTypeURL) {
+ t.Errorf("DoesSupport(%q) = true, want false", unsupportedKeyTypeURL)
+ }
+}
+
+func TestPrivateKeyManagerTypeURL(t *testing.T) {
+ km, err := registry.GetKeyManager(privateKeyTypeURL)
+ if err != nil {
+ t.Fatalf("GetKeyManager(%q) err = %v, want nil", privateKeyTypeURL, err)
+ }
+ if km.TypeURL() != privateKeyTypeURL {
+ t.Errorf("TypeURL = %q, want %q", km.TypeURL(), privateKeyTypeURL)
+ }
+}
diff --git a/go/hybrid/hpke/public_key_manager.go b/go/hybrid/hpke/public_key_manager.go
index 5f2f180..b121845 100644
--- a/go/hybrid/hpke/public_key_manager.go
+++ b/go/hybrid/hpke/public_key_manager.go
@@ -27,8 +27,10 @@
)
const (
- publicKeyKeyVersion uint32 = 0
- publicKeyTypeURL = "type.googleapis.com/google.crypto.tink.HpkePublicKey"
+ // maxSupportedPublicKeyVersion is the max supported public key version. It
+ // must be incremented when support for new versions are implemented.
+ maxSupportedPublicKeyVersion = 0
+ publicKeyTypeURL = "type.googleapis.com/google.crypto.tink.HpkePublicKey"
)
var (
@@ -49,7 +51,7 @@
if err := proto.Unmarshal(serializedKey, key); err != nil {
return nil, errInvalidPublicKey
}
- if err := keyset.ValidateKeyVersion(key.GetVersion(), publicKeyKeyVersion); err != nil {
+ if err := keyset.ValidateKeyVersion(key.GetVersion(), maxSupportedPublicKeyVersion); err != nil {
return nil, err
}
return newEncrypt(key)
diff --git a/go/hybrid/hpke/public_key_manager_test.go b/go/hybrid/hpke/public_key_manager_test.go
index 132c2b3..e0b55a2 100644
--- a/go/hybrid/hpke/public_key_manager_test.go
+++ b/go/hybrid/hpke/public_key_manager_test.go
@@ -23,98 +23,88 @@
"google.golang.org/protobuf/proto"
"github.com/google/tink/go/core/registry"
"github.com/google/tink/go/subtle/random"
- pb "github.com/google/tink/go/proto/hpke_go_proto"
+ hpkepb "github.com/google/tink/go/proto/hpke_go_proto"
)
-func TestPublicKeyManagerPrimitiveInvalidKeyVersion(t *testing.T) {
+func TestPublicKeyManagerPrimitiveRejectsInvalidKeyVersion(t *testing.T) {
km, err := registry.GetKeyManager(publicKeyTypeURL)
if err != nil {
t.Fatalf("GetKeyManager(%q) err = %v, want nil", publicKeyTypeURL, err)
}
pubKey, _ := pubPrivKeys(t, validParams(t))
- pubKey.Version = publicKeyKeyVersion + 1
- invalidPubKey, err := proto.Marshal(pubKey)
+ pubKey.Version = 1
+ serializedPubKey, err := proto.Marshal(pubKey)
if err != nil {
t.Fatal(err)
}
- if _, err := km.Primitive(invalidPubKey); err == nil {
- t.Error("Primitive(invalidPubKey) err = nil, want error")
+ if _, err := km.Primitive(serializedPubKey); err == nil {
+ t.Error("Primitive() err = nil, want error")
}
}
-func TestPublicKeyManagerPrimitiveUnknownKEM(t *testing.T) {
+func TestPublicKeyManagerPrimitiveRejectsInvalidParams(t *testing.T) {
km, err := registry.GetKeyManager(publicKeyTypeURL)
if err != nil {
t.Fatalf("GetKeyManager(%q) err = %v, want nil", publicKeyTypeURL, err)
}
- params := validParams(t)
- params.Kem = pb.HpkeKem_KEM_UNKNOWN
- pubKey, _ := pubPrivKeys(t, params)
- invalidPubKey, err := proto.Marshal(pubKey)
- if err != nil {
- t.Fatal(err)
+
+ tests := []struct {
+ name string
+ params *hpkepb.HpkeParams
+ }{
+ {"kem", &hpkepb.HpkeParams{
+ Kem: hpkepb.HpkeKem_KEM_UNKNOWN,
+ Kdf: hpkepb.HpkeKdf_HKDF_SHA256,
+ Aead: hpkepb.HpkeAead_AES_256_GCM,
+ }},
+ {"kdf", &hpkepb.HpkeParams{
+ Kem: hpkepb.HpkeKem_DHKEM_X25519_HKDF_SHA256,
+ Kdf: hpkepb.HpkeKdf_KDF_UNKNOWN,
+ Aead: hpkepb.HpkeAead_AES_256_GCM,
+ }},
+ {"aead", &hpkepb.HpkeParams{
+ Kem: hpkepb.HpkeKem_DHKEM_X25519_HKDF_SHA256,
+ Kdf: hpkepb.HpkeKdf_HKDF_SHA256,
+ Aead: hpkepb.HpkeAead_AEAD_UNKNOWN,
+ }},
}
- if _, err := km.Primitive(invalidPubKey); err == nil {
- t.Error("Primitive(invalidPubKey) err = nil, want error")
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ pubKey, _ := pubPrivKeys(t, test.params)
+ serializedPubKey, err := proto.Marshal(pubKey)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if _, err := km.Primitive(serializedPubKey); err == nil {
+ t.Error("Primitive() err = nil, want error")
+ }
+ })
}
}
-func TestPublicKeyManagerPrimitiveUnknownKDF(t *testing.T) {
- km, err := registry.GetKeyManager(publicKeyTypeURL)
- if err != nil {
- t.Fatalf("GetKeyManager(%q) err = %v, want nil", publicKeyTypeURL, err)
- }
- params := validParams(t)
- params.Kdf = pb.HpkeKdf_KDF_UNKNOWN
- pubKey, _ := pubPrivKeys(t, params)
- invalidPubKey, err := proto.Marshal(pubKey)
- if err != nil {
- t.Fatal(err)
- }
- if _, err := km.Primitive(invalidPubKey); err == nil {
- t.Error("Primitive(invalidPubKey) err = nil, want error")
- }
-}
-
-func TestPublicKeyManagerPrimitiveUnknownAEAD(t *testing.T) {
- km, err := registry.GetKeyManager(publicKeyTypeURL)
- if err != nil {
- t.Fatalf("GetKeyManager(%q) err = %v, want nil", publicKeyTypeURL, err)
- }
- params := validParams(t)
- params.Aead = pb.HpkeAead_AEAD_UNKNOWN
- pubKey, _ := pubPrivKeys(t, params)
- invalidPubKey, err := proto.Marshal(pubKey)
- if err != nil {
- t.Fatal(err)
- }
- if _, err := km.Primitive(invalidPubKey); err == nil {
- t.Error("Primitive(invalidPubKey) err = nil, want error")
- }
-}
-
-func TestPublicKeyManagerPrimitiveMissingParams(t *testing.T) {
+func TestPublicKeyManagerPrimitiveRejectsMissingParams(t *testing.T) {
km, err := registry.GetKeyManager(publicKeyTypeURL)
if err != nil {
t.Fatalf("GetKeyManager(%q) err = %v, want nil", publicKeyTypeURL, err)
}
pubKey, _ := pubPrivKeys(t, nil)
- invalidPubKey, err := proto.Marshal(pubKey)
+ serializedPubKey, err := proto.Marshal(pubKey)
if err != nil {
t.Fatal(err)
}
- if _, err := km.Primitive(invalidPubKey); err == nil {
- t.Error("Primitive(invalidPubKey) err = nil, want error")
+ if _, err := km.Primitive(serializedPubKey); err == nil {
+ t.Error("Primitive() err = nil, want error")
}
}
-func TestPublicKeyManagerPrimitiveNilKey(t *testing.T) {
+func TestPublicKeyManagerPrimitiveRejectsNilKey(t *testing.T) {
km, err := registry.GetKeyManager(publicKeyTypeURL)
if err != nil {
t.Fatalf("GetKeyManager(%q) err = %v, want nil", publicKeyTypeURL, err)
}
if _, err := km.Primitive(nil); err == nil {
- t.Error("Primitive(nil) err = nil, want error")
+ t.Error("Primitive() err = nil, want error")
}
}
@@ -127,11 +117,11 @@
wantPT := random.GetRandomBytes(200)
ctxInfo := random.GetRandomBytes(100)
- aeadIDs := []pb.HpkeAead{pb.HpkeAead_AES_128_GCM, pb.HpkeAead_AES_256_GCM}
+ aeadIDs := []hpkepb.HpkeAead{hpkepb.HpkeAead_AES_128_GCM, hpkepb.HpkeAead_AES_256_GCM}
for _, aeadID := range aeadIDs {
- params := &pb.HpkeParams{
- Kem: pb.HpkeKem_DHKEM_X25519_HKDF_SHA256,
- Kdf: pb.HpkeKdf_HKDF_SHA256,
+ params := &hpkepb.HpkeParams{
+ Kem: hpkepb.HpkeKem_DHKEM_X25519_HKDF_SHA256,
+ Kdf: hpkepb.HpkeKdf_HKDF_SHA256,
Aead: aeadID,
}
pubKey, privKey := pubPrivKeys(t, params)
@@ -142,7 +132,7 @@
e, err := km.Primitive(serializedPubKey)
if err != nil {
- t.Fatalf("Primitive(serializedPubKey) err = %v, want nil", err)
+ t.Fatalf("Primitive() err = %v, want nil", err)
}
enc, ok := e.(*Encrypt)
if !ok {
@@ -150,19 +140,19 @@
}
dec, err := newDecrypt(privKey)
if err != nil {
- t.Fatalf("newDecrypt(privKey) err = %v, want nil", err)
+ t.Fatalf("newDecrypt() err = %v, want nil", err)
}
ct, err := enc.Encrypt(wantPT, ctxInfo)
if err != nil {
- t.Fatalf("Encrypt(wantPT, ctxInfo) err = %v, want nil", err)
+ t.Fatalf("Encrypt() err = %v, want nil", err)
}
gotPT, err := dec.Decrypt(ct, ctxInfo)
if err != nil {
- t.Fatalf("Decrypt(ct, ctxInfo) err = %v, want nil", err)
+ t.Fatalf("Decrypt() err = %v, want nil", err)
}
if !bytes.Equal(gotPT, wantPT) {
- t.Errorf("Decrypt(gotPT, wantPT) = %x, want %x", gotPT, wantPT)
+ t.Errorf("Decrypt() = %x, want %x", gotPT, wantPT)
}
}
}
@@ -197,9 +187,9 @@
t.Fatalf("GetKeyManager(%q) err = %v, want nil", publicKeyTypeURL, err)
}
if _, err := km.NewKey(nil); err != errNotSupported {
- t.Fatalf("NewKey(nil) err = %v, want %v", err, errNotSupported)
+ t.Fatalf("NewKey() err = %v, want %v", err, errNotSupported)
}
if _, err := km.NewKeyData(nil); err != errNotSupported {
- t.Fatalf("NewKeyData(nil) err = %v, want %v", err, errNotSupported)
+ t.Fatalf("NewKeyData() err = %v, want %v", err, errNotSupported)
}
}
diff --git a/go/mac/mac_factory.go b/go/mac/mac_factory.go
index 668ccc0..18cef4a 100644
--- a/go/mac/mac_factory.go
+++ b/go/mac/mac_factory.go
@@ -82,7 +82,7 @@
}
if m.ps.Primary.PrefixType == tinkpb.OutputPrefixType_LEGACY {
d := data
- if len(d) == maxInt {
+ if len(d) >= maxInt {
return nil, fmt.Errorf("mac_factory: data too long")
}
data = make([]byte, 0, len(d)+1)
@@ -121,7 +121,7 @@
}
if entry.PrefixType == tinkpb.OutputPrefixType_LEGACY {
d := data
- if len(d) == maxInt {
+ if len(d) >= maxInt {
return fmt.Errorf("mac_factory: data too long")
}
data = make([]byte, 0, len(d)+1)
diff --git a/java_src/src/main/java/com/google/crypto/tink/KeyManager.java b/java_src/src/main/java/com/google/crypto/tink/KeyManager.java
index a561a2b..c664117 100644
--- a/java_src/src/main/java/com/google/crypto/tink/KeyManager.java
+++ b/java_src/src/main/java/com/google/crypto/tink/KeyManager.java
@@ -41,6 +41,10 @@
* Constructs an instance of P for the key given in {@code serializedKey}, which must be a
* serialized key protocol buffer handled by this manager.
*
+ * <p>For primitives of type {@code Mac}, {@code Aead}, {@code PublicKeySign}, {@code
+ * PublicKeyVerify}, {@code DeterministicAead}, {@code HybridEncrypt}, and {@code HybridDecrypt}
+ * this should be a primitive which <b>ignores</b> the output prefix and assumes "RAW".
+ *
* @return the new constructed P
* @throws GeneralSecurityException if the key given in {@code serializedKey} is corrupted or not
* supported
@@ -50,6 +54,10 @@
/**
* Constructs an instance of P for the key given in {@code key}.
*
+ * <p>For primitives of type {@code Mac}, {@code Aead}, {@code PublicKeySign}, {@code
+ * PublicKeyVerify}, {@code DeterministicAead}, {@code HybridEncrypt}, and {@code HybridDecrypt}
+ * this should be a primitive which <b>ignores</b> the output prefix and assumes "RAW".
+ *
* @return the new constructed P
* @throws GeneralSecurityException if the key given in {@code key} is corrupted or not supported
*/
diff --git a/java_src/src/main/java/com/google/crypto/tink/KeysetHandle.java b/java_src/src/main/java/com/google/crypto/tink/KeysetHandle.java
index 4b6cc4b..6ab0163 100644
--- a/java_src/src/main/java/com/google/crypto/tink/KeysetHandle.java
+++ b/java_src/src/main/java/com/google/crypto/tink/KeysetHandle.java
@@ -354,7 +354,7 @@
*
* @throws GeneralSecurityException
*/
- public static void assertEnoughKeyMaterial(Keyset keyset) throws GeneralSecurityException {
+ private static void assertEnoughKeyMaterial(Keyset keyset) throws GeneralSecurityException {
if (keyset == null || keyset.getKeyCount() <= 0) {
throw new GeneralSecurityException("empty keyset");
}
@@ -365,7 +365,7 @@
*
* @throws GeneralSecurityException
*/
- public static void assertEnoughEncryptedKeyMaterial(EncryptedKeyset keyset)
+ private static void assertEnoughEncryptedKeyMaterial(EncryptedKeyset keyset)
throws GeneralSecurityException {
if (keyset == null || keyset.getEncryptedKeyset().size() == 0) {
throw new GeneralSecurityException("empty keyset");
diff --git a/java_src/src/main/java/com/google/crypto/tink/PrimitiveSet.java b/java_src/src/main/java/com/google/crypto/tink/PrimitiveSet.java
index e5ba18d..e4e615e 100644
--- a/java_src/src/main/java/com/google/crypto/tink/PrimitiveSet.java
+++ b/java_src/src/main/java/com/google/crypto/tink/PrimitiveSet.java
@@ -79,6 +79,13 @@
this.keyId = keyId;
}
+ /**
+ * Returns the primitive for this entry.
+ *
+ * <p>For primitives of type {@code Mac}, {@code Aead}, {@code PublicKeySign}, {@code
+ * PublicKeyVerify}, {@code DeterministicAead}, {@code HybridEncrypt}, and {@code HybridDecrypt}
+ * this is a primitive which <b>ignores</b> the output prefix and assumes "RAW".
+ */
public P getPrimitive() {
return this.primitive;
}
diff --git a/java_src/src/main/java/com/google/crypto/tink/internal/KeyTypeManager.java b/java_src/src/main/java/com/google/crypto/tink/internal/KeyTypeManager.java
index d95164c..269bb92 100644
--- a/java_src/src/main/java/com/google/crypto/tink/internal/KeyTypeManager.java
+++ b/java_src/src/main/java/com/google/crypto/tink/internal/KeyTypeManager.java
@@ -71,7 +71,13 @@
return clazz;
}
- /** Creates a new instance of {@code PrimitiveT}. */
+ /**
+ * Creates a new instance of {@code PrimitiveT}.
+ *
+ * <p>For primitives of type {@code Mac}, {@code Aead}, {@code PublicKeySign}, {@code
+ * PublicKeyVerify}, {@code DeterministicAead}, {@code HybridEncrypt}, and {@code HybridDecrypt}
+ * this should be a primitive which <b>ignores</b> the output prefix and assumes "RAW".
+ */
public abstract PrimitiveT getPrimitive(KeyT key) throws GeneralSecurityException;
}
diff --git a/kokoro/gcp_ubuntu_per_language/apps/run_tests.sh b/kokoro/gcp_ubuntu_per_language/apps/run_tests.sh
index be8d523..58d89e5 100644
--- a/kokoro/gcp_ubuntu_per_language/apps/run_tests.sh
+++ b/kokoro/gcp_ubuntu_per_language/apps/run_tests.sh
@@ -24,4 +24,4 @@
cd apps
use_bazel.sh $(cat .bazelversion)
time bazel build -- ...
-time bazel test -- ...
+time bazel test --test_output="errors" -- ...
diff --git a/kokoro/macos_external/apps/run_tests.sh b/kokoro/macos_external/apps/run_tests.sh
index 410e7b9..3aecea9 100644
--- a/kokoro/macos_external/apps/run_tests.sh
+++ b/kokoro/macos_external/apps/run_tests.sh
@@ -31,4 +31,4 @@
cd apps
use_bazel.sh $(cat .bazelversion)
time bazel build -- ...
-time bazel test -- ...
+time bazel test --test_output="errors" -- ...
diff --git a/kokoro/macos_external/cc/bazel/run_tests.sh b/kokoro/macos_external/cc/bazel/run_tests.sh
index 438ea6d..68162fb 100644
--- a/kokoro/macos_external/cc/bazel/run_tests.sh
+++ b/kokoro/macos_external/cc/bazel/run_tests.sh
@@ -24,4 +24,4 @@
cd cc
use_bazel.sh $(cat .bazelversion)
bazel build -- ...
-bazel test -- ...
+bazel test --test_output="errors" -- ...
diff --git a/kokoro/macos_external/objc/run_tests.sh b/kokoro/macos_external/objc/run_tests.sh
index baa8e29..8eb16fe 100644
--- a/kokoro/macos_external/objc/run_tests.sh
+++ b/kokoro/macos_external/objc/run_tests.sh
@@ -24,4 +24,4 @@
## TODO(b/155060426) Reenable once the tests work.
# use_bazel.sh $(cat .bazelversion)
# time bazel build -- ...
-# time bazel test -- ...
+# time bazel test --test_output="errors" -- ...
