598 lines
27 KiB
C++
598 lines
27 KiB
C++
// 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
|