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

Simplify fuzz tests using LicenseWithUsageEntryFuzz

Browse Source 
Merged from https://widevine-internal-review.googlesource.com/175060

Change-Id: I2f245ac998883e2a31cde361e30b36f00681262c
This commit is contained in:
Ian Benz
2023-05-12 17:52:38 +00:00
committed by Robert Shih
parent 5c5433a8d8
commit 078682a897
8 changed files with 72 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
libwvdrmengine/oemcrypto/test/fuzz_tests/oemcrypto_deactivate_usage_entry_fuzz.cc
View File

@@ -11,19 +11,15 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
wvoec::LicenseWithUsageEntryFuzz entry; wvoec::LicenseWithUsageEntryFuzz entry;
entry.Initialize(); entry.Initialize();
entry.CreateUsageTableHeader(); entry.CreateUsageTableHeader();
// Open a session, create a usage entry. entry.InstallTestDrmKey();
wvoec::Session* session = entry.license_messages().session(); entry.session().CreateNewUsageEntry();
session->open(); entry.session().GenerateNonce();
entry.InstallTestDrmKey(session);
session->CreateNewUsageEntry();
session->GenerateNonce();
std::vector<uint8_t> encrypted_usage_header; std::vector<uint8_t> encrypted_usage_header;
session->UpdateUsageEntry(&encrypted_usage_header); entry.session().UpdateUsageEntry(&encrypted_usage_header);
// LoadLicense sets the pst for usage entry. // LoadLicense sets the pst for usage entry.
entry.LoadLicense(); entry.LoadLicense();
OEMCrypto_DeactivateUsageEntry(entry.session().session_id(), data, size);
entry.Terminate();
OEMCrypto_DeactivateUsageEntry(session->session_id(), data, size);
session->close();
OEMCrypto_Terminate();
return 0; return 0;
} }

21
libwvdrmengine/oemcrypto/test/fuzz_tests/oemcrypto_fuzz_helper.h
View File

@@ -143,33 +143,36 @@ class OEMCryptoRenewalAPIFuzz {
class LicenseWithUsageEntryFuzz { class LicenseWithUsageEntryFuzz {
public: public:
LicenseWithUsageEntryFuzz() : license_messages_(&session_) { LicenseWithUsageEntryFuzz() : license_messages_(&session_fuzz_.session()) {
license_messages_.set_pst("my_pst"); license_messages_.set_pst("my_pst");
} }
void Initialize() { InitializeFuzz(session_util_); } void Initialize() { session_fuzz_.Initialize(); }
void InstallTestDrmKey(Session* session) { void Terminate() { session_fuzz_.Terminate(); }
session_util_.InstallTestDrmKey(session);
}
void CreateUsageTableHeader(); void CreateUsageTableHeader();
void InstallTestDrmKey() { session_fuzz_.InstallTestDrmKey(); }
void LoadLicense(); void LoadLicense();
LicenseRoundTrip& license_messages() { return license_messages_; } LicenseRoundTrip& license_messages() { return license_messages_; }
const LicenseRoundTrip& license_messages() const { return license_messages_; } const LicenseRoundTrip& license_messages() const { return license_messages_; }
const vector<uint8_t>& encrypted_usage_header() const { const std::vector<uint8_t>& encrypted_usage_header() const {
return encrypted_usage_header_; return encrypted_usage_header_;
} }
Session& session() { return session_fuzz_.session(); }
const Session& session() const { return session_fuzz_.session(); }
private: private:
SessionUtil session_util_; SessionFuzz session_fuzz_;
vector<uint8_t> encrypted_usage_header_;
LicenseRoundTrip license_messages_; LicenseRoundTrip license_messages_;
Session session_; std::vector<uint8_t> encrypted_usage_header_;
}; };
// Convert data from FuzzedDataProvider to valid enum value. // Convert data from FuzzedDataProvider to valid enum value.

24
libwvdrmengine/oemcrypto/test/fuzz_tests/oemcrypto_load_usage_entry_fuzz.cc
View File

@@ -35,17 +35,16 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv) {
extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* data, size_t size, extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* data, size_t size,
size_t max_size, unsigned int seed) { size_t max_size, unsigned int seed) {
entry.CreateUsageTableHeader(); entry.CreateUsageTableHeader();
wvoec::Session* s = entry.license_messages().session(); entry.session().open();
s->open(); entry.InstallTestDrmKey();
entry.InstallTestDrmKey(s); if (LoadUsageEntryWithFuzzedData(entry.session().session_id(), data, size) !=
if (LoadUsageEntryWithFuzzedData(s->session_id(), data, size) !=
OEMCrypto_SUCCESS) { OEMCrypto_SUCCESS) {
s->CreateNewUsageEntry(); entry.session().CreateNewUsageEntry();
std::vector<uint8_t> encrypted_usage_header; std::vector<uint8_t> encrypted_usage_header;
s->UpdateUsageEntry(&encrypted_usage_header); entry.session().UpdateUsageEntry(&encrypted_usage_header);
const uint32_t usage_entry_number = s->usage_entry_number(); const uint32_t usage_entry_number = entry.session().usage_entry_number();
const std::vector<uint8_t>& encrypted_usage_entry = const std::vector<uint8_t>& encrypted_usage_entry =
s->encrypted_usage_entry(); entry.session().encrypted_usage_entry();
size = sizeof(usage_entry_number) + encrypted_usage_entry.size(); size = sizeof(usage_entry_number) + encrypted_usage_entry.size();
if (size > max_size) { if (size > max_size) {
return 0; return 0;
@@ -55,14 +54,13 @@ extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* data, size_t size,
memcpy(data + sizeof(usage_entry_number), encrypted_usage_entry.data(), memcpy(data + sizeof(usage_entry_number), encrypted_usage_entry.data(),
encrypted_usage_entry.size()); encrypted_usage_entry.size());
} }
s->close(); entry.session().close();
return LLVMFuzzerMutate(data, size, max_size); return LLVMFuzzerMutate(data, size, max_size);
} }
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
wvoec::Session s; entry.session().open();
s.open(); LoadUsageEntryWithFuzzedData(entry.session().session_id(), data, size);
LoadUsageEntryWithFuzzedData(s.session_id(), data, size); entry.session().close();
s.close();
return 0; return 0;
} }

