Updated cdm_session_fuzzer
Implemented google c++ code style changes for cdm_session_fuzzer exec/s: 21 Test: ./cdm_session_fuzzer Bug: 312374669 Change-Id: I4dd20d3120876dd12b599ebf6fe8aa43dc0207f9
This commit is contained in:
Onkar Shinde
committed by
Aditya Wazir
Aditya Wazir
parent
f3c22ff3f1
commit
02441b620f
@@ -56,64 +56,64 @@ class FuzzEventListener : public WvCdmEventListener {
|
||||
|
||||
class CdmSessionFuzzer {
|
||||
public:
|
||||
CdmSessionFuzzer(const uint8_t *data, size_t size) : mFdp(data, size){};
|
||||
void process();
|
||||
CdmSessionFuzzer(const uint8_t *data, size_t size) : fdp_(data, size){};
|
||||
void Process();
|
||||
|
||||
private:
|
||||
FuzzedDataProvider mFdp;
|
||||
void invokeCdmSessionAPIs(CdmSession *cdmSession);
|
||||
void invokeCdmSessionMapAPIs();
|
||||
FuzzedDataProvider fdp_;
|
||||
void InvokeCdmSessionAPIs(CdmSession *cdm_session);
|
||||
void InvokeCdmSessionMapAPIs();
|
||||
CdmResponseType
|
||||
initCdmSession(CdmSession *cdmSession,
|
||||
FuzzCdmClientPropertySet *fuzzCdmClientPropertySet,
|
||||
CdmSessionId forcedsessionId,
|
||||
FuzzEventListener *fuzzeventListener, bool forcedLevel);
|
||||
void createResponse(CdmKeyResponse *response);
|
||||
void setLicenseMsg(std::string *msg);
|
||||
void storeLicense(DeviceFiles::CdmLicenseData licenseData);
|
||||
InitCdmSession(CdmSession *cdm_session,
|
||||
FuzzCdmClientPropertySet *fuzz_cdm_client_property_set,
|
||||
CdmSessionId forced_session_id,
|
||||
FuzzEventListener *fuzz_event_listener, bool forced_level);
|
||||
void CreateResponse(CdmKeyResponse *response);
|
||||
void SetLicenseMsg(std::string *msg);
|
||||
void StoreLicense(DeviceFiles::CdmLicenseData license_data);
|
||||
};
|
||||
|
||||
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_;
|
||||
};
|
||||
|
||||
void policySetBool(std::function<void(bool)> function,
|
||||
@@ -123,446 +123,446 @@ void policySetBool(std::function<void(bool)> function,
|
||||
}
|
||||
}
|
||||
|
||||
void CdmSessionFuzzer::setLicenseMsg(std::string *msg) {
|
||||
void CdmSessionFuzzer::SetLicenseMsg(std::string *msg) {
|
||||
video_widevine::License license;
|
||||
|
||||
if (mFdp.ConsumeBool()) {
|
||||
if (fdp_.ConsumeBool()) {
|
||||
std::string provider_client_token =
|
||||
mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
license.set_provider_client_token(provider_client_token);
|
||||
}
|
||||
if (mFdp.ConsumeBool()) {
|
||||
uint32_t scheme = mFdp.ConsumeIntegral<uint32_t>();
|
||||
if (fdp_.ConsumeBool()) {
|
||||
uint32_t scheme = fdp_.ConsumeIntegral<uint32_t>();
|
||||
license.set_protection_scheme(scheme);
|
||||
}
|
||||
|
||||
video_widevine::License::KeyContainer *container = license.add_key();
|
||||
|
||||
if (mFdp.ConsumeBool()) {
|
||||
uint32_t keyType = mFdp.ConsumeIntegralInRange<uint8_t>(
|
||||
if (fdp_.ConsumeBool()) {
|
||||
uint32_t key_type = fdp_.ConsumeIntegralInRange<uint8_t>(
|
||||
video_widevine::License::KeyContainer::SIGNING,
|
||||
video_widevine::License::KeyContainer::ENTITLEMENT);
|
||||
container->set_type((video_widevine::License_KeyContainer_KeyType)keyType);
|
||||
container->set_type((video_widevine::License_KeyContainer_KeyType)key_type);
|
||||
}
|
||||
|
||||
if (mFdp.ConsumeBool()) {
|
||||
if (fdp_.ConsumeBool()) {
|
||||
container->mutable_iv();
|
||||
}
|
||||
|
||||
if (mFdp.ConsumeBool()) {
|
||||
std::string keyString = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
container->set_key(keyString);
|
||||
if (fdp_.ConsumeBool()) {
|
||||
std::string key_string = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
container->set_key(key_string);
|
||||
}
|
||||
|
||||
if (mFdp.ConsumeBool()) {
|
||||
if (fdp_.ConsumeBool()) {
|
||||
container->mutable_id();
|
||||
}
|
||||
|
||||
if (mFdp.ConsumeBool()) {
|
||||
if (fdp_.ConsumeBool()) {
|
||||
container->mutable_track_label();
|
||||
}
|
||||
|
||||
video_widevine::License_KeyContainer_KeyControl *keyControl =
|
||||
video_widevine::License_KeyContainer_KeyControl *key_control =
|
||||
container->mutable_key_control();
|
||||
if (mFdp.ConsumeBool()) {
|
||||
keyControl->mutable_key_control_block();
|
||||
if (fdp_.ConsumeBool()) {
|
||||
key_control->mutable_key_control_block();
|
||||
}
|
||||
|
||||
if (mFdp.ConsumeBool()) {
|
||||
keyControl->mutable_iv();
|
||||
if (fdp_.ConsumeBool()) {
|
||||
key_control->mutable_iv();
|
||||
}
|
||||
|
||||
if (mFdp.ConsumeBool()) {
|
||||
if (fdp_.ConsumeBool()) {
|
||||
video_widevine::License_Policy *policy = license.mutable_policy();
|
||||
policySetBool(std::bind(&video_widevine::License_Policy::set_can_persist,
|
||||
policy, std::placeholders::_1),
|
||||
&mFdp);
|
||||
if (mFdp.ConsumeBool()) {
|
||||
std::string server_url = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
&fdp_);
|
||||
if (fdp_.ConsumeBool()) {
|
||||
std::string server_url = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
policy->set_renewal_server_url(server_url);
|
||||
}
|
||||
policySetBool(
|
||||
std::bind(&video_widevine::License_Policy::set_always_include_client_id,
|
||||
policy, std::placeholders::_1),
|
||||
&mFdp);
|
||||
&fdp_);
|
||||
}
|
||||
|
||||
LicenseIdentification *id = license.mutable_id();
|
||||
if (mFdp.ConsumeBool()) {
|
||||
id->set_type(mFdp.ConsumeBool() ? video_widevine::STREAMING
|
||||
if (fdp_.ConsumeBool()) {
|
||||
id->set_type(fdp_.ConsumeBool() ? video_widevine::STREAMING
|
||||
: video_widevine::OFFLINE);
|
||||
}
|
||||
if (mFdp.ConsumeBool()) {
|
||||
if (fdp_.ConsumeBool()) {
|
||||
std::string provider_session_token =
|
||||
mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
id->set_provider_session_token(provider_session_token);
|
||||
}
|
||||
license.SerializeToString(msg);
|
||||
}
|
||||
|
||||
void CdmSessionFuzzer::createResponse(CdmKeyResponse *response) {
|
||||
void CdmSessionFuzzer::CreateResponse(CdmKeyResponse *response) {
|
||||
video_widevine::SignedMessage signed_message;
|
||||
video_widevine::SignedMessage type;
|
||||
signed_message.set_type(video_widevine::SignedMessage::LICENSE);
|
||||
signed_message.mutable_service_version_info();
|
||||
std::string sign = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
std::string sign = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
sign.resize(kMaxId, '0');
|
||||
signed_message.set_signature(sign);
|
||||
std::string key = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
std::string key = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
key.resize(kMaxId, '0');
|
||||
signed_message.set_session_key(key);
|
||||
std::string message = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
std::string message = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
message.resize(kMaxId, '0');
|
||||
signed_message.set_oemcrypto_core_message(message);
|
||||
signed_message.set_using_secondary_key(mFdp.ConsumeBool());
|
||||
std::string setMsg = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
signed_message.set_msg(setMsg);
|
||||
signed_message.set_using_secondary_key(fdp_.ConsumeBool());
|
||||
std::string set_msg = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
signed_message.set_msg(set_msg);
|
||||
signed_message.SerializeToString(response);
|
||||
}
|
||||
|
||||
CdmResponseType CdmSessionFuzzer::initCdmSession(
|
||||
CdmSession *cdmSession, FuzzCdmClientPropertySet *fuzzCdmClientPropertySet,
|
||||
CdmSessionId forcedsessionId, FuzzEventListener *fuzzeventListener,
|
||||
bool forcedLevel) {
|
||||
CdmResponseType CdmSessionFuzzer::InitCdmSession(
|
||||
CdmSession *cdm_session, FuzzCdmClientPropertySet *fuzz_cdm_client_property_set,
|
||||
CdmSessionId forced_session_id, FuzzEventListener *fuzz_event_listener,
|
||||
bool forced_level) {
|
||||
CdmResponseType result;
|
||||
if (mFdp.ConsumeBool()) {
|
||||
if (fdp_.ConsumeBool()) {
|
||||
result =
|
||||
cdmSession->Init(fuzzCdmClientPropertySet /*cdm_client_property_set*/,
|
||||
&forcedsessionId /*forced_session_id*/,
|
||||
fuzzeventListener /*event_listener*/, forcedLevel);
|
||||
cdm_session->Init(fuzz_cdm_client_property_set /*cdm_client_property_set*/,
|
||||
&forced_session_id /*forced_session_id*/,
|
||||
fuzz_event_listener /*event_listener*/, forced_level);
|
||||
} else {
|
||||
result =
|
||||
cdmSession->Init(fuzzCdmClientPropertySet /*cdm_client_property_set*/);
|
||||
cdm_session->Init(fuzz_cdm_client_property_set /*cdm_client_property_set*/);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void CdmSessionFuzzer::storeLicense(DeviceFiles::CdmLicenseData licenseData) {
|
||||
FuzzFileSystem fileSystemdev(&mFdp);
|
||||
DeviceFiles deviceFiles(mFdp.ConsumeBool() ? &fileSystemdev : nullptr);
|
||||
deviceFiles.Init((CdmSecurityLevel)mFdp.ConsumeIntegralInRange<int32_t>(
|
||||
void CdmSessionFuzzer::StoreLicense(DeviceFiles::CdmLicenseData license_data) {
|
||||
FuzzFileSystem file_system_dev(&fdp_);
|
||||
DeviceFiles deviceFiles(fdp_.ConsumeBool() ? &file_system_dev : nullptr);
|
||||
deviceFiles.Init((CdmSecurityLevel)fdp_.ConsumeIntegralInRange<int32_t>(
|
||||
kSecurityLevelL1, kSecurityLevelL3));
|
||||
std::map<std::string, std::string> appParameters;
|
||||
std::map<std::string, std::string> app_parameters;
|
||||
|
||||
appParameters[mFdp.ConsumeBytesAsString(kMaxByte)] =
|
||||
mFdp.ConsumeBytesAsString(kMaxByte);
|
||||
licenseData.key_set_id =
|
||||
std::to_string(mFdp.ConsumeIntegralInRange(kMinId, kMaxId));
|
||||
licenseData.state =
|
||||
(CdmOfflineLicenseState)mFdp.ConsumeIntegralInRange<int32_t>(
|
||||
app_parameters[fdp_.ConsumeBytesAsString(kMaxByte)] =
|
||||
fdp_.ConsumeBytesAsString(kMaxByte);
|
||||
license_data.key_set_id =
|
||||
std::to_string(fdp_.ConsumeIntegralInRange(kMinId, kMaxId));
|
||||
license_data.state =
|
||||
(CdmOfflineLicenseState)fdp_.ConsumeIntegralInRange<int32_t>(
|
||||
kLicenseStateActive, kLicenseStateUnknown);
|
||||
licenseData.pssh_data = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
licenseData.license_request = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
licenseData.license = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
licenseData.license_renewal_request =
|
||||
mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
licenseData.license_renewal = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
licenseData.release_server_url = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
licenseData.playback_start_time = mFdp.ConsumeIntegral<int64_t>();
|
||||
licenseData.last_playback_time = mFdp.ConsumeIntegral<int64_t>();
|
||||
licenseData.grace_period_end_time = mFdp.ConsumeIntegral<int64_t>();
|
||||
licenseData.app_parameters = appParameters;
|
||||
licenseData.usage_entry = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
licenseData.usage_entry_index = mFdp.ConsumeIntegral<uint32_t>();
|
||||
licenseData.drm_certificate = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
licenseData.wrapped_private_key = CryptoWrappedKey(
|
||||
(CryptoWrappedKey::Type)mFdp.ConsumeIntegralInRange<int32_t>(
|
||||
license_data.pssh_data = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
license_data.license_request = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
license_data.license = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
license_data.license_renewal_request =
|
||||
fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
license_data.license_renewal = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
license_data.release_server_url = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
license_data.playback_start_time = fdp_.ConsumeIntegral<int64_t>();
|
||||
license_data.last_playback_time = fdp_.ConsumeIntegral<int64_t>();
|
||||
license_data.grace_period_end_time = fdp_.ConsumeIntegral<int64_t>();
|
||||
license_data.app_parameters = app_parameters;
|
||||
license_data.usage_entry = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
license_data.usage_entry_index = fdp_.ConsumeIntegral<uint32_t>();
|
||||
license_data.drm_certificate = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
license_data.wrapped_private_key = CryptoWrappedKey(
|
||||
(CryptoWrappedKey::Type)fdp_.ConsumeIntegralInRange<int32_t>(
|
||||
CryptoWrappedKey::kUninitialized, CryptoWrappedKey::kEcc),
|
||||
mFdp.ConsumeRandomLengthString(kMaxByte));
|
||||
fdp_.ConsumeRandomLengthString(kMaxByte));
|
||||
|
||||
DeviceFiles::ResponseType result;
|
||||
deviceFiles.StoreLicense(licenseData, &result);
|
||||
deviceFiles.StoreLicense(license_data, &result);
|
||||
}
|
||||
|
||||
void CdmSessionFuzzer::invokeCdmSessionAPIs(CdmSession *cdmSession) {
|
||||
void CdmSessionFuzzer::InvokeCdmSessionAPIs(CdmSession *cdm_session) {
|
||||
CdmKeyResponse response;
|
||||
createResponse(&response);
|
||||
CdmKeyRequest keyRequest;
|
||||
CdmKeyMessage signedRequest;
|
||||
keyRequest.message = signedRequest;
|
||||
keyRequest.type = (CdmKeyRequestType)mFdp.ConsumeIntegralInRange<int32_t>(
|
||||
CreateResponse(&response);
|
||||
CdmKeyRequest key_request;
|
||||
CdmKeyMessage signed_request;
|
||||
key_request.message = signed_request;
|
||||
key_request.type = (CdmKeyRequestType)fdp_.ConsumeIntegralInRange<int32_t>(
|
||||
kKeyRequestTypeUnknown, kKeyRequestTypeRelease);
|
||||
std::string url;
|
||||
keyRequest.url = url;
|
||||
while (mFdp.remaining_bytes()) {
|
||||
auto invokeCdmSessionAPI = mFdp.PickValueInArray<
|
||||
key_request.url = url;
|
||||
while (fdp_.remaining_bytes()) {
|
||||
auto invokeCdmSessionAPI = fdp_.PickValueInArray<
|
||||
const std::function<void()>>(
|
||||
{[&]() { cdmSession->AddKey(response /*key_response*/); },
|
||||
{[&]() { cdm_session->AddKey(response /*key_response*/); },
|
||||
[&]() {
|
||||
FuzzCdmClientPropertySet propertyset(&mFdp);
|
||||
propertyset.enable_privacy_mode();
|
||||
propertyset.set_service_certificate(kTestSignedCertificate);
|
||||
FuzzCdmClientPropertySet property_set(&fdp_);
|
||||
property_set.enable_privacy_mode();
|
||||
property_set.set_service_certificate(kTestSignedCertificate);
|
||||
PropertiesTestPeer::ForceReinit();
|
||||
PropertiesTestPeer::AddSessionPropertySet(
|
||||
mFdp.ConsumeBool() ? kTestSessionId1
|
||||
: mFdp.ConsumeRandomLengthString(kMaxByte),
|
||||
&propertyset);
|
||||
std::string rawServiceCertificate;
|
||||
fdp_.ConsumeBool() ? kTestSessionId1
|
||||
: fdp_.ConsumeRandomLengthString(kMaxByte),
|
||||
&property_set);
|
||||
std::string raw_service_certificate;
|
||||
PropertiesTestPeer::GetServiceCertificate(
|
||||
mFdp.ConsumeBool() ? kTestSessionId1
|
||||
: mFdp.ConsumeRandomLengthString(kMaxByte),
|
||||
&rawServiceCertificate);
|
||||
cdmSession->SetServiceCertificate(
|
||||
rawServiceCertificate /*service_certificate*/);
|
||||
fdp_.ConsumeBool() ? kTestSessionId1
|
||||
: fdp_.ConsumeRandomLengthString(kMaxByte),
|
||||
&raw_service_certificate);
|
||||
cdm_session->SetServiceCertificate(
|
||||
raw_service_certificate /*service_certificate*/);
|
||||
},
|
||||
[&]() {
|
||||
CdmQueryMap queryResponse;
|
||||
cdmSession->QueryKeyStatus(&queryResponse /*query_response*/);
|
||||
CdmQueryMap query_response;
|
||||
cdm_session->QueryKeyStatus(&query_response /*query_response*/);
|
||||
},
|
||||
[&]() {
|
||||
const std::string oecVersion = std::to_string(
|
||||
mFdp.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
std::string dataType = mFdp.PickValueInArray(kInitType);
|
||||
std::unique_ptr<InitializationData> initData(new InitializationData(
|
||||
dataType, a2bs_hex(mFdp.ConsumeRandomLengthString(kMaxByte)),
|
||||
oecVersion));
|
||||
CdmLicenseType licenseType =
|
||||
(CdmLicenseType)mFdp.ConsumeIntegralInRange<int32_t>(
|
||||
const std::string oec_version = std::to_string(
|
||||
fdp_.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
std::string data_type = fdp_.PickValueInArray(kInitType);
|
||||
std::unique_ptr<InitializationData> init_data(new InitializationData(
|
||||
data_type, a2bs_hex(fdp_.ConsumeRandomLengthString(kMaxByte)),
|
||||
oec_version));
|
||||
CdmLicenseType license_type =
|
||||
(CdmLicenseType)fdp_.ConsumeIntegralInRange<int32_t>(
|
||||
kLicenseTypeOffline, kLicenseTypeEmbeddedKeyData);
|
||||
CdmAppParameterMap appParameters;
|
||||
cdmSession->GenerateKeyRequest(
|
||||
*initData /*init_data*/, licenseType /*license_type*/,
|
||||
appParameters /*app_parameters*/, &keyRequest /*key_request*/);
|
||||
CdmAppParameterMap app_parameters;
|
||||
cdm_session->GenerateKeyRequest(
|
||||
*init_data /*init_data*/, license_type /*license_type*/,
|
||||
app_parameters /*app_parameters*/, &key_request /*key_request*/);
|
||||
},
|
||||
[&]() {
|
||||
CdmQueryMap queryResponse;
|
||||
cdmSession->QueryStatus(&queryResponse /*query_response*/);
|
||||
CdmQueryMap query_response;
|
||||
cdm_session->QueryStatus(&query_response /*query_response*/);
|
||||
},
|
||||
[&]() {
|
||||
DeviceFiles::CdmLicenseData licenseData;
|
||||
storeLicense(licenseData);
|
||||
std::string randomData = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
const CdmKeySetId keySetId =
|
||||
mFdp.ConsumeBool()
|
||||
? (kKeyId + wvutil::b2a_hex(randomData))
|
||||
DeviceFiles::CdmLicenseData license_data;
|
||||
StoreLicense(license_data);
|
||||
std::string random_data = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
const CdmKeySetId key_set_id =
|
||||
fdp_.ConsumeBool()
|
||||
? (kKeyId + wvutil::b2a_hex(random_data))
|
||||
: std::to_string(
|
||||
mFdp.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
CdmLicenseType licenseType =
|
||||
(CdmLicenseType)mFdp.ConsumeIntegralInRange<int32_t>(
|
||||
fdp_.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
CdmLicenseType license_type =
|
||||
(CdmLicenseType)fdp_.ConsumeIntegralInRange<int32_t>(
|
||||
kLicenseTypeOffline, kLicenseTypeEmbeddedKeyData);
|
||||
int errorDetail = mFdp.ConsumeIntegral<int32_t>();
|
||||
cdmSession->RestoreOfflineSession(keySetId /*key_set_id*/,
|
||||
licenseType /*license_type*/,
|
||||
&errorDetail /*error_detail*/);
|
||||
int error_detail = fdp_.ConsumeIntegral<int32_t>();
|
||||
cdm_session->RestoreOfflineSession(key_set_id /*key_set_id*/,
|
||||
license_type /*license_type*/,
|
||||
&error_detail /*error_detail*/);
|
||||
},
|
||||
[&]() {
|
||||
DeviceFiles::CdmUsageData usageData;
|
||||
usageData.provider_session_token =
|
||||
mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
usageData.license_request = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
usageData.license = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
std::string randomData = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
usageData.key_set_id =
|
||||
mFdp.ConsumeBool()
|
||||
? (kKeyId + wvutil::b2a_hex(randomData))
|
||||
DeviceFiles::CdmUsageData usage_Data;
|
||||
usage_Data.provider_session_token =
|
||||
fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
usage_Data.license_request = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
usage_Data.license = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
std::string random_data = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
usage_Data.key_set_id =
|
||||
fdp_.ConsumeBool()
|
||||
? (kKeyId + wvutil::b2a_hex(random_data))
|
||||
: std::to_string(
|
||||
mFdp.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
usageData.usage_entry = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
usageData.usage_entry_index = mFdp.ConsumeIntegral<uint32_t>();
|
||||
usageData.drm_certificate = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
usageData.wrapped_private_key = CryptoWrappedKey(
|
||||
(CryptoWrappedKey::Type)mFdp.ConsumeIntegralInRange<int32_t>(
|
||||
fdp_.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
usage_Data.usage_entry = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
usage_Data.usage_entry_index = fdp_.ConsumeIntegral<uint32_t>();
|
||||
usage_Data.drm_certificate = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
usage_Data.wrapped_private_key = CryptoWrappedKey(
|
||||
(CryptoWrappedKey::Type)fdp_.ConsumeIntegralInRange<int32_t>(
|
||||
CryptoWrappedKey::kUninitialized, CryptoWrappedKey::kEcc),
|
||||
mFdp.ConsumeRandomLengthString(kMaxByte));
|
||||
int errorDetail = mFdp.ConsumeIntegral<int32_t>();
|
||||
cdmSession->RestoreUsageSession(usageData /*usage_data*/,
|
||||
&errorDetail /*error_detail*/);
|
||||
fdp_.ConsumeRandomLengthString(kMaxByte));
|
||||
int error_detail = fdp_.ConsumeIntegral<int32_t>();
|
||||
cdm_session->RestoreUsageSession(usage_Data /*usage_data*/,
|
||||
&error_detail /*error_detail*/);
|
||||
},
|
||||
[&]() {
|
||||
const std::string keyId = std::to_string(
|
||||
mFdp.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
CdmKeyAllowedUsage keyUsage;
|
||||
cdmSession->QueryKeyAllowedUsage(keyId /*key_id*/,
|
||||
&keyUsage /*key_usage*/);
|
||||
const std::string key_id = std::to_string(
|
||||
fdp_.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
CdmKeyAllowedUsage key_usage;
|
||||
cdm_session->QueryKeyAllowedUsage(key_id /*key_id*/,
|
||||
&key_usage /*key_usage*/);
|
||||
},
|
||||
[&]() {
|
||||
CdmQueryMap queryResponse;
|
||||
cdmSession->QueryOemCryptoSessionId(
|
||||
&queryResponse /*query_response*/);
|
||||
CdmQueryMap query_response;
|
||||
cdm_session->QueryOemCryptoSessionId(
|
||||
&query_response /*query_response*/);
|
||||
},
|
||||
[&]() {
|
||||
const KeyId keyId = std::to_string(
|
||||
mFdp.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
CdmDecryptionParametersV16 params(keyId);
|
||||
const uint8_t encryptBufferParam = mFdp.ConsumeIntegral<uint8_t>();
|
||||
void *decryptBufferParam;
|
||||
size_t decryptbufferOffsetParam = mFdp.ConsumeIntegral<size_t>();
|
||||
size_t length = mFdp.ConsumeIntegral<size_t>();
|
||||
const std::vector<uint8_t> iv = mFdp.ConsumeBytes<uint8_t>(kMaxSize);
|
||||
CdmDecryptionSample sample(&encryptBufferParam, decryptBufferParam,
|
||||
decryptbufferOffsetParam, length, iv);
|
||||
CdmDecryptionSubsample subsample(mFdp.ConsumeIntegral<size_t>(),
|
||||
mFdp.ConsumeIntegral<size_t>());
|
||||
sample.subsamples.push_back(subsample);
|
||||
const KeyId key_id = std::to_string(
|
||||
fdp_.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
CdmDecryptionParametersV16 params(key_id);
|
||||
const uint8_t encrypt_buffer_param = fdp_.ConsumeIntegral<uint8_t>();
|
||||
void *decrypt_buffer_param;
|
||||
size_t decrypt_buffer_offset_param = fdp_.ConsumeIntegral<size_t>();
|
||||
size_t length = fdp_.ConsumeIntegral<size_t>();
|
||||
const std::vector<uint8_t> iv = fdp_.ConsumeBytes<uint8_t>(kMaxSize);
|
||||
CdmDecryptionSample sample(&encrypt_buffer_param, decrypt_buffer_param,
|
||||
decrypt_buffer_offset_param, length, iv);
|
||||
CdmDecryptionSubsample sub_sample(fdp_.ConsumeIntegral<size_t>(),
|
||||
fdp_.ConsumeIntegral<size_t>());
|
||||
sample.subsamples.push_back(sub_sample);
|
||||
params.samples.push_back(sample);
|
||||
cdmSession->Decrypt(params /*parameters*/);
|
||||
cdm_session->Decrypt(params /*parameters*/);
|
||||
},
|
||||
[&]() {
|
||||
cdmSession->GenerateRenewalRequest(&keyRequest /*key_request*/);
|
||||
cdm_session->GenerateRenewalRequest(&key_request /*key_request*/);
|
||||
},
|
||||
[&]() { cdmSession->RenewKey(response /*key_response*/); },
|
||||
[&]() { cdm_session->RenewKey(response /*key_response*/); },
|
||||
[&]() {
|
||||
const KeyId keyId = std::to_string(
|
||||
mFdp.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
cdmSession->IsKeyLoaded(keyId /*key_id*/);
|
||||
const KeyId key_id = std::to_string(
|
||||
fdp_.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
cdm_session->IsKeyLoaded(key_id /*key_id*/);
|
||||
},
|
||||
[&]() { cdmSession->GetDurationRemaining(); },
|
||||
[&]() { cdm_session->GetDurationRemaining(); },
|
||||
[&]() {
|
||||
cdmSession->NotifyResolution(
|
||||
mFdp.ConsumeIntegral<uint32_t>() /*width*/,
|
||||
mFdp.ConsumeIntegral<uint32_t>() /*height*/);
|
||||
cdm_session->NotifyResolution(
|
||||
fdp_.ConsumeIntegral<uint32_t>() /*width*/,
|
||||
fdp_.ConsumeIntegral<uint32_t>() /*height*/);
|
||||
},
|
||||
[&]() {
|
||||
cdmSession->OnTimerEvent(mFdp.ConsumeBool() /*update_usage*/);
|
||||
cdm_session->OnTimerEvent(fdp_.ConsumeBool() /*update_usage*/);
|
||||
},
|
||||
[&]() {
|
||||
const CdmKeySetId keySetId =
|
||||
kKeyId + mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
cdmSession->OnKeyReleaseEvent(keySetId /*key_set_id*/);
|
||||
const CdmKeySetId key_set_id =
|
||||
kKeyId + fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
cdm_session->OnKeyReleaseEvent(key_set_id /*key_set_id*/);
|
||||
},
|
||||
[&]() {
|
||||
std::string appId =
|
||||
std::string app_id =
|
||||
kSessionId +
|
||||
std::to_string(
|
||||
mFdp.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
cdmSession->GetApplicationId(&appId /*app_id*/);
|
||||
fdp_.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
cdm_session->GetApplicationId(&app_id /*app_id*/);
|
||||
},
|
||||
[&]() { cdmSession->UpdateUsageEntryInformation(); },
|
||||
[&]() { cdmSession->GenerateSessionId(); },
|
||||
[&]() { cdm_session->UpdateUsageEntryInformation(); },
|
||||
[&]() { cdm_session->GenerateSessionId(); },
|
||||
[&]() {
|
||||
const std::string inBuffer =
|
||||
mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
const std::string keyId = std::to_string(
|
||||
mFdp.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
const std::string iv = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
const std::string in_buffer =
|
||||
fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
const std::string key_id = std::to_string(
|
||||
fdp_.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
const std::string iv = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
CdmEncryptionAlgorithm algorithm =
|
||||
mFdp.ConsumeBool()
|
||||
fdp_.ConsumeBool()
|
||||
? CdmEncryptionAlgorithm::kEncryptionAlgorithmAesCbc128
|
||||
: CdmEncryptionAlgorithm::kEncryptionAlgorithmUnknown;
|
||||
std::string outBuffer = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
cdmSession->GenericEncrypt(inBuffer /*in_buffer*/, keyId /*key_id*/,
|
||||
iv, algorithm, &outBuffer /*out_buffer*/);
|
||||
std::string out_buffer = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
cdm_session->GenericEncrypt(in_buffer /*in_buffer*/, key_id /*key_id*/,
|
||||
iv, algorithm, &out_buffer /*out_buffer*/);
|
||||
},
|
||||
[&]() {
|
||||
const std::string inBuffer =
|
||||
mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
const std::string keyId = std::to_string(
|
||||
mFdp.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
const std::string iv = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
const std::string in_buffer =
|
||||
fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
const std::string key_id = std::to_string(
|
||||
fdp_.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
const std::string iv = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
CdmEncryptionAlgorithm algorithm =
|
||||
mFdp.ConsumeBool()
|
||||
fdp_.ConsumeBool()
|
||||
? CdmEncryptionAlgorithm::kEncryptionAlgorithmAesCbc128
|
||||
: CdmEncryptionAlgorithm::kEncryptionAlgorithmUnknown;
|
||||
std::string outBuffer = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
cdmSession->GenericDecrypt(inBuffer /*in_buffer*/, keyId /*key_id*/,
|
||||
iv, algorithm, &outBuffer /*out_buffer*/);
|
||||
std::string out_buffer = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
cdm_session->GenericDecrypt(in_buffer /*in_buffer*/, key_id /*key_id*/,
|
||||
iv, algorithm, &out_buffer /*out_buffer*/);
|
||||
},
|
||||
[&]() {
|
||||
const std::string message = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
const std::string keyId = std::to_string(
|
||||
mFdp.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
const std::string message = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
const std::string key_id = std::to_string(
|
||||
fdp_.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
CdmSigningAlgorithm algorithm =
|
||||
mFdp.ConsumeBool()
|
||||
fdp_.ConsumeBool()
|
||||
? CdmSigningAlgorithm::kSigningAlgorithmHmacSha256
|
||||
: CdmSigningAlgorithm::kSigningAlgorithmUnknown;
|
||||
std::string signature = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
cdmSession->GenericSign(message, keyId /*key_id*/, algorithm,
|
||||
std::string signature = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
cdm_session->GenericSign(message, key_id /*key_id*/, algorithm,
|
||||
&signature);
|
||||
},
|
||||
[&]() {
|
||||
const std::string message = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
const std::string keyId = std::to_string(
|
||||
mFdp.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
const std::string message = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
const std::string key_id = std::to_string(
|
||||
fdp_.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
CdmSigningAlgorithm algorithm =
|
||||
mFdp.ConsumeBool()
|
||||
fdp_.ConsumeBool()
|
||||
? CdmSigningAlgorithm::kSigningAlgorithmHmacSha256
|
||||
: CdmSigningAlgorithm::kSigningAlgorithmUnknown;
|
||||
const std::string signature =
|
||||
mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
cdmSession->GenericVerify(message, keyId /*key_id*/, algorithm,
|
||||
fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
cdm_session->GenericVerify(message, key_id /*key_id*/, algorithm,
|
||||
signature);
|
||||
},
|
||||
[&]() {
|
||||
uint32_t frameNumber = mFdp.ConsumeIntegral<uint32_t>();
|
||||
const std::string hash = mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
cdmSession->SetDecryptHash(frameNumber /*frame_number*/, hash);
|
||||
uint32_t frame_number = fdp_.ConsumeIntegral<uint32_t>();
|
||||
const std::string hash = fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
cdm_session->SetDecryptHash(frame_number /*frame_number*/, hash);
|
||||
},
|
||||
[&]() {
|
||||
std::string hashErrorString =
|
||||
mFdp.ConsumeRandomLengthString(kMaxByte);
|
||||
cdmSession->GetDecryptHashError(
|
||||
&hashErrorString /*hash_error_string*/);
|
||||
std::string hash_error_string =
|
||||
fdp_.ConsumeRandomLengthString(kMaxByte);
|
||||
cdm_session->GetDecryptHashError(
|
||||
&hash_error_string /*hash_error_string*/);
|
||||
},
|
||||
[&]() { cdmSession->ReleaseKey(response /*key_response*/); },
|
||||
[&]() { cdm_session->ReleaseKey(response /*key_response*/); },
|
||||
[&]() {
|
||||
cdmSession->GenerateReleaseRequest(&keyRequest /*key_request*/);
|
||||
cdm_session->GenerateReleaseRequest(&key_request /*key_request*/);
|
||||
}});
|
||||
invokeCdmSessionAPI();
|
||||
}
|
||||
UsageEntryIndex entryIndex = mFdp.ConsumeIntegral<uint32_t>();
|
||||
cdmSession->DeleteUsageEntry(entryIndex /*usage_entry_index*/);
|
||||
cdmSession->DeleteLicenseFile();
|
||||
cdmSession->RemoveKeys();
|
||||
cdmSession->RemoveLicense();
|
||||
UsageEntryIndex entry_index = fdp_.ConsumeIntegral<uint32_t>();
|
||||
cdm_session->DeleteUsageEntry(entry_index /*usage_entry_index*/);
|
||||
cdm_session->DeleteLicenseFile();
|
||||
cdm_session->RemoveKeys();
|
||||
cdm_session->RemoveLicense();
|
||||
}
|
||||
|
||||
void CdmSessionFuzzer::invokeCdmSessionMapAPIs() {
|
||||
FuzzFileSystem fileSystemMap(&mFdp);
|
||||
CdmSessionMap cdmsessionMap;
|
||||
std::shared_ptr<metrics::SessionMetrics> CdmMetricsMap(
|
||||
void CdmSessionFuzzer::InvokeCdmSessionMapAPIs() {
|
||||
FuzzFileSystem file_system_map(&fdp_);
|
||||
CdmSessionMap cdm_session_map;
|
||||
std::shared_ptr<metrics::SessionMetrics> cdm_metrics_map(
|
||||
new metrics::SessionMetrics);
|
||||
CdmSession *session = new CdmSession(&fileSystemMap, CdmMetricsMap);
|
||||
const CdmSessionId forcedSessionId =
|
||||
CdmSession *session = new CdmSession(&file_system_map, cdm_metrics_map);
|
||||
const CdmSessionId forced_session_id =
|
||||
kSessionId +
|
||||
std::to_string(mFdp.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
cdmsessionMap.Add(forcedSessionId /*id*/, session /*session*/);
|
||||
while (mFdp.remaining_bytes()) {
|
||||
std::to_string(fdp_.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
cdm_session_map.Add(forced_session_id /*id*/, session /*session*/);
|
||||
while (fdp_.remaining_bytes()) {
|
||||
auto invokeCdmSessionMapAPI =
|
||||
mFdp.PickValueInArray<const std::function<void()>>({
|
||||
[&]() { cdmsessionMap.Exists(forcedSessionId /*id*/); },
|
||||
[&]() { cdmsessionMap.Size(); },
|
||||
fdp_.PickValueInArray<const std::function<void()>>({
|
||||
[&]() { cdm_session_map.Exists(forced_session_id /*id*/); },
|
||||
[&]() { cdm_session_map.Size(); },
|
||||
[&]() {
|
||||
std::shared_ptr<CdmSession> cdmsessionShared;
|
||||
cdmsessionMap.FindSession(forcedSessionId /*id*/,
|
||||
&cdmsessionShared /*session*/);
|
||||
std::shared_ptr<CdmSession> cdm_session_shared;
|
||||
cdm_session_map.FindSession(forced_session_id /*id*/,
|
||||
&cdm_session_shared /*session*/);
|
||||
},
|
||||
[&]() {
|
||||
CdmSessionList sessions;
|
||||
cdmsessionMap.GetSessionList(sessions);
|
||||
cdm_session_map.GetSessionList(sessions);
|
||||
},
|
||||
});
|
||||
invokeCdmSessionMapAPI();
|
||||
cdmsessionMap.CloseSession(forcedSessionId);
|
||||
cdm_session_map.CloseSession(forced_session_id);
|
||||
}
|
||||
}
|
||||
|
||||
void CdmSessionFuzzer::process() {
|
||||
if (mFdp.ConsumeBool()) {
|
||||
FuzzFileSystem fileSystem(&mFdp);
|
||||
FuzzEventListener fuzzeventListener;
|
||||
void CdmSessionFuzzer::Process() {
|
||||
if (fdp_.ConsumeBool()) {
|
||||
FuzzFileSystem file_system(&fdp_);
|
||||
FuzzEventListener fuzz_event_listener;
|
||||
std::shared_ptr<metrics::SessionMetrics> metrics =
|
||||
std::make_shared<metrics::SessionMetrics>();
|
||||
std::unique_ptr<CdmSession> cdmSession =
|
||||
std::make_unique<CdmSession>(&fileSystem, metrics);
|
||||
std::unique_ptr<FuzzCdmClientPropertySet> fuzzCdmClientPropertySet(
|
||||
new FuzzCdmClientPropertySet(&mFdp));
|
||||
const CdmSessionId forcedSessionId =
|
||||
std::unique_ptr<CdmSession> cdm_session =
|
||||
std::make_unique<CdmSession>(&file_system, metrics);
|
||||
std::unique_ptr<FuzzCdmClientPropertySet> fuzz_cdm_client_property_set(
|
||||
new FuzzCdmClientPropertySet(&fdp_));
|
||||
const CdmSessionId forced_session_id =
|
||||
kSessionId +
|
||||
std::to_string(mFdp.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
bool forcedLevel = mFdp.ConsumeBool();
|
||||
std::to_string(fdp_.ConsumeIntegralInRange<uint32_t>(kMinId, kMaxId));
|
||||
bool forced_level = fdp_.ConsumeBool();
|
||||
CdmResponseType result =
|
||||
initCdmSession(cdmSession.get(), fuzzCdmClientPropertySet.get(),
|
||||
forcedSessionId, &fuzzeventListener, forcedLevel);
|
||||
InitCdmSession(cdm_session.get(), fuzz_cdm_client_property_set.get(),
|
||||
forced_session_id, &fuzz_event_listener, forced_level);
|
||||
if (result == NO_ERROR) {
|
||||
invokeCdmSessionAPIs(cdmSession.get());
|
||||
InvokeCdmSessionAPIs(cdm_session.get());
|
||||
}
|
||||
} else {
|
||||
invokeCdmSessionMapAPIs();
|
||||
InvokeCdmSessionMapAPIs();
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
|
||||
CdmSessionFuzzer cdmSessionFuzzer(data, size);
|
||||
cdmSessionFuzzer.process();
|
||||
CdmSessionFuzzer cdm_session_fuzzer(data, size);
|
||||
cdm_session_fuzzer.Process();
|
||||
return 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user