Change crypto::tink::util::StatusOr::ValueOrDie() to value() in /tink/cc. Part of Tink migration to absl::Status{,Or}.

PiperOrigin-RevId: 436169510

5 files changed, 29 insertions, 31 deletions

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 9ca040c07..c1ac5333f 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 @@ util::StatusOr<std::unique_ptr<HybridDecrypt>> Cecpq2AeadHkdfHybridDecrypt::New(
   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<std::string> Cecpq2AeadHkdfHybridDecrypt::Decrypt(
   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::StatusOr<std::string> Cecpq2AeadHkdfHybridDecrypt::Decrypt(
           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 2b6e338ff..bd21b4739 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 @@ class Cecpq2AeadHkdfHybridDecryptTest : public ::testing::Test {
     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 @@ class Cecpq2AeadHkdfHybridDecryptTest : public ::testing::Test {
       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 @@ class Cecpq2AeadHkdfHybridDecryptTest : public ::testing::Test {
       {  // 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 @@ class Cecpq2AeadHkdfHybridDecryptTest : public ::testing::Test {
         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 @@ google::crypto::tink::Cecpq2AeadHkdfPrivateKey CreateValidKey() {
 
   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 @@ TEST_F(Cecpq2AeadHkdfHybridDecryptTest, AesGcmHybridDecryption) {
                                 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 @@ TEST_F(Cecpq2AeadHkdfHybridDecryptTest, XChaCha20Poly1305HybridDecryption) {
                               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 @@ TEST_F(Cecpq2AeadHkdfHybridDecryptTest, AesSivHybridDecryption) {
   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 6ccc76a45..f66d5b4c1 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 @@ util::StatusOr<std::unique_ptr<HybridEncrypt>> Cecpq2AeadHkdfHybridEncrypt::New(
   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<std::string> Cecpq2AeadHkdfHybridEncrypt::Encrypt(
   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 @@ util::StatusOr<std::string> Cecpq2AeadHkdfHybridEncrypt::Encrypt(
               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 @@ util::StatusOr<std::string> Cecpq2AeadHkdfHybridEncrypt::Encrypt(
           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 @@ util::StatusOr<std::string> Cecpq2AeadHkdfHybridEncrypt::Encrypt(
 
   // 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 e6fde6fb3..418eee6d3 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 @@ namespace {
 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 @@ TEST(Cecpq2AeadHkdfHybridEncryptTest, InvalidKeyUnsupportedDemKeyType) {
   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 @@ TEST(Cecpq2AeadHkdfHybridEncryptTest, Basic) {
           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/util/test_util.cc b/cc/experimental/pqcrypto/cecpq2/util/test_util.cc
index 4217f5a96..dc1e014df 100644
--- a/cc/experimental/pqcrypto/cecpq2/util/test_util.cc
+++ b/cc/experimental/pqcrypto/cecpq2/util/test_util.cc
@@ -45,7 +45,7 @@ google::crypto::tink::Cecpq2AeadHkdfPrivateKey GetCecpq2AeadHkdfTestKey(
 
   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 *>(