2
libwvdrmengine/oemcrypto/test/fuzz_tests/oemcrypto_load_usage_table_header_fuzz.cc
View File

@@ -20,7 +20,7 @@ extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* data, size_t size,
memcpy(data, entry.encrypted_usage_header().data(), memcpy(data, entry.encrypted_usage_header().data(),
entry.encrypted_usage_header().size()); entry.encrypted_usage_header().size());
} }
OEMCrypto_Terminate(); entry.Terminate();
return LLVMFuzzerMutate(data, size, max_size); return LLVMFuzzerMutate(data, size, max_size);
} }

35
libwvdrmengine/oemcrypto/test/fuzz_tests/oemcrypto_move_usage_entry_fuzz.cc
View File

@@ -6,35 +6,24 @@
#include "OEMCryptoCENC.h" #include "OEMCryptoCENC.h"
#include "oemcrypto_fuzz_helper.h" #include "oemcrypto_fuzz_helper.h"
namespace {
// Avoid calling non-trivial destructor.
wvoec::LicenseWithUsageEntryFuzz& entry = *new wvoec::LicenseWithUsageEntryFuzz;
} // namespace
extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv) {
wvoec::RedirectStdoutToFile();
entry.Initialize();
return 0;
}
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
wvoec::RedirectStdoutToFile();
wvoec::LicenseWithUsageEntryFuzz entry;
entry.Initialize();
entry.CreateUsageTableHeader(); entry.CreateUsageTableHeader();
wvoec::Session* s = entry.license_messages().session(); entry.InstallTestDrmKey();
s->open(); entry.session().CreateNewUsageEntry();
entry.InstallTestDrmKey(s);
s->CreateNewUsageEntry();
std::vector<uint8_t> encrypted_usage_header; std::vector<uint8_t> encrypted_usage_header;
s->UpdateUsageEntry(&encrypted_usage_header); entry.session().UpdateUsageEntry(&encrypted_usage_header);
s->close(); entry.session().close();
s->open(); entry.session().open();
s->ReloadUsageEntry(); entry.session().ReloadUsageEntry();
OEMCrypto_MoveEntry( OEMCrypto_MoveEntry(
s->session_id(), entry.session().session_id(),
FuzzedDataProvider(data, size).ConsumeIntegral<uint32_t>()); FuzzedDataProvider(data, size).ConsumeIntegral<uint32_t>());
s->close();
entry.Terminate();
return 0; return 0;
} }

27
libwvdrmengine/oemcrypto/test/fuzz_tests/oemcrypto_report_usage_fuzz.cc
View File

