// Copyright 2017 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.
//
///////////////////////////////////////////////////////////////////////////////

#include "tink/hybrid/ecies_aead_hkdf_hybrid_decrypt.h"

#include <string>
#include <utility>

#include "gtest/gtest.h"
#include "absl/memory/memory.h"
#include "tink/aead/aes_ctr_hmac_aead_key_manager.h"
#include "tink/aead/aes_gcm_key_manager.h"
#include "tink/aead/xchacha20_poly1305_key_manager.h"
#include "tink/daead/aes_siv_key_manager.h"
#include "tink/hybrid/ecies_aead_hkdf_hybrid_encrypt.h"
#include "tink/hybrid_decrypt.h"
#include "tink/internal/ec_util.h"
#include "tink/internal/ssl_util.h"
#include "tink/registry.h"
#include "tink/subtle/random.h"
#include "tink/util/enums.h"
#include "tink/util/statusor.h"
#include "tink/util/test_matchers.h"
#include "tink/util/test_util.h"
#include "proto/aes_gcm.pb.h"
#include "proto/common.pb.h"
#include "proto/ecies_aead_hkdf.pb.h"

using crypto::tink::subtle::Random;
using ::crypto::tink::test::IsOkAndHolds;
using google::crypto::tink::EciesAeadHkdfPrivateKey;
using google::crypto::tink::EcPointFormat;
using google::crypto::tink::EllipticCurveType;
using google::crypto::tink::HashType;
using ::testing::Eq;

namespace crypto {
namespace tink {
namespace {

class EciesAeadHkdfHybridDecryptTest : public ::testing::Test {
 protected:
  void SetUp() override {}
  void TearDown() override {}

  struct CommonHybridKeyParams {
    EllipticCurveType ec_curve;
    EcPointFormat ec_point_format;
    HashType hash_type;
  };

  std::vector<CommonHybridKeyParams> GetCommonHybridKeyParamsList() {
    std::vector<CommonHybridKeyParams> params_list;
    for (auto ec_curve :
         {EllipticCurveType::NIST_P256, EllipticCurveType::NIST_P384,
          EllipticCurveType::NIST_P521, EllipticCurveType::CURVE25519}) {
      for (auto ec_point_format :
           {EcPointFormat::UNCOMPRESSED, EcPointFormat::COMPRESSED}) {
        if (ec_curve == EllipticCurveType::CURVE25519 &&
            ec_point_format == EcPointFormat::UNCOMPRESSED) {
          continue;
        }
        for (auto hash_type : {HashType::SHA256, HashType::SHA512}) {
          CommonHybridKeyParams params;
          params.ec_curve = ec_curve;
          params.ec_point_format = ec_point_format;
          params.hash_type = hash_type;
          params_list.push_back(params);
        }
      }
    }
    return params_list;
  }

  EciesAeadHkdfPrivateKey GetEciesPrivateKeyFromHexString(
      absl::string_view private_key_hex_string,
      CommonHybridKeyParams& key_params) {
    auto ecies_key = test::GetEciesAesSivHkdfTestKey(
        key_params.ec_curve, key_params.ec_point_format, key_params.hash_type);
    ecies_key.set_key_value(test::HexDecodeOrDie(private_key_hex_string));
    return ecies_key;
  }

  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.value()));

