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

185
fuzzer/system_id_extractor_fuzzer.cpp
View File

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