@@ -11,7 +11,7 @@ namespace {
constexpr size_t MAX_FUZZ_PST_REPORT_BUFFER_LENGTH = 5 * wvoec::MB; constexpr size_t MAX_FUZZ_PST_REPORT_BUFFER_LENGTH = 5 * wvoec::MB;
} // namespace } // namespace
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
wvoec::RedirectStdoutToFile(); wvoec::RedirectStdoutToFile();
@@ -19,30 +19,29 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
wvoec::LicenseWithUsageEntryFuzz entry; wvoec::LicenseWithUsageEntryFuzz entry;
entry.Initialize(); entry.Initialize();
entry.CreateUsageTableHeader(); entry.CreateUsageTableHeader();
// Open a session, create a usage entry. entry.InstallTestDrmKey();
wvoec::Session* session = entry.license_messages().session(); entry.session().CreateNewUsageEntry();
session->open(); entry.session().GenerateNonce();
entry.InstallTestDrmKey(session);
session->CreateNewUsageEntry();
session->GenerateNonce();
std::vector<uint8_t> encrypted_usage_header; std::vector<uint8_t> encrypted_usage_header;
session->UpdateUsageEntry(&encrypted_usage_header); entry.session().UpdateUsageEntry(&encrypted_usage_header);
// Sets pst for usage entry. // Sets pst for usage entry.
entry.LoadLicense(); entry.LoadLicense();
FuzzedDataProvider fuzzed_data(data, size); FuzzedDataProvider fuzzed_data(data, size);
// pst_report_buffer and pst_report_buffer_length parameters
size_t pst_report_buffer_length_data = size_t pst_report_buffer_length_data =
fuzzed_data.ConsumeIntegralInRange<size_t>( fuzzed_data.ConsumeIntegralInRange<size_t>(
0, MAX_FUZZ_PST_REPORT_BUFFER_LENGTH); 0, MAX_FUZZ_PST_REPORT_BUFFER_LENGTH);
std::vector<uint8_t> pst_report_buffer(pst_report_buffer_length_data); std::vector<uint8_t> pst_report_buffer(pst_report_buffer_length_data);
size_t* const pst_report_buffer_length = size_t* const pst_report_buffer_length =
fuzzed_data.ConsumeBool() ? &pst_report_buffer_length_data : nullptr; fuzzed_data.ConsumeBool() ? &pst_report_buffer_length_data : nullptr;
const std::vector<uint8_t> pst = fuzzed_data.ConsumeRemainingBytes<uint8_t>();
// Call API with fuzzed pst_buffer_length, pst.
OEMCrypto_ReportUsage(session->session_id(), pst.data(), pst.size(),
pst_report_buffer.data(), pst_report_buffer_length);
session->close();
OEMCrypto_Terminate();
const std::vector<uint8_t> pst = fuzzed_data.ConsumeRemainingBytes<uint8_t>();
OEMCrypto_ReportUsage(entry.session().session_id(), pst.data(), pst.size(),
pst_report_buffer.data(), pst_report_buffer_length);
entry.Terminate();
return 0; return 0;
} }

31
libwvdrmengine/oemcrypto/test/fuzz_tests/oemcrypto_reuse_usage_entry_fuzz.cc
View File

@@ -6,32 +6,21 @@
#include "OEMCryptoCENC.h" #include "OEMCryptoCENC.h"
#include "oemcrypto_fuzz_helper.h" #include "oemcrypto_fuzz_helper.h"
namespace {
// Avoid calling non-trivial destructor.
wvoec::LicenseWithUsageEntryFuzz& entry = *new wvoec::LicenseWithUsageEntryFuzz;
} // namespace
extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv) {
wvoec::RedirectStdoutToFile();
entry.Initialize();
return 0;
}
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
wvoec::RedirectStdoutToFile();
wvoec::LicenseWithUsageEntryFuzz entry;
entry.Initialize();
entry.CreateUsageTableHeader(); entry.CreateUsageTableHeader();
wvoec::Session* s = entry.license_messages().session(); entry.InstallTestDrmKey();
s->open(); entry.session().CreateNewUsageEntry();
entry.InstallTestDrmKey(s); entry.session().close();
s->CreateNewUsageEntry();
s->close();
s->open(); entry.session().open();
OEMCrypto_ReuseUsageEntry( OEMCrypto_ReuseUsageEntry(
s->session_id(), entry.session().session_id(),
FuzzedDataProvider(data, size).ConsumeIntegral<uint32_t>()); FuzzedDataProvider(data, size).ConsumeIntegral<uint32_t>());
s->close();
entry.Terminate();
return 0; return 0;
} }

8
libwvdrmengine/oemcrypto/test/fuzz_tests/oemcrypto_shrink_usage_table_header_fuzz.cc
View File

@@ -14,15 +14,21 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
wvoec::LicenseWithUsageEntryFuzz entry; wvoec::LicenseWithUsageEntryFuzz entry;
entry.Initialize(); entry.Initialize();
entry.CreateUsageTableHeader(); entry.CreateUsageTableHeader();
FuzzedDataProvider fuzzed_data(data, size); FuzzedDataProvider fuzzed_data(data, size);
const uint32_t new_entry_count = fuzzed_data.ConsumeIntegral<uint32_t>(); const uint32_t new_entry_count = fuzzed_data.ConsumeIntegral<uint32_t>();
// header_buffer and header_buffer_length parameters
size_t header_buffer_length_data = fuzzed_data.ConsumeIntegralInRange<size_t>( size_t header_buffer_length_data = fuzzed_data.ConsumeIntegralInRange<size_t>(
0, wvoec::MAX_FUZZ_OUTPUT_LENGTH); 0, wvoec::MAX_FUZZ_OUTPUT_LENGTH);
std::vector<uint8_t> header_buffer(header_buffer_length_data); std::vector<uint8_t> header_buffer(header_buffer_length_data);
size_t* const header_buffer_length = size_t* const header_buffer_length =
fuzzed_data.ConsumeBool() ? &header_buffer_length_data : nullptr; fuzzed_data.ConsumeBool() ? &header_buffer_length_data : nullptr;
OEMCrypto_ShrinkUsageTableHeader(new_entry_count, header_buffer.data(), OEMCrypto_ShrinkUsageTableHeader(new_entry_count, header_buffer.data(),
header_buffer_length); header_buffer_length);
OEMCrypto_Terminate();
entry.Terminate();
return 0; return 0;
} }