Source release 17.1.0

2022-07-07 17:14:31 -07:00
parent 8c17574083
commit 694cf6fb25
2233 changed files with 272026 additions and 223371 deletions
--- a/oemcrypto/util/test/hmac_unittest.cpp
+++ b/oemcrypto/util/test/hmac_unittest.cpp
@@ -0,0 +1,597 @@
+// 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