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

Updated system_id_extractor_fuzzer

Browse Source 
Implemented google c++ code style changes for system_id_extractor_fuzzer

exec/s: 73
Test: ./system_id_extractor_fuzzer
Bug: 312374669

Change-Id: I9ffb9f1de99a3e37fa456b357946292f16af5dc3
This commit is contained in:
Onkar Shinde
2023-12-05 06:07:41 +00:00
committed by Aditya Wazir
parent 2b3de00a36
commit 8bfb8bd34d
1 changed files with 96 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

149
fuzzer/system_id_extractor_fuzzer.cpp
View File

@@ -38,168 +38,175 @@ static constexpr int32_t kMinRequestedSecurityLevel = 0;
class FuzzDeviceFiles : public DeviceFiles {
public:
FuzzDeviceFiles(wvutil::FileSystem *fs, FuzzedDataProvider *fdp)
: DeviceFiles(fs), mFdp(fdp) {}
: DeviceFiles(fs), fdp_(fdp) {}
bool Init(CdmSecurityLevel) override { return mFdp->ConsumeBool(); }
bool Init(CdmSecurityLevel) override { return fdp_->ConsumeBool(); }
DeviceFiles::CertificateState
RetrieveOemCertificate(std::string *certificate,
DeviceFiles::CertificateState RetrieveOemCertificate(
std::string *certificate,
CryptoWrappedKey * /*wrapped_private_key*/) override {
*certificate = mFdp->ConsumeRandomLengthString(kMaxByte);
return (DeviceFiles::CertificateState)mFdp->ConsumeIntegralInRange<int32_t>(
*certificate = fdp_->ConsumeRandomLengthString(kMaxByte);
return (DeviceFiles::CertificateState)fdp_->ConsumeIntegralInRange<int32_t>(
kMinEnum, kMaxEnum);
}
private:
FuzzedDataProvider *mFdp;
FuzzedDataProvider *fdp_;
};
class FuzzFile : public File {
public:
FuzzFile(FuzzedDataProvider *fdp) : mFdp(fdp) {}
FuzzFile(FuzzedDataProvider *fdp) : fdp_(fdp) {}
ssize_t Read(char *buffer, size_t bytes) {
std::vector<char> initData = mFdp->ConsumeBytes<char>(
mFdp->ConsumeIntegralInRange<size_t>(kMinByte, bytes));
buffer = initData.data();
return initData.size();
std::vector<char> init_data = fdp_->ConsumeBytes<char>(
fdp_->ConsumeIntegralInRange<size_t>(kMinByte, bytes));
buffer = init_data.data();
return init_data.size();
};
ssize_t Write(const char * /* buffer*/, size_t bytes) {
return mFdp->ConsumeIntegralInRange<ssize_t>(kMinByte, bytes);
return fdp_->ConsumeIntegralInRange<ssize_t>(kMinByte, bytes);
};
private:
FuzzedDataProvider *mFdp;
FuzzedDataProvider *fdp_;
};
class FuzzFileSystem : public FileSystem {
public:
FuzzFileSystem(FuzzedDataProvider *fdp) : mFdp(fdp) {}
FuzzFileSystem(FuzzedDataProvider *fdp) : fdp_(fdp) {}
std::unique_ptr<File> Open(const std::string &, int) {
return std::unique_ptr<File>(new FuzzFile(mFdp));
return std::unique_ptr<File>(new FuzzFile(fdp_));
}
bool Exists(const std::string &) { return mFdp->ConsumeBool(); }
bool Exists(const std::string &) { return fdp_->ConsumeBool(); }
bool Remove(const std::string &) { return mFdp->ConsumeBool(); }
bool Remove(const std::string &) { return fdp_->ConsumeBool(); }
ssize_t FileSize(const std::string &) {
return mFdp->ConsumeIntegralInRange<ssize_t>(kMinByte, kMaxByte);
return fdp_->ConsumeIntegralInRange<ssize_t>(kMinByte, kMaxByte);
}
bool List(const std::string &, std::vector<std::string> *) {
return mFdp->ConsumeBool();
return fdp_->ConsumeBool();
}
private:
FuzzedDataProvider *mFdp;
FuzzedDataProvider *fdp_;
};
class FuzzCryptoSession : public CryptoSession {
public:
FuzzCryptoSession(metrics::CryptoMetrics *metrics, FuzzedDataProvider *fdp)
: CryptoSession(metrics) {
mFdp = fdp;
fdp_ = fdp;
}
~FuzzCryptoSession() override {}
bool IsOpen() override { return mFdp->ConsumeBool(); }
bool IsOpen() override { return fdp_->ConsumeBool(); }
bool GetCachedSystemId(uint32_t * /*system_id*/) override {
return mFdp->ConsumeBool();
return fdp_->ConsumeBool();
}
void SetSystemId(uint32_t /*system_id*/) override {}
CdmSecurityLevel GetSecurityLevel(RequestedSecurityLevel /*level*/) override {
return (CdmSecurityLevel)mFdp->ConsumeIntegralInRange(kMinEnum, kMaxEnum);
return (CdmSecurityLevel)fdp_->ConsumeIntegralInRange(kMinEnum, kMaxEnum);
}
CdmResponseType
GetProvisioningMethod(RequestedSecurityLevel /*level*/,
CdmClientTokenType *tokenType) override {
*tokenType =
(CdmClientTokenType)mFdp->ConsumeIntegralInRange(kMinEnum, kMaxEnum);
CdmResponseType GetProvisioningMethod(
RequestedSecurityLevel /*level*/,
CdmClientTokenType *token_type) override {
*token_type =
(CdmClientTokenType)fdp_->ConsumeIntegralInRange(kMinEnum, kMaxEnum);
return CdmResponseType(
mFdp->PickValueInArray<CdmResponseEnum>(kCdmResponseEnums));
fdp_->PickValueInArray<CdmResponseEnum>(kCdmResponseEnums));
}
CdmResponseType GetTokenFromKeybox(RequestedSecurityLevel /*level*/,
std::string *keyData) override {
*keyData = mFdp->ConsumeRandomLengthString(kMaxByte);
std::string *key_data) override {
*key_data = fdp_->ConsumeRandomLengthString(kMaxByte);
return CdmResponseType(
mFdp->PickValueInArray<CdmResponseEnum>(kCdmResponseEnums));
fdp_->PickValueInArray<CdmResponseEnum>(kCdmResponseEnums));
}
CdmResponseType GetTokenFromOemCert(RequestedSecurityLevel /*level*/,
std::string *oemCert) override {
*oemCert = mFdp->ConsumeRandomLengthString(kMaxByte);
std::string *oem_cert) override {
*oem_cert = fdp_->ConsumeRandomLengthString(kMaxByte);
return CdmResponseType(
mFdp->PickValueInArray<CdmResponseEnum>(kCdmResponseEnums));
fdp_->PickValueInArray<CdmResponseEnum>(kCdmResponseEnums));
}
void SetSystemIdBase(uint32_t /* system_id*/) {}
private:
FuzzedDataProvider *mFdp;
FuzzedDataProvider *fdp_;
};
class SystemIdExtractorFuzzer {
public:
SystemIdExtractorFuzzer(const uint8_t *data, size_t size)
: mFdp(data, size){};
void process();
: fdp_(data, size){};
void Process();
private:
FuzzedDataProvider mFdp;
FuzzedDataProvider fdp_;
};
void SystemIdExtractorFuzzer::process() {
void SystemIdExtractorFuzzer::Process() {
FuzzFileSystem fuzz_file_system(&fdp_);
metrics::CryptoMetrics crypto_metrics;
FuzzDeviceFiles device_files(&fuzz_file_system, &fdp_);
FuzzFileSystem fuzzFileSystem(&mFdp);
metrics::CryptoMetrics cryptoMetrics;
FuzzDeviceFiles deviceFiles(&fuzzFileSystem, &mFdp);
RequestedSecurityLevel securityLevel =
(RequestedSecurityLevel)mFdp.ConsumeIntegralInRange(
RequestedSecurityLevel security_level =
(RequestedSecurityLevel)fdp_.ConsumeIntegralInRange(
kMinRequestedSecurityLevel, kMaxRequestedSecurityLevel);
std::unique_ptr<FuzzCryptoSession> cryptoSessions =
std::make_unique<FuzzCryptoSession>(&cryptoMetrics, &mFdp);
std::unique_ptr<FuzzCryptoSession> crypto_sessions =
std::make_unique<FuzzCryptoSession>(&crypto_metrics, &fdp_);
std::unique_ptr<SystemIdExtractor> systemIdExtractor =
std::make_unique<SystemIdExtractor>(securityLevel, cryptoSessions.get(),
&fuzzFileSystem);
std::unique_ptr<SystemIdExtractor> system_id_extractor =
std::make_unique<SystemIdExtractor>(security_level, crypto_sessions.get(),
&fuzz_file_system);
while (mFdp.remaining_bytes()) {
auto invokeSystemIdExtractorAPI = mFdp.PickValueInArray<
const std::function<void()>>({
while (fdp_.remaining_bytes()) {
auto invoke_system_id_extractor_API =
fdp_.PickValueInArray<const std::function<void()>>({
[&]() {
uint32_t systemId;
systemId = mFdp.ConsumeIntegralInRange<uint32_t>(kMinByte, kMaxByte);
systemIdExtractor->ExtractSystemId(&systemId);
uint32_t system_id;
system_id =
fdp_.ConsumeIntegralInRange<uint32_t>(kMinByte, kMaxByte);
system_id_extractor->ExtractSystemId(&system_id);
},
[&]() {
uint32_t systemId;
systemId = mFdp.ConsumeIntegralInRange<uint32_t>(kMinByte, kMaxByte);
const std::string keyData = mFdp.ConsumeRandomLengthString(kMaxByte);
systemIdExtractor->ExtractSystemIdFromKeyboxData(keyData, &systemId);
uint32_t system_id;
system_id =
fdp_.ConsumeIntegralInRange<uint32_t>(kMinByte, kMaxByte);
const std::string key_data =
fdp_.ConsumeRandomLengthString(kMaxByte);
system_id_extractor->ExtractSystemIdFromKeyboxData(key_data,
&system_id);
},
[&]() {
uint32_t systemId;
systemId = mFdp.ConsumeIntegralInRange<uint32_t>(kMinByte, kMaxByte);
const std::string oemCert = mFdp.ConsumeRandomLengthString(kMaxByte);
systemIdExtractor->ExtractSystemIdFromOemCert(oemCert, &systemId);
uint32_t system_id;
system_id =
fdp_.ConsumeIntegralInRange<uint32_t>(kMinByte, kMaxByte);
const std::string oem_cert =
fdp_.ConsumeRandomLengthString(kMaxByte);
system_id_extractor->ExtractSystemIdFromOemCert(oem_cert, &system_id);
},
[&]() {
system_id_extractor->SetDeviceFilesForTesting(&device_files);
},
[&]() { systemIdExtractor->SetDeviceFilesForTesting(&deviceFiles); },
});
invokeSystemIdExtractorAPI();
invoke_system_id_extractor_API();
}
}
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
SystemIdExtractorFuzzer systemIdExtractorFuzzer(data, size);
systemIdExtractorFuzzer.process();
SystemIdExtractorFuzzer system_id_extractor_fuzzer(data, size);
system_id_extractor_fuzzer.Process();
return 0;
}