    std::unique_ptr<HybridEncrypt> hybrid_encrypt(std::move(
        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).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.value());
      }
      {  // Encryption and decryption with empty context info.
        const absl::string_view empty_context_info;
        auto ciphertext =
            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.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)
                .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.value());
      }
      {  // Short bad ciphertext.
        auto decrypt_result =
            hybrid_decrypt->Decrypt(Random::GetRandomBytes(16), context_info);
        EXPECT_FALSE(decrypt_result.ok());
        EXPECT_EQ(absl::StatusCode::kInvalidArgument,
                  decrypt_result.status().code());
        EXPECT_PRED_FORMAT2(testing::IsSubstring, "ciphertext too short",
                            std::string(decrypt_result.status().message()));
      }
      {  // Long but still bad ciphertext.
        auto decrypt_result =
            hybrid_decrypt->Decrypt(Random::GetRandomBytes(142), context_info);
        EXPECT_FALSE(decrypt_result.ok());
        // TODO(przydatek): add more checks while avoiding flakiness.
      }
      {  // Bad context info
        auto decrypt_result =
            hybrid_decrypt->Decrypt(ciphertext, Random::GetRandomBytes(14));
        EXPECT_FALSE(decrypt_result.ok());
      }
    }
  }
};

TEST_F(EciesAeadHkdfHybridDecryptTest, testInvalidKeys) {
  {  // No fields set.
    EciesAeadHkdfPrivateKey recipient_key;
    auto result = EciesAeadHkdfHybridDecrypt::New(recipient_key);
    EXPECT_FALSE(result.ok());
    EXPECT_EQ(absl::StatusCode::kInvalidArgument, result.status().code());
    EXPECT_PRED_FORMAT2(testing::IsSubstring, "missing required fields",
                        std::string(result.status().message()));
  }

  {  // Only some fields set.
    EciesAeadHkdfPrivateKey recipient_key;
    recipient_key.set_version(0);
    recipient_key.mutable_public_key()->set_x("some x bytes");
    recipient_key.mutable_public_key()->set_y("some y bytes");
    auto result(EciesAeadHkdfHybridDecrypt::New(recipient_key));
    EXPECT_FALSE(result.ok());
    EXPECT_EQ(absl::StatusCode::kInvalidArgument, result.status().code());
    EXPECT_PRED_FORMAT2(testing::IsSubstring, "missing required fields",
                        std::string(result.status().message()));
  }

  {  // Wrong EC type.
    EciesAeadHkdfPrivateKey recipient_key;
    recipient_key.set_version(0);
    recipient_key.set_key_value("some key value bytes");
    recipient_key.mutable_public_key()->set_x("some x bytes");
    recipient_key.mutable_public_key()->set_y("some y bytes");
    recipient_key.mutable_public_key()->mutable_params();
    auto result(EciesAeadHkdfHybridDecrypt::New(recipient_key));
    EXPECT_FALSE(result.ok());
    EXPECT_EQ(absl::StatusCode::kUnimplemented, result.status().code());
    EXPECT_PRED_FORMAT2(testing::IsSubstring, "Unsupported elliptic curve",
                        std::string(result.status().message()));
  }

  {  // Unsupported DEM key type.
    EllipticCurveType curve = EllipticCurveType::NIST_P256;
    auto test_key =
        internal::NewEcKey(util::Enums::ProtoToSubtle(curve)).value();
    EciesAeadHkdfPrivateKey recipient_key;
    recipient_key.set_version(0);
    recipient_key.set_key_value("some key value bytes");
    recipient_key.mutable_public_key()->set_x(test_key.pub_x);
    recipient_key.mutable_public_key()->set_y(test_key.pub_y);
    auto params = recipient_key.mutable_public_key()->mutable_params();
    params->mutable_kem_params()->set_curve_type(curve);
    params->mutable_kem_params()->set_hkdf_hash_type(HashType::SHA256);
    auto aead_dem = params->mutable_dem_params()->mutable_aead_dem();
    aead_dem->set_type_url("some.type.url/that.is.not.supported");
    auto result(EciesAeadHkdfHybridDecrypt::New(recipient_key));
    EXPECT_FALSE(result.ok());
    EXPECT_EQ(absl::StatusCode::kInvalidArgument, result.status().code());
    EXPECT_PRED_FORMAT2(testing::IsSubstring, "Unsupported DEM",
                        std::string(result.status().message()));
  }
}

