// Copyright 2022 Google LLC. All Rights Reserved. This file and proprietary
// source code may only be used and distributed under the Widevine License
// Agreement.
//
//  Reference implementation utilities of OEMCrypto APIs
//
#include <ostream>

#include <gtest/gtest.h>

#include "hmac.h"
#include "string_conversions.h"

namespace wvoec {
namespace util {
namespace {
struct HmacTestVector {
  std::vector<uint8_t> key;
  std::vector<uint8_t> message;
  std::vector<uint8_t> signature;
  std::vector<uint8_t> signature_sha1;
};

void PrintTo(const HmacTestVector& v, std::ostream* os) {
  constexpr size_t kMaxSize = 32;
  *os << "{";
  if (v.key.size() > kMaxSize) {
    std::vector<uint8_t> short_short(v.key.begin(), v.key.begin() + kMaxSize);
    *os << "key = " << wvutil::b2a_hex(short_short);
    *os << "... (size = " << std::to_string(v.key.size()) << "), ";
  } else {
    *os << "key = " << wvutil::b2a_hex(v.key) << ", ";
  }
  if (v.message.size() > kMaxSize) {
    std::vector<uint8_t> short_message(v.message.begin(),
                                       v.message.begin() + kMaxSize);
    *os << "message = " << wvutil::b2a_hex(short_message);
    *os << "... (size = " << std::to_string(v.message.size()) << "), ";
  } else {
    *os << "message = " << wvutil::b2a_hex(v.message) << ", ";
  }
  *os << "signature = " << wvutil::b2a_hex(v.signature) << ", ";
  *os << "signature_sha1 = " << wvutil::b2a_hex(v.signature_sha1) << "}";
}

std::vector<uint8_t> FromString(const std::string& s) {
  return std::vector<uint8_t>(s.begin(), s.end());
}

// Test vectors come from RFC4231 Section 4 (test case 5 is omitted).
const HmacTestVector kHmacTestVectorList[] = {
    {/* key = */ wvutil::a2b_hex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"),
     /* message = */ FromString("Hi There"),
     /* signature = */
     wvutil::a2b_hex(
         "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7"),
     /* signature_sha1 = */
     wvutil::a2b_hex("b617318655057264e28bc0b6fb378c8ef146be00")},
    {/* key = */ FromString("Jefe"),
     /* message = */ FromString("what do ya want for nothing?"),
     /* signature = */
     wvutil::a2b_hex(
         "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843"),
     /* signature_sha1 = */
     wvutil::a2b_hex("effcdf6ae5eb2fa2d27416d5f184df9c259a7c79")},
    {/* key = */ std::vector<uint8_t>(20, 0xaa),
     /* message = */ std::vector<uint8_t>(50, 0xdd),
     /* signature = */
     wvutil::a2b_hex(
         "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe"),
     /* signature_sha1 = */
     wvutil::a2b_hex("125d7342b9ac11cd91a39af48aa17b4f63f175d3")},
    {/* key = */ wvutil::a2b_hex(
         "0102030405060708090a0b0c0d0e0f10111213141516171819"),
     /* message = */ std::vector<uint8_t>(50, 0xcd),
     /* signature = */
     wvutil::a2b_hex(
         "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b"),
     /* signature_sha1 = */
     wvutil::a2b_hex("4c9007f4026250c6bc8414f9bf50c86c2d7235da")},
    {/* key = */ std::vector<uint8_t>(131, 0xaa),
     /* message = */
     FromString("Test Using Larger Than Block-Size Key - Hash Key First"),
     /* signature = */
     wvutil::a2b_hex(
         "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54"),
     /* signature_sha1 = */
     wvutil::a2b_hex("90d0dace1c1bdc957339307803160335bde6df2b")},
    {/* key = */ std::vector<uint8_t>(131, 0xaa),
     /* message = */
     FromString(
         "This is a test using a larger than block-size key and a larger "
         "than block-size data. The key needs to be hashed before being "
         "used by the HMAC algorithm."),
     /* signature = */
     wvutil::a2b_hex(
         "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2"),
     /* signature_sha1 = */
     wvutil::a2b_hex("217e44bb08b6e06a2d6c30f3cb9f537f97c63356")}};

const std::vector<uint8_t> kEmptyVector;
const std::string kEmptyString;
}  // namespace

TEST(OEMCryptoHmacApiTest, GenerateSignatureSha1_InvalidParameters) {
  const std::vector<uint8_t> key = kHmacTestVectorList[0].key;
  const std::vector<uint8_t> message = kHmacTestVectorList[0].message;
  // Pointers only.
  size_t signature_length = kHmacSha256SignatureSize;
  std::vector<uint8_t> signature(signature_length);
  OEMCryptoResult result =
      HmacSha1(nullptr, key.size(), message.data(), message.size(),
               signature.data(), &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key = nullptr";
  result = HmacSha1(key.data(), 0, message.data(), message.size(),
                    signature.data(), &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key_length = 0";
  result = HmacSha1(key.data(), key.size(), nullptr, message.size(),
                    signature.data(), &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message = nullptr";
  result = HmacSha1(key.data(), key.size(), message.data(), 0, signature.data(),
                    &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message_length = 0";
  result = HmacSha1(key.data(), key.size(), message.data(), message.size(),
                    nullptr, &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "signature = nullptr";
  result = HmacSha1(key.data(), key.size(), message.data(), message.size(),
                    signature.data(), nullptr);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT)
      << "signature_length = nullptr";

  // Vector key.
  result = HmacSha1(kEmptyVector, message.data(), message.size(),
                    signature.data(), &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key = <empty>";
  result = HmacSha1(key, nullptr, message.size(), signature.data(),
                    &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message = nullptr";
  result =
      HmacSha1(key, message.data(), 0, signature.data(), &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message_length = 0";
  result =
      HmacSha1(key, message.data(), message.size(), nullptr, &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "signature = nullptr";
  result =
      HmacSha1(key, message.data(), message.size(), signature.data(), nullptr);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT)
      << "signature_length = nullptr";

  // Vector message, vector output.
  signature = HmacSha1(kEmptyVector, message);
  EXPECT_TRUE(signature.empty()) << "key = <empty>";
  signature = HmacSha1(key, kEmptyVector);
  EXPECT_TRUE(signature.empty()) << "message = <empty>";
}

TEST(OEMCryptoHmacApiTest, GenerateSignature_InvalidParameters) {
  const std::vector<uint8_t> key = kHmacTestVectorList[0].key;
  const std::vector<uint8_t> message = kHmacTestVectorList[0].message;
  // Pointers only.
  size_t signature_length = kHmacSha256SignatureSize;
  std::vector<uint8_t> signature(signature_length);
  OEMCryptoResult result =
      HmacSha256(nullptr, key.size(), message.data(), message.size(),
                 signature.data(), &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key = nullptr";
  result = HmacSha256(key.data(), 0, message.data(), message.size(),
                      signature.data(), &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key_length = 0";
  result = HmacSha256(key.data(), key.size(), nullptr, message.size(),
                      signature.data(), &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message = nullptr";
  result = HmacSha256(key.data(), key.size(), message.data(), 0,
                      signature.data(), &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message_length = 0";
  result = HmacSha256(key.data(), key.size(), message.data(), message.size(),
                      nullptr, &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "signature = nullptr";
  result = HmacSha256(key.data(), key.size(), message.data(), message.size(),
                      signature.data(), nullptr);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT)
      << "signature_length = nullptr";

  // Vector key.
  result = HmacSha256(kEmptyVector, message.data(), message.size(),
                      signature.data(), &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key = <empty>";
  result = HmacSha256(key, nullptr, message.size(), signature.data(),
                      &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message = nullptr";
  result =
      HmacSha256(key, message.data(), 0, signature.data(), &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message_length = 0";
  result = HmacSha256(key, message.data(), message.size(), nullptr,
                      &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "signature = nullptr";
  result = HmacSha256(key, message.data(), message.size(), signature.data(),
                      nullptr);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT)
      << "signature_length = nullptr";

  // Vector message, vector output signature parameter.
  signature.clear();
  EXPECT_FALSE(HmacSha256(kEmptyVector, message, &signature))
      << "key = <empty>";
  EXPECT_FALSE(HmacSha256(key, kEmptyVector, &signature))
      << "message = <empty>";
  EXPECT_FALSE(HmacSha256(key, message, nullptr)) << "signature = nullptr";

  // String message, vector output signature parameter.
  const std::string message_str(message.begin(), message.end());
  EXPECT_FALSE(HmacSha256(kEmptyVector, message_str, &signature))
      << "key = <empty>";
  EXPECT_FALSE(HmacSha256(key, kEmptyString, &signature))
      << "message = <empty>";
  EXPECT_FALSE(HmacSha256(key, message_str, nullptr)) << "signature = nullptr";

  // Pointer message, vector output.
  signature = HmacSha256(kEmptyVector, message.data(), message.size());
  EXPECT_TRUE(signature.empty()) << "key = <empty>";
  signature = HmacSha256(key, nullptr, message.size());
  EXPECT_TRUE(signature.empty()) << "message = nullptr";
  signature = HmacSha256(key, message.data(), 0);
  EXPECT_TRUE(signature.empty()) << "message_length = 0";

  // Vector message, vector output.
  signature = HmacSha256(kEmptyVector, message);
  EXPECT_TRUE(signature.empty()) << "key = <empty>";
  signature = HmacSha256(key, kEmptyVector);
  EXPECT_TRUE(signature.empty()) << "message = <empty>";

  // String message, vector output.
  signature = HmacSha256(kEmptyVector, message_str);
  EXPECT_TRUE(signature.empty()) << "key = <empty>";
  signature = HmacSha256(key, kEmptyString);
  EXPECT_TRUE(signature.empty()) << "message = <empty>";
}

TEST(OEMCryptoHmacApiTest, VerifySignatureSha1_InvalidParameters) {
  const std::vector<uint8_t> key = kHmacTestVectorList[0].key;
  const std::vector<uint8_t> message = kHmacTestVectorList[0].message;
  const std::vector<uint8_t> signature = kHmacTestVectorList[0].signature_sha1;

  // Pointers only.
  OEMCryptoResult result =
      HmacSha1Verify(nullptr, key.size(), message.data(), message.size(),
                     signature.data(), signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key = nullptr";
  result = HmacSha1Verify(key.data(), 0, message.data(), message.size(),
                          signature.data(), signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key_length = 0";
  result = HmacSha1Verify(key.data(), key.size(), nullptr, message.size(),
                          signature.data(), signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message = nullptr";
  result = HmacSha1Verify(key.data(), key.size(), message.data(), 0,
                          signature.data(), signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message_length = 0";
  result = HmacSha1Verify(key.data(), key.size(), message.data(),
                          message.size(), nullptr, signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "signature = nullptr";
  result = HmacSha1Verify(key.data(), key.size(), message.data(),
                          message.size(), signature.data(), 0);
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE)
      << "signature_length = 0";

  // Vector key, pointer others.
  result = HmacSha1Verify(kEmptyVector, message.data(), message.size(),
                          signature.data(), signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key = <empty>";
  result = HmacSha1Verify(key, nullptr, message.size(), signature.data(),
                          signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message = nullptr";
  result = HmacSha1Verify(key, message.data(), 0, signature.data(),
                          signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message_length = 0";
  result = HmacSha1Verify(key, message.data(), message.size(), nullptr,
                          signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "signature = nullptr";
  result =
      HmacSha1Verify(key, message.data(), message.size(), signature.data(), 0);
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE)
      << "signature_length = 0";

  // Vector only.
  result = HmacSha1Verify(kEmptyVector, message, signature);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key = <empty>";
  result = HmacSha1Verify(key, kEmptyVector, signature);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message = <empty>";
  result = HmacSha1Verify(key, message, kEmptyVector);
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE) << "signature = <empty>";
}

TEST(OEMCryptoHmacApiTest, VerifySignature_InvalidParameters) {
  const std::vector<uint8_t> key = kHmacTestVectorList[0].key;
  const std::vector<uint8_t> message = kHmacTestVectorList[0].message;
  const std::vector<uint8_t> signature = kHmacTestVectorList[0].signature;

  // Pointers only.
  OEMCryptoResult result =
      HmacSha256Verify(nullptr, key.size(), message.data(), message.size(),
                       signature.data(), signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key = nullptr";
  result = HmacSha256Verify(key.data(), 0, message.data(), message.size(),
                            signature.data(), signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key_length = 0";
  result = HmacSha256Verify(key.data(), key.size(), nullptr, message.size(),
                            signature.data(), signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message = nullptr";
  result = HmacSha256Verify(key.data(), key.size(), message.data(), 0,
                            signature.data(), signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message_length = 0";
  result = HmacSha256Verify(key.data(), key.size(), message.data(),
                            message.size(), nullptr, signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "signature = nullptr";
  result = HmacSha256Verify(key.data(), key.size(), message.data(),
                            message.size(), signature.data(), 0);
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE)
      << "signature_length = 0";

  // Vector key, pointer others.
  result = HmacSha256Verify(kEmptyVector, message.data(), message.size(),
                            signature.data(), signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key = <empty>";
  result = HmacSha256Verify(key, nullptr, message.size(), signature.data(),
                            signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message = nullptr";
  result = HmacSha256Verify(key, message.data(), 0, signature.data(),
                            signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message_length = 0";
  result = HmacSha256Verify(key, message.data(), message.size(), nullptr,
                            signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "signature = nullptr";
  result = HmacSha256Verify(key, message.data(), message.size(),
                            signature.data(), 0);
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE)
      << "signature_length = 0";

  // Vector only.
  result = HmacSha256Verify(kEmptyVector, message, signature);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key = <empty>";
  result = HmacSha256Verify(key, kEmptyVector, signature);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message = <empty>";
  result = HmacSha256Verify(key, message, kEmptyVector);
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE) << "signature = <empty>";

  // String message, vector others.
  const std::string message_str(message.begin(), message.end());
  result = HmacSha256Verify(kEmptyVector, message_str, signature);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "key = <empty>";
  result = HmacSha256Verify(key, kEmptyString, signature);
  EXPECT_EQ(result, OEMCrypto_ERROR_INVALID_CONTEXT) << "message = <empty>";
  result = HmacSha256Verify(key, message_str, kEmptyVector);
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE) << "signature = <empty>";
}

class OEMCryptoHmacTest : public testing::TestWithParam<HmacTestVector> {
 public:
  void SetUp() override {
    HmacTestVector v = GetParam();
    key_ = std::move(v.key);
    message_ = std::move(v.message);
    expected_signature_ = std::move(v.signature);
    expected_signature_sha1_ = std::move(v.signature_sha1);
    ASSERT_FALSE(key_.empty()) << "Missing test key";
    ASSERT_FALSE(message_.empty()) << "Missing test message";
    ASSERT_EQ(expected_signature_.size(), kHmacSha256SignatureSize)
        << "Invalid test HMAC-SHA-256 signature";
    ASSERT_EQ(expected_signature_sha1_.size(), kHmacSha1SignatureSize)
        << "Invalid test HMAC-SHA-1 signature";
  }

  void TearDown() override {
    key_.clear();
    message_.clear();
    expected_signature_.clear();
    expected_signature_sha1_.clear();
  }

  std::string GetStringMessage() const {
    return std::string(message_.begin(), message_.end());
  }

  std::vector<uint8_t> GenerateBadSignature() const {
    std::vector<uint8_t> bad_signature = expected_signature_;
    bad_signature[kHmacSha256SignatureSize / 2] ^= 0x87;
    return bad_signature;
  }

  std::vector<uint8_t> GenerateBadSignatureSha1() const {
    std::vector<uint8_t> bad_signature = expected_signature_sha1_;
    bad_signature[kHmacSha1SignatureSize / 2] ^= 0x87;
    return bad_signature;
  }

 protected:
  std::vector<uint8_t> key_;
  std::vector<uint8_t> message_;
  std::vector<uint8_t> expected_signature_;
  std::vector<uint8_t> expected_signature_sha1_;
};

TEST_P(OEMCryptoHmacTest, GenerateSignatureSha1_PointersOnly) {
  size_t signature_length = 0;
  OEMCryptoResult result =
      HmacSha1(key_.data(), key_.size(), message_.data(), message_.size(),
               nullptr, &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_SHORT_BUFFER);
  EXPECT_EQ(signature_length, kHmacSha1SignatureSize);

  signature_length = kHmacSha1SignatureSize * 2;
  std::vector<uint8_t> signature(signature_length);
  result = HmacSha1(key_.data(), key_.size(), message_.data(), message_.size(),
                    signature.data(), &signature_length);
  EXPECT_EQ(result, OEMCrypto_SUCCESS);
  EXPECT_EQ(signature_length, kHmacSha1SignatureSize);
  signature.resize(kHmacSha1SignatureSize);
  EXPECT_EQ(signature, expected_signature_sha1_);
}

TEST_P(OEMCryptoHmacTest, GenerateSignatureSha1_VectorKeyPointerOther) {
  size_t signature_length = 0;
  OEMCryptoResult result = HmacSha1(key_, message_.data(), message_.size(),
                                    nullptr, &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_SHORT_BUFFER);
  EXPECT_EQ(signature_length, kHmacSha1SignatureSize);

  signature_length = kHmacSha1SignatureSize * 2;
  std::vector<uint8_t> signature(signature_length);
  result = HmacSha1(key_, message_.data(), message_.size(), signature.data(),
                    &signature_length);
  EXPECT_EQ(result, OEMCrypto_SUCCESS);
  EXPECT_EQ(signature_length, kHmacSha1SignatureSize);
  signature.resize(kHmacSha1SignatureSize);
  EXPECT_EQ(signature, expected_signature_sha1_);
}

TEST_P(OEMCryptoHmacTest, GenerateSignatureSha1_VectorMessageVectorResult) {
  const std::vector<uint8_t> signature = HmacSha1(key_, message_);
  EXPECT_EQ(signature.size(), kHmacSha1SignatureSize);
  EXPECT_EQ(signature, expected_signature_sha1_);
}

TEST_P(OEMCryptoHmacTest, GenerateSignature_PointersOnly) {
  size_t signature_length = 0;
  OEMCryptoResult result =
      HmacSha256(key_.data(), key_.size(), message_.data(), message_.size(),
                 nullptr, &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_SHORT_BUFFER);
  EXPECT_EQ(signature_length, kHmacSha256SignatureSize);

  signature_length = kHmacSha256SignatureSize * 2;
  std::vector<uint8_t> signature(signature_length);
  result = HmacSha256(key_.data(), key_.size(), message_.data(),
                      message_.size(), signature.data(), &signature_length);
  EXPECT_EQ(result, OEMCrypto_SUCCESS);
  EXPECT_EQ(signature_length, kHmacSha256SignatureSize);
  signature.resize(kHmacSha256SignatureSize);
  EXPECT_EQ(signature, expected_signature_);
}

TEST_P(OEMCryptoHmacTest, GenerateSignature_VectorKeyPointerOther) {
  size_t signature_length = 0;
  OEMCryptoResult result = HmacSha256(key_, message_.data(), message_.size(),
                                      nullptr, &signature_length);
  EXPECT_EQ(result, OEMCrypto_ERROR_SHORT_BUFFER);
  EXPECT_EQ(signature_length, kHmacSha256SignatureSize);

  signature_length = kHmacSha256SignatureSize * 2;
  std::vector<uint8_t> signature(signature_length);
  result = HmacSha256(key_, message_.data(), message_.size(), signature.data(),
                      &signature_length);
  EXPECT_EQ(result, OEMCrypto_SUCCESS);
  EXPECT_EQ(signature_length, kHmacSha256SignatureSize);
  signature.resize(kHmacSha256SignatureSize);
  EXPECT_EQ(signature, expected_signature_);
}

TEST_P(OEMCryptoHmacTest, GenerateSignature_VectorMessageVectorOutputArgument) {
  std::vector<uint8_t> signature;
  EXPECT_TRUE(HmacSha256(key_, message_, &signature));
  EXPECT_EQ(signature.size(), kHmacSha256SignatureSize);
  EXPECT_EQ(signature, expected_signature_);
}

TEST_P(OEMCryptoHmacTest, GenerateSignature_StringMessageVectorOutputArgument) {
  const std::string message_str = GetStringMessage();
  std::vector<uint8_t> signature;
  EXPECT_TRUE(HmacSha256(key_, message_str, &signature));
  EXPECT_EQ(signature.size(), kHmacSha256SignatureSize);
  EXPECT_EQ(signature, expected_signature_);
}

TEST_P(OEMCryptoHmacTest, GenerateSignature_PointerMessageVectorResult) {
  const std::vector<uint8_t> signature =
      HmacSha256(key_, message_.data(), message_.size());
  EXPECT_EQ(signature.size(), kHmacSha256SignatureSize);
  EXPECT_EQ(signature, expected_signature_);
}

TEST_P(OEMCryptoHmacTest, GenerateSignature_VectorMessageVectorResult) {
  const std::vector<uint8_t> signature = HmacSha256(key_, message_);
  EXPECT_EQ(signature.size(), kHmacSha256SignatureSize);
  EXPECT_EQ(signature, expected_signature_);
}

TEST_P(OEMCryptoHmacTest, GenerateSignature_StringMessageVectorResult) {
  const std::string message_str = GetStringMessage();
  const std::vector<uint8_t> signature = HmacSha256(key_, message_str);
  EXPECT_EQ(signature.size(), kHmacSha256SignatureSize);
  EXPECT_EQ(signature, expected_signature_);
}

TEST_P(OEMCryptoHmacTest, VerifySignatureSha1_PointersOnly) {
  OEMCryptoResult result = HmacSha1Verify(
      key_.data(), key_.size(), message_.data(), message_.size(),
      expected_signature_sha1_.data(), expected_signature_sha1_.size());
  EXPECT_EQ(result, OEMCrypto_SUCCESS);

  const std::vector<uint8_t> bad_signature = GenerateBadSignatureSha1();
  result =
      HmacSha1Verify(key_.data(), key_.size(), message_.data(), message_.size(),
                     bad_signature.data(), bad_signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE);
}

TEST_P(OEMCryptoHmacTest, VerifySignatureSha1_VectorKeyPointerOther) {
  OEMCryptoResult result = HmacSha1Verify(
      key_, message_.data(), message_.size(), expected_signature_sha1_.data(),
      expected_signature_sha1_.size());
  EXPECT_EQ(result, OEMCrypto_SUCCESS);

  const std::vector<uint8_t> bad_signature = GenerateBadSignatureSha1();
  result = HmacSha1Verify(key_, message_.data(), message_.size(),
                          bad_signature.data(), bad_signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE);
}

TEST_P(OEMCryptoHmacTest, VerifySignatureSha1_VectorsOnly) {
  OEMCryptoResult result =
      HmacSha1Verify(key_, message_, expected_signature_sha1_);
  EXPECT_EQ(result, OEMCrypto_SUCCESS);

  const std::vector<uint8_t> bad_signature = GenerateBadSignatureSha1();
  result = HmacSha1Verify(key_, message_, bad_signature);
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE);
}

TEST_P(OEMCryptoHmacTest, VerifySignature_PointersOnly) {
  OEMCryptoResult result = HmacSha256Verify(
      key_.data(), key_.size(), message_.data(), message_.size(),
      expected_signature_.data(), expected_signature_.size());
  EXPECT_EQ(result, OEMCrypto_SUCCESS);

  const std::vector<uint8_t> bad_signature = GenerateBadSignature();
  result = HmacSha256Verify(key_.data(), key_.size(), message_.data(),
                            message_.size(), bad_signature.data(),
                            bad_signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE);
}

TEST_P(OEMCryptoHmacTest, VerifySignature_VectorKeyPointerOther) {
  OEMCryptoResult result =
      HmacSha256Verify(key_, message_.data(), message_.size(),
                       expected_signature_.data(), expected_signature_.size());
  EXPECT_EQ(result, OEMCrypto_SUCCESS);

  const std::vector<uint8_t> bad_signature = GenerateBadSignature();
  result = HmacSha256Verify(key_, message_.data(), message_.size(),
                            bad_signature.data(), bad_signature.size());
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE);
}

TEST_P(OEMCryptoHmacTest, VerifySignature_VectorsOnly) {
  OEMCryptoResult result =
      HmacSha256Verify(key_, message_, expected_signature_);
  EXPECT_EQ(result, OEMCrypto_SUCCESS);

  const std::vector<uint8_t> bad_signature = GenerateBadSignature();
  result = HmacSha256Verify(key_, message_, bad_signature);
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE);
}

TEST_P(OEMCryptoHmacTest, VerifySignature_StringMessageVectorOther) {
  const std::string message_str = GetStringMessage();
  OEMCryptoResult result =
      HmacSha256Verify(key_, message_str, expected_signature_);
  EXPECT_EQ(result, OEMCrypto_SUCCESS);

  const std::vector<uint8_t> bad_signature = GenerateBadSignature();
  result = HmacSha256Verify(key_, message_str, bad_signature);
  EXPECT_EQ(result, OEMCrypto_ERROR_SIGNATURE_FAILURE);
}

INSTANTIATE_TEST_SUITE_P(HmacVectors, OEMCryptoHmacTest,
                         testing::ValuesIn(kHmacTestVectorList));
}  // namespace util
}  // namespace wvoec