widevine-partner/whitebox
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix formatting for selected files

Browse Source
This commit is contained in:
Feras Aldahlawi
2023-10-05 14:24:47 -07:00
parent 9a1d1460fe
commit de6653061e
6 changed files with 45 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
whitebox/api/license_whitebox_entitlement_content_key_test.cc
View File

@@ -64,18 +64,12 @@ TEST_P(LicenseWhiteboxEntitlementContentKeyTest, Decrypt) {
std::vector<uint8_t> decrypted(content.plaintext.size()); std::vector<uint8_t> decrypted(content.plaintext.size());
size_t decrypted_size = decrypted.size(); size_t decrypted_size = decrypted.size();
ASSERT_EQ(WB_License_Decrypt( ASSERT_EQ(
whitebox_, WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CTR, key_id.data(),
WB_CIPHER_MODE_CTR, key_id.size(), content.ciphertext.data(),
key_id.data(), content.ciphertext.size(), content.iv.data(),
key_id.size(), content.iv.size(), &decrypted[0], &decrypted_size),
content.ciphertext.data(), WB_RESULT_OK);
content.ciphertext.size(),
content.iv.data(),
content.iv.size(),
&decrypted[0],
&decrypted_size),
WB_RESULT_OK);
decrypted.resize(decrypted_size); decrypted.resize(decrypted_size);
EXPECT_EQ(decrypted, content.plaintext); EXPECT_EQ(decrypted, content.plaintext);
} }
@@ -113,22 +107,15 @@ TEST_F(LicenseWhiteboxEntitlementContentKeyTest, Remove) {
std::vector<uint8_t> decrypted(content.plaintext.size()); std::vector<uint8_t> decrypted(content.plaintext.size());
size_t decrypted_size = decrypted.size(); size_t decrypted_size = decrypted.size();
ASSERT_EQ(WB_License_Decrypt( ASSERT_EQ(
whitebox_, WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CTR, key_id.data(),
WB_CIPHER_MODE_CTR, key_id.size(), content.ciphertext.data(),
key_id.data(), content.ciphertext.size(), content.iv.data(),
key_id.size(), content.iv.size(), &decrypted[0], &decrypted_size),
content.ciphertext.data(), WB_RESULT_KEY_UNAVAILABLE);
content.ciphertext.size(),
content.iv.data(),
content.iv.size(),
&decrypted[0],
&decrypted_size),
WB_RESULT_KEY_UNAVAILABLE);
} }
INSTANTIATE_TEST_SUITE_P( INSTANTIATE_TEST_SUITE_P(WithAndWithoutProviderKeyId,
WithAndWithoutProviderKeyId, LicenseWhiteboxEntitlementContentKeyTest,
LicenseWhiteboxEntitlementContentKeyTest, ::testing::Values(kNoProviderKeyId, kProviderKeyId));
::testing::Values(kNoProviderKeyId, kProviderKeyId));
} // namespace widevine } // namespace widevine

43
whitebox/api/license_whitebox_generic_crypto_test.cc
View File