TEST_F(EciesAeadHkdfHybridDecryptTest, testGettingHybridEncryptWithoutManager) {
  // Prepare an ECIES key.
  Registry::Reset();
  auto ecies_key = test::GetEciesAesGcmHkdfTestKey(EllipticCurveType::NIST_P256,
                                                   EcPointFormat::UNCOMPRESSED,
                                                   HashType::SHA256, 32);

  // Try to get a HybridEncrypt primitive without DEM key manager.
  auto bad_result(EciesAeadHkdfHybridDecrypt::New(ecies_key));
  EXPECT_FALSE(bad_result.ok());
  EXPECT_EQ(absl::StatusCode::kFailedPrecondition, bad_result.status().code());
  EXPECT_PRED_FORMAT2(testing::IsSubstring, "No manager for DEM",
                      std::string(bad_result.status().message()));
}

TEST_F(EciesAeadHkdfHybridDecryptTest, testAesGcmHybridDecryption) {
  // Register DEM key manager.
  std::string dem_key_type = AesGcmKeyManager().get_key_type();
  ASSERT_TRUE(Registry::RegisterKeyTypeManager(
                  absl::make_unique<AesGcmKeyManager>(), true)
                  .ok());

  int i = 0;
  // Generate and test many keys with various parameters.
  for (auto key_params : GetCommonHybridKeyParamsList()) {
    for (uint32_t aes_gcm_key_size : {16, 32}) {
      ++i;
      auto ecies_key = test::GetEciesAesGcmHkdfTestKey(
          key_params.ec_curve, key_params.ec_point_format, key_params.hash_type,
          aes_gcm_key_size);
      TestValidKey(ecies_key);
    }
  }
  EXPECT_EQ(i, 32 - 4);
}

TEST_F(EciesAeadHkdfHybridDecryptTest, testAesCtrAeadHybridDecryption) {
  // Register DEM key manager.
  std::string dem_key_type = AesCtrHmacAeadKeyManager().get_key_type();
  ASSERT_TRUE(Registry::RegisterKeyTypeManager(
                  absl::make_unique<AesCtrHmacAeadKeyManager>(), true)
                  .ok());

  uint32_t aes_ctr_iv_size = 16;
  // Generate and test many keys with various parameters.
  for (auto key_params : GetCommonHybridKeyParamsList()) {
    for (uint32_t aes_ctr_key_size : {16, 32}) {
      for (auto hmac_hash_type : {HashType::SHA256, HashType::SHA512}) {
        for (uint32_t hmac_tag_size : {16, 32}) {
          for (uint32_t hmac_key_size : {16, 32}) {
            auto ecies_key = test::GetEciesAesCtrHmacHkdfTestKey(
                key_params.ec_curve, key_params.ec_point_format,
                key_params.hash_type, aes_ctr_key_size, aes_ctr_iv_size,
                hmac_hash_type, hmac_tag_size, hmac_key_size);
            TestValidKey(ecies_key);
          }
        }
      }
    }
  }
}

TEST_F(EciesAeadHkdfHybridDecryptTest, testXChaCha20Poly1305HybridDecryption) {
  if (!internal::IsBoringSsl()) {
    GTEST_SKIP() << "XChaCha20-Poly1305 is not supported when OpenSSL is used";
  }
  // Register DEM key manager.
  std::string dem_key_type = XChaCha20Poly1305KeyManager().get_key_type();
  ASSERT_TRUE(Registry::RegisterKeyTypeManager(
                  absl::make_unique<XChaCha20Poly1305KeyManager>(), true)
                  .ok());

  // Generate and test many keys with various parameters.
  for (auto key_params : GetCommonHybridKeyParamsList()) {
    auto ecies_key = test::GetEciesXChaCha20Poly1305HkdfTestKey(
        key_params.ec_curve, key_params.ec_point_format, key_params.hash_type);
    TestValidKey(ecies_key);
  }
}