@@ -14,7 +14,8 @@
namespace widevine { namespace widevine {
class LicenseWhiteboxGenericCryptoInvalidTest class LicenseWhiteboxGenericCryptoInvalidTest
: public LicenseWhiteboxTestBase, public testing::WithParamInterface<int> { : public LicenseWhiteboxTestBase,
public testing::WithParamInterface<int> {
protected: protected:
void SetUp() { void SetUp() {
LicenseWhiteboxTestBase::SetUp(); LicenseWhiteboxTestBase::SetUp();
@@ -81,11 +82,13 @@ TEST_P(LicenseWhiteboxGenericCryptoInvalidTest, Test) {
WB_RESULT_KEY_UNAVAILABLE); WB_RESULT_KEY_UNAVAILABLE);
} }
INSTANTIATE_TEST_SUITE_P(All, LicenseWhiteboxGenericCryptoInvalidTest, INSTANTIATE_TEST_SUITE_P(All,
LicenseWhiteboxGenericCryptoInvalidTest,
testing::Range(0, 6)); testing::Range(0, 6));
class LicenseWhiteboxGenericCryptoTest class LicenseWhiteboxGenericCryptoTest
: public LicenseWhiteboxTestBase, public testing::WithParamInterface<bool> { : public LicenseWhiteboxTestBase,
public testing::WithParamInterface<bool> {
protected: protected:
void SetUp() { void SetUp() {
LicenseWhiteboxTestBase::SetUp(); LicenseWhiteboxTestBase::SetUp();
@@ -129,10 +132,10 @@ TEST_P(LicenseWhiteboxGenericCryptoTest, NoContentDecrypt) {
GetParam() ? content.encrypt_decrypt_key.id : content.decrypt_key.id; GetParam() ? content.encrypt_decrypt_key.id : content.decrypt_key.id;
std::vector<uint8_t> actual(content.plaintext.size()); std::vector<uint8_t> actual(content.plaintext.size());
size_t actual_size = actual.size(); size_t actual_size = actual.size();
result = WB_License_Decrypt( result = WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CTR, key_id.data(),
whitebox_, WB_CIPHER_MODE_CTR, key_id.data(), key_id.size(), key_id.size(), content.encrypted.data(),
content.encrypted.data(), content.encrypted.size(), content.iv.data(), content.encrypted.size(), content.iv.data(),
content.iv.size(), actual.data(), &actual_size); content.iv.size(), actual.data(), &actual_size);
#ifndef HAS_GENERIC_CRYPTO #ifndef HAS_GENERIC_CRYPTO
if (result == WB_RESULT_NOT_IMPLEMENTED) if (result == WB_RESULT_NOT_IMPLEMENTED)
GTEST_SKIP(); GTEST_SKIP();
@@ -229,8 +232,8 @@ TEST_P(LicenseWhiteboxGenericCryptoTest, DecryptShortBuffer) {
size_t actual_size = 0; size_t actual_size = 0;
result = WB_License_GenericDecrypt( result = WB_License_GenericDecrypt(
whitebox_, key_id.data(), key_id.size(), content.encrypted.data(), whitebox_, key_id.data(), key_id.size(), content.encrypted.data(),
content.encrypted.size(), content.iv.data(), content.iv.size(), content.encrypted.size(), content.iv.data(), content.iv.size(), nullptr,
nullptr, &actual_size); &actual_size);
#ifndef HAS_GENERIC_CRYPTO #ifndef HAS_GENERIC_CRYPTO
if (result == WB_RESULT_NOT_IMPLEMENTED) if (result == WB_RESULT_NOT_IMPLEMENTED)
GTEST_SKIP(); GTEST_SKIP();
@@ -284,8 +287,7 @@ TEST_P(LicenseWhiteboxGenericCryptoTest, DecryptKeyUsage) {
ASSERT_EQ(result, WB_RESULT_OK); ASSERT_EQ(result, WB_RESULT_OK);
auto& content = golden_data_.GenericContent(); auto& content = golden_data_.GenericContent();
auto& key_id = auto& key_id = GetParam() ? content.sign_verify_key.id : content.sign_key.id;
GetParam() ? content.sign_verify_key.id : content.sign_key.id;
std::vector<uint8_t> actual(content.plaintext.size()); std::vector<uint8_t> actual(content.plaintext.size());
size_t actual_size = actual.size(); size_t actual_size = actual.size();
result = WB_License_GenericDecrypt( result = WB_License_GenericDecrypt(
@@ -384,8 +386,8 @@ TEST_P(LicenseWhiteboxGenericCryptoTest, EncryptShortBuffer) {
size_t actual_size = 0; size_t actual_size = 0;
result = WB_License_GenericEncrypt( result = WB_License_GenericEncrypt(
whitebox_, key_id.data(), key_id.size(), content.plaintext.data(), whitebox_, key_id.data(), key_id.size(), content.plaintext.data(),
content.plaintext.size(), content.iv.data(), content.iv.size(), content.plaintext.size(), content.iv.data(), content.iv.size(), nullptr,
nullptr, &actual_size); &actual_size);
#ifndef HAS_GENERIC_CRYPTO #ifndef HAS_GENERIC_CRYPTO
if (result == WB_RESULT_NOT_IMPLEMENTED) if (result == WB_RESULT_NOT_IMPLEMENTED)
GTEST_SKIP(); GTEST_SKIP();
@@ -439,8 +441,7 @@ TEST_P(LicenseWhiteboxGenericCryptoTest, EncryptKeyUsage) {
ASSERT_EQ(result, WB_RESULT_OK); ASSERT_EQ(result, WB_RESULT_OK);
auto& content = golden_data_.GenericContent(); auto& content = golden_data_.GenericContent();
auto& key_id = auto& key_id = GetParam() ? content.sign_verify_key.id : content.sign_key.id;
GetParam() ? content.sign_verify_key.id : content.sign_key.id;
std::vector<uint8_t> actual(content.encrypted.size()); std::vector<uint8_t> actual(content.encrypted.size());
size_t actual_size = actual.size(); size_t actual_size = actual.size();
result = WB_License_GenericEncrypt( result = WB_License_GenericEncrypt(
@@ -500,8 +501,7 @@ TEST_P(LicenseWhiteboxGenericCryptoTest, Sign) {
ASSERT_EQ(result, WB_RESULT_OK); ASSERT_EQ(result, WB_RESULT_OK);
auto& content = golden_data_.GenericContent(); auto& content = golden_data_.GenericContent();
auto& key_id = auto& key_id = GetParam() ? content.sign_verify_key.id : content.sign_key.id;
GetParam() ? content.sign_verify_key.id : content.sign_key.id;
std::vector<uint8_t> actual(content.signature.size()); std::vector<uint8_t> actual(content.signature.size());
size_t actual_size = actual.size(); size_t actual_size = actual.size();
result = WB_License_GenericSign( result = WB_License_GenericSign(
@@ -533,8 +533,7 @@ TEST_P(LicenseWhiteboxGenericCryptoTest, SignShortBuffer) {
ASSERT_EQ(result, WB_RESULT_OK); ASSERT_EQ(result, WB_RESULT_OK);
auto& content = golden_data_.GenericContent(); auto& content = golden_data_.GenericContent();
auto& key_id = auto& key_id = GetParam() ? content.sign_verify_key.id : content.sign_key.id;
GetParam() ? content.sign_verify_key.id : content.sign_key.id;
size_t actual_size = 0; size_t actual_size = 0;
result = WB_License_GenericSign( result = WB_License_GenericSign(
whitebox_, key_id.data(), key_id.size(), content.plaintext.data(), whitebox_, key_id.data(), key_id.size(), content.plaintext.data(),
@@ -562,8 +561,7 @@ TEST_P(LicenseWhiteboxGenericCryptoTest, SignMissingKey) {
ASSERT_EQ(result, WB_RESULT_OK); ASSERT_EQ(result, WB_RESULT_OK);
auto& content = golden_data_.GenericContent(); auto& content = golden_data_.GenericContent();
auto& key_id = auto& key_id = !GetParam() ? content.sign_verify_key.id : content.sign_key.id;
!GetParam() ? content.sign_verify_key.id : content.sign_key.id;
std::vector<uint8_t> actual(content.signature.size()); std::vector<uint8_t> actual(content.signature.size());
size_t actual_size = actual.size(); size_t actual_size = actual.size();
result = WB_License_GenericSign( result = WB_License_GenericSign(
@@ -693,7 +691,8 @@ TEST_P(LicenseWhiteboxGenericCryptoTest, VerifyKeyUsage) {
ASSERT_EQ(result, WB_RESULT_INSUFFICIENT_PERMISSIONS); ASSERT_EQ(result, WB_RESULT_INSUFFICIENT_PERMISSIONS);
} }
INSTANTIATE_TEST_SUITE_P(All, LicenseWhiteboxGenericCryptoTest, INSTANTIATE_TEST_SUITE_P(All,
LicenseWhiteboxGenericCryptoTest,
testing::Bool()); testing::Bool());
} // namespace widevine } // namespace widevine

2
whitebox/api/license_whitebox_key_control_block_test.cc
View File

@@ -119,7 +119,7 @@ INSTANTIATE_TEST_SUITE_P(
::testing::Bool())); ::testing::Bool()));
class LicenseWhiteboxKeyControlBlockSingleTest class LicenseWhiteboxKeyControlBlockSingleTest
: public LicenseWhiteboxTestBase { : public LicenseWhiteboxTestBase {
protected: protected:
void SetUp() override { void SetUp() override {
LicenseWhiteboxTestBase::SetUp(); LicenseWhiteboxTestBase::SetUp();

3
whitebox/api/license_whitebox_process_license_response_test.cc
View File

@@ -100,8 +100,7 @@ TEST_F(LicenseWhiteboxProcessLicenseResponseTest,
WB_RESULT_OK); WB_RESULT_OK);
} }
TEST_F(LicenseWhiteboxProcessLicenseResponseTest, TEST_F(LicenseWhiteboxProcessLicenseResponseTest, SuccessWithEntitlementKey) {
SuccessWithEntitlementKey) {
UseLicenseWithEntitlementKey(); UseLicenseWithEntitlementKey();
const auto result = WB_License_ProcessLicenseResponse( const auto result = WB_License_ProcessLicenseResponse(

3
whitebox/api/remote_attestation_and_verification_test.cc
View File

@@ -137,7 +137,8 @@ class RemoteAttestationAndVerificationTest
#ifdef ALWAYS_DECRYPT_TO_CLEAR #ifdef ALWAYS_DECRYPT_TO_CLEAR
if (key == Key::kDecode) { if (key == Key::kDecode) {
if (mode_ == Mode::kDecryptFail) mode_ = Mode::kDecryptPass; if (mode_ == Mode::kDecryptFail)
mode_ = Mode::kDecryptPass;
} }
#endif #endif

11
whitebox/reference/impl/license_whitebox_impl.cc
View File

@@ -593,15 +593,14 @@ WB_Result WB_License_RemoveEntitledContentKey(WB_License_Whitebox* whitebox,
return WB_RESULT_INVALID_STATE; return WB_RESULT_INVALID_STATE;
} }
if (whitebox->content_keys.erase(MakeString(content_key_id, if (whitebox->content_keys.erase(
content_key_id_size)) == 0) { MakeString(content_key_id, content_key_id_size)) == 0) {
DVLOG(1) << "Content key not found."; DVLOG(1) << "Content key not found.";
return WB_RESULT_KEY_UNAVAILABLE; return WB_RESULT_KEY_UNAVAILABLE;
} }
return WB_RESULT_OK; return WB_RESULT_OK;
} }
WB_Result WB_License_QueryKeyStatus(const WB_License_Whitebox* whitebox, WB_Result WB_License_QueryKeyStatus(const WB_License_Whitebox* whitebox,
WB_KeyQueryType type, WB_KeyQueryType type,
const uint8_t* key_id, const uint8_t* key_id,
@@ -1052,9 +1051,9 @@ WB_Result WB_License_GenericVerify(const WB_License_Whitebox* whitebox,
} }
if (!widevine::crypto_util::VerifySignatureHmacSha256( if (!widevine::crypto_util::VerifySignatureHmacSha256(
MakeString(it->second.key.data(), it->second.key.size()), MakeString(it->second.key.data(), it->second.key.size()),
MakeString(signature, signature_size), MakeString(signature, signature_size),
MakeString(message, message_size))) { MakeString(message, message_size))) {
return WB_RESULT_INVALID_SIGNATURE; return WB_RESULT_INVALID_SIGNATURE;
} }
return WB_RESULT_OK; return WB_RESULT_OK;