TEST_F(EciesAeadHkdfHybridDecryptTest, testAesSivHybridDecryption) {
  // Register DEM key manager.
  std::string dem_key_type = AesSivKeyManager().get_key_type();
  ASSERT_TRUE(Registry::RegisterKeyTypeManager(
                  absl::make_unique<AesSivKeyManager>(), true)
                  .ok());

  // Generate and test many keys with various parameters.
  for (auto key_params : GetCommonHybridKeyParamsList()) {
    auto ecies_key = test::GetEciesAesSivHkdfTestKey(
        key_params.ec_curve, key_params.ec_point_format, key_params.hash_type);
    TestValidKey(ecies_key);
  }
}

struct TestVector {
  EciesAeadHkdfPrivateKey private_key;
  std::string ciphertext;
  std::string context_info;
  std::string plaintext;
};

TEST_F(EciesAeadHkdfHybridDecryptTest,
       testAesSivHybridDecryptionWithTestVectors) {
  // Register DEM key manager.
  std::string dem_key_type = AesSivKeyManager().get_key_type();
  ASSERT_TRUE(Registry::RegisterKeyTypeManager(
                  absl::make_unique<AesSivKeyManager>(), true)
                  .ok());

  CommonHybridKeyParams key_params = {EllipticCurveType::NIST_P256,
                                      EcPointFormat::UNCOMPRESSED,
                                      HashType::SHA256};
  TestVector hybrid_decryption_test_vectors[] = {
      {
          /*TEST 1*/
          /*private_key=*/
          GetEciesPrivateKeyFromHexString("32588172ed65830571bb83748f7fddd38332"
                                          "3208a7825c80a71bef846333eb02",
                                          key_params),
          /*ciphertext=*/
          test::HexDecodeOrDie(
              "0401b11f8c9bafe30ae13f8bd15528714e752631a4328bf146009068e99489c8"
              "e9fae1ec39e3fe9994723711417fcab2af4b3c9b60117d47d33d35175c87b483"
              "b8935a73312940d1fbf8da3944a89b5e8b"),
          /*context_info=*/
          "some context info",
          /*plaintext=*/"",
      },
      {
          /*TEST 2*/
          /*private_key=*/
          GetEciesPrivateKeyFromHexString("32588172ed65830571bb83748f7fddd38332"
                                          "3208a7825c80a71bef846333eb02",
                                          key_params),
          /*ciphertext=*/
          test::HexDecodeOrDie(
              "040230023d1547b55af5a735a7f460722612126d7539d7cd0f677d308b29c6f5"
              "2a964e66e7b0cb44cff1673df9e2c793f1477ca755807bfbeadcae1ab20b45ec"
              "b1501ca5e3f5b0626d3ca40aa5d010443d506e4df90b"),
          /*context_info=*/
          "some context info",
          /*plaintext=*/"hello",
      },
      {
          /*TEST 3*/
          /*private_key=*/
          GetEciesPrivateKeyFromHexString("32588172ed65830571bb83748f7fddd38332"
                                          "3208a7825c80a71bef846333eb02",
                                          key_params),
          /*ciphertext=*/
          test::HexDecodeOrDie(
              "0441ddd246cea0825bd68bddff05cec54a4ee678da35b2f5cfbbb32e5350bdd8"
              "17214bfb7b5ed5528131bde56916062cfbd8b9952d9e0907a6e87e1de54db5df"
              "3aaccddd328efcf7771ce061e647488f66b8c11a9fca171dcff813e90b44b273"
              "9573f9f23b60202491870c7ff8aaf0ae46838e48f17f8dc1ad55b67809699dd3"
              "1eb6ca50dfa9beeee32d30bdc00a1eb1d8b0cbcedbe50b1e24619cc5e79042f2"
              "5f49e2c2d5a35c79e833c0d68e31a93da4173aacd0428b367594ed4636763d16"
              "c23e4f8c115d44bddc83bcefcaea13587238ce8b7a5d5fad53beeb59aaa1d748"
              "3eb4bac93ed50ed4d3e9fd5af760283fd38080b58744b73212a36039179ce6f9"
              "6ef1ecaa05b5186967d81c06b9cd91140dfbd54084ddcfd941527719848a2eec"
              "b84278f6a0fe9357a3964f87222fcd16a12a353e1f64fd45dc227a4a2112da6f"
              "61269f22f16b41e68eadf0b6b3a48c67b9e7e3ec1c66eecce50dda8ecbce99d3"
              "778299aa28741b7247fbc46a1b8a908dc23943c2dd17210a270bb12b096c2c6a"
              "00400a95c62894a15b9fc44e709d27348f2f2644a786cd9e96caf42ea9b949f7"
              "6e85e6f7365e15fa2902e851222c025f6c208269d799fcfc4c0b37aba8979ed9"
              "e6ccf543c217ee0b6ad05f0e3ffb92943d308c801b25efedab5bf93a733bdae6"
              "11132d774d4b9ee4fb5e88ae63014315ae9571039a8c8c7020e2b3a1bbd4235b"
              "65af94771c8417c87fd6cab423b82a557f60a99ae7402dba205e05136dd34f00"
              "26fce87899d4b9819cc2b2ba686512d62c41a1e3a667a705ea45404aafa489cd"
              "7f53f42455fff3f9b22f960d12a2587efd6ed0fa3e00dd4645face1b2f1268e6"
              "019be70999eab00f0aeff3cb0e77b7c4a1ab1fdf15d00c4eedd7b75e8cf5c901"
              "19346894089ee0299d58f1d7ebac9b592da2325a5a738ea2baecc1468670f5ae"
              "c880bce32efecfb2a7c5ad3ae4096b0a07aa9bfe6cbaf53da6757377bb692e55"
              "ec8caf5f0af28dafdc42e1d6e5893140945a853f56652c575b99d64399aad2d0"
              "42948575134c8fe638fb0b80ac3a0f08a60f3aa817fe0a24c1fffee6933bd72e"
              "a460e0b241d3f5d98b2321ee25d8c0302353fcfd41bce964d73ff67042286450"
              "6cc56f3470362c90144586ccbfc8e5e6fefbb70429b0a517e4b1badb449cd110"
              "92790aba6e19b914899872f4fb481c8dc47a33422fc05072ac99c958e40dae53"
              "d96ebd87cfbde67a0f050203a89e487da5e03364951830e43771d36abfbe8f5a"
              "7da8e7aa891f36a68dbe9a3b0e3dfbd1afd6327a3ced4a5cd8a5b256fef46d20"
              "0df4af2e2da4dbb786ea0404bb968b6d961e4fc76f89e70ad7c9e11d6aee6526"
              "b75b399811f73c053a29582ba9295ea4d5a8fffb5a8ccbac008d291dd60e2041"
              "371acfc4c432a0ae0fcd8fa25c9551123c95da64caa134edaee5893e19c3c760"
              "75bef419c09681a67f4ede6f28d747b53afd61ddc937d7de96a22c7db10ad870"
              "0cade888de5d6f450c15d796978ddb5e6a52e5044e90247c988686d992105c85"
              "f6d198e2de859330f973ded4d7e5d90de57051dbaf0db0febd4cf9d44da155e5"
              "5293b0930f89c1d21cc227eba9615ca47cce41d16eaddb5bf5dc9bc8477df5cf"
              "21f460b83241e7d0fa3707f9d2b322b9aaa42747d0653168b095ca0a83f38426"
              "688f6f10143cbd1b84c08583b09ed6192c7366ecc23af528fc2e8c585560f9bd"
              "0fcc255b82fc70723a92506bb475ebc1f5ae34a902bf2aa75997ed90a54762c8"
              "e83720833b2fd607eee1beb347a75d3bd0f174ed450a72cce79f1be426de9d6f"
              "1a6feff052674af141b3cea89f8e749118392e9533c62ddad870e60d509fd7ab"
              "fa0bc33c2774b29a0170089b30d82047d6e130c49f6965f9871d1928b7f13e3e"
              "40ad8e3dc85195f4b312f9f6d8e4158aca23a611f6c6c798983555139942536f"
              "6ac59bbd6cc88b9933f22e81429e835bfd4fec27c67520d64a0ad8fd7feb6a3f"
              "be52dc56cbbf59644b0fad0c462ed02ffbf7258e4b94bdedefb187fbdb729a0d"
              "56a36e876ac76de766eed416f39ab4e8b1982b8d0a87cd33182ae81ecf1d1d52"
              "02cc3e82c5762646d15db5f13cde3e81c83715195f9af9f27e01e1829ce529fa"
              "0f715db1f5d227bb201c7c127ea8d0e9c21739c7e9c6a0d8d5a1aaea5216c549"
              "f3715f889e583555ac1bfd77339f3eff1bee75ee2fc45457f5c3ffe9401b8b67"
              "f5bb3f305f3269fe6153ba34de3fa90016c76811cd54b4b49b17b244b1a4f6ed"
              "fa2eaf46e2819aded26005b4ed712e8b700ae7b6123fa2c179640ee523f86436"
              "0d116ee243f13c66d2cd61d422709648d905ab17edf0d0075d2fed443889e153"
              "44069b69b2d3d8273f197f8468baf167074bf6dfdeea5871f0c0652ab2801f39"
              "4ef6fbf841e8072c8bf65026d85d441ca61e78785a2e7ca1e743640fecd6dfad"
              "8b77adcbb8bcb8ce8532ad0cd8b3e51269c26ad037545273f756c1a551192540"
              "8a5045af469ca947f9a3f5457bcc325d05291a192abe75b4da7c97a61adc2fa2"
              "47984edb5a03285f1c3b99f13f6a22f007029faffdd38b62f7bf909ce602e4e0"
              "6ab1ec4543013d354d0dd86d8933a53c17ead02faf0cc740d7191fe475be2f79"
              "40c234f8c73420774a7213fd2a477847527172c02a54928de5fde5f15616760e"
              "6f7ff3c03a233aec880a939d9f1ca68be7f474fd13184fe8f6deb0c4ea01617e"
              "a207d5d765d067fddba58b94f3b59d5996e9f5434f483e2f0079c48050f3ba94"
              "1b589294c41a0f350451d566fe58a9c9688cc3a75da314ff4b3473eeac58664c"
              "5922ae4efae850fe0f7f11dcc089bc0b4df9a64547a35b2559f4a4a3e7d3782d"
              "850997baa589534921becde8dc3f76380ae36bd9730956aae9f59b121d8ae4db"
              "bc586c6b45ad9d5c17cf6821b746177bc9fcb727db3f4aa190688c48826421de"
              "5ebcd429e0d9b479e66e676e8f9a3b4bd92621f47357a7b1b27942121f5a6e00"
              "87e4192a5f8cf4da942cc9d86eac5e"),
          /*context_info=*/
          "some context info",
          /*plaintext=*/
          "08b8b2b733424243760fe426a4b54908"
          "632110a66c2f6591eabd3345e3e4eb98"
          "fa6e264bf09efe12ee50f8f54e9f77b1"
          "e355f6c50544e23fb1433ddf73be84d8"
          "79de7c0046dc4996d9e773f4bc9efe57"
          "38829adb26c81b37c93a1b270b20329d"
          "658675fc6ea534e0810a4432826bf58c"
          "941efb65d57a338bbd2e26640f89ffbc"
          "1a858efcb8550ee3a5e1998bd177e93a"
          "7363c344fe6b199ee5d02e82d522c4fe"
          "ba15452f80288a821a579116ec6dad2b"
          "3b310da903401aa62100ab5d1a36553e"
          "06203b33890cc9b832f79ef80560ccb9"
          "a39ce767967ed628c6ad573cb116dbef"
          "efd75499da96bd68a8a97b928a8bbc10"
          "3b6621fcde2beca1231d206be6cd9ec7"
          "aff6f6c94fcd7204ed3455c68c83f4a4"
          "1da4af2b74ef5c53f1d8ac70bdcb7ed1"
          "85ce81bd84359d44254d95629e9855a9"
          "4a7c1958d1f8ada5d0532ed8a5aa3fb2"
          "d17ba70eb6248e594e1a2297acbbb39d"
          "502f1a8c6eb6f1ce22b3de1a1f40cc24"
          "554119a831a9aad6079cad88425de6bd"
          "e1a9187ebb6092cf67bf2b13fd65f270"
          "88d78b7e883c8759d2c4f5c65adb7553"
          "878ad575f9fad878e80a0c9ba63bcbcc"
          "2732e69485bbc9c90bfbd62481d9089b"
          "eccf80cfe2df16a2cf65bd92dd597b07"
          "07e0917af48bbb75fed413d238f5555a"
          "7a569d80c3414a8d0859dc65a46128ba"
          "b27af87a71314f318c782b23ebfe808b"
          "82b0ce26401d2e22f04d83d1255dc51a"
          "ddd3b75a2b1ae0784504df543af8969b"
          "e3ea7082ff7fc9888c144da2af58429e"
          "c96031dbcad3dad9af0dcbaaaf268cb8"
          "fcffead94f3c7ca495e056a9b47acdb7"
          "51fb73e666c6c655ade8297297d07ad1"
          "ba5e43f1bca32301651339e22904cc8c"
          "42f58c30c04aafdb038dda0847dd988d"
          "cda6f3bfd15c4b4c4525004aa06eeff8"
          "ca61783aacec57fb3d1f92b0fe2fd1a8"
          "5f6724517b65e614ad6808d6f6ee34df"
          "f7310fdc82aebfd904b01e1dc54b2927"
          "094b2db68d6f903b68401adebf5a7e08"
          "d78ff4ef5d63653a65040cf9bfd4aca7"
          "984a74d37145986780fc0b16ac451649"
          "de6188a7dbdf191f64b5fc5e2ab47b57"
          "f7f7276cd419c17a3ca8e1b939ae49e4"
          "88acba6b965610b5480109c8b17b80e1"
          "b7b750dfc7598d5d5011fd2dcc5600a3"
          "2ef5b52a1ecc820e308aa342721aac09"
          "43bf6686b64b2579376504ccc493d97e"
          "6aed3fb0f9cd71a43dd497f01f17c0e2"
          "cb3797aa2a2f256656168e6c496afc5f"
          "b93246f6b1116398a346f1a641f3b041"
          "e989f7914f90cc2c7fff357876e506b5"
          "0d334ba77c225bc307ba537152f3f161"
          "0e4eafe595f6d9d90d11faa933a15ef1"
          "369546868a7f3a45a96768d40fd9d034"
          "12c091c6315cf4fde7cb68606937380d"
          "b2eaaa707b4c4185c32eddcdd306705e"
          "4dc1ffc872eeee475a64dfac86aba41c"
          "0618983f8741c5ef68d3a101e8a3b8ca"
          "c60c905c15fc910840b94c00a0b9d0",
      }};

  for (const TestVector& test_vector : hybrid_decryption_test_vectors) {
    std::unique_ptr<HybridDecrypt> hybrid_decrypt =
        EciesAeadHkdfHybridDecrypt::New(test_vector.private_key).value();
    EXPECT_THAT(hybrid_decrypt->Decrypt(test_vector.ciphertext,
                                        test_vector.context_info),
                IsOkAndHolds(Eq(test_vector.plaintext)));
  }
}

}  // namespace
}  // namespace tink
}  // namespace crypto