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

Updated cdm_engine_fuzzer

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

exec/s: 323
Test: ./cdm_engine_fuzzer
Bug: 312374669

Change-Id: Iddaeab285d591d77f16c10e62a88b1af3f8af7c5
This commit is contained in:
Onkar Shinde
2023-12-12 08:46:03 +00:00
committed by Aditya Wazir
parent d866ba45aa
commit c39f453c59
1 changed files with 261 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

520
fuzzer/cdm_engine_fuzzer.cpp
View File

@@ -15,18 +15,20 @@
* *
*/ */
#include "vendor_widevine_fuzz_helper.h"
#include <cdm_engine.h> #include <cdm_engine.h>
#include <cdm_engine_factory.h> #include <cdm_engine_factory.h>
#include <fstream>
#include <fuzzer/FuzzedDataProvider.h> #include <fuzzer/FuzzedDataProvider.h>
#include <iostream>
#include <stdlib.h> #include <stdlib.h>
#include <string>
#include <wv_cdm_constants.h> #include <wv_cdm_constants.h>
#include <wv_cdm_event_listener.h> #include <wv_cdm_event_listener.h>
#include <wv_cdm_types.h> #include <wv_cdm_types.h>
#include <fstream>
#include <iostream>
#include <string>
#include "vendor_widevine_fuzz_helper.h"
const int32_t kMinByte = 0; const int32_t kMinByte = 0;
const int32_t kMaxByte = 256; const int32_t kMaxByte = 256;
const int32_t kMinEnum = 0; const int32_t kMinEnum = 0;
@@ -37,9 +39,9 @@ const int32_t kMinKey = 10;
const int32_t kMaxKey = 1000; const int32_t kMaxKey = 1000;
const int32_t kMinSize = 1; const int32_t kMinSize = 1;
const int32_t kMaxSize = 100; const int32_t kMaxSize = 100;
const char* kKeySystem = "widevine"; const char *kKeySystem = "widevine";
const char* kKeySetIdPrefix = "ksid"; const char *kKeySetIdPrefix = "ksid";
const char* kEmptyString = ""; const char *kEmptyString = "";
const std::string kUsageFilePrefixL1 = "/data/vendor/mediadrm/IDM0/L1/"; const std::string kUsageFilePrefixL1 = "/data/vendor/mediadrm/IDM0/L1/";
const std::string kUsageFilePrefixL3 = "/data/vendor/mediadrm/IDM0/L3/"; const std::string kUsageFilePrefixL3 = "/data/vendor/mediadrm/IDM0/L3/";
const std::string kCertFile = kUsageFilePrefixL3 + "cert.bin"; const std::string kCertFile = kUsageFilePrefixL3 + "cert.bin";
@@ -83,7 +85,7 @@ std::string kInitType[] = {ISO_BMFF_VIDEO_MIME_TYPE, WEBM_VIDEO_MIME_TYPE,
WEBM_INIT_DATA_FORMAT}; WEBM_INIT_DATA_FORMAT};
class FuzzWvCdmEventListener : public WvCdmEventListener { class FuzzWvCdmEventListener : public WvCdmEventListener {
public: public:
void OnSessionRenewalNeeded(const CdmSessionId & /*session_id*/) {} void OnSessionRenewalNeeded(const CdmSessionId & /*session_id*/) {}
void OnSessionKeysChange(const CdmSessionId & /*session_id*/, void OnSessionKeysChange(const CdmSessionId & /*session_id*/,
const CdmKeyStatusMap & /*keys_status*/, const CdmKeyStatusMap & /*keys_status*/,
@@ -93,413 +95,413 @@ public:
}; };
class CdmEngineFuzzer { class CdmEngineFuzzer {
public: public:
CdmEngineFuzzer(const uint8_t *data, size_t size) : mFdp(data, size){}; CdmEngineFuzzer(const uint8_t *data, size_t size) : fdp_(data, size){};
void process(); void Process();
void init(CdmEngine *cdmEngine); void Init(CdmEngine *cdm_engine);
void createUsageFile(std::string mAppId); void CreateUsageFiles(std::string app_id_);
std::vector<std::string> createVector(bool enableKeySetId); std::vector<std::string> CreateVector(bool enable_key_set_id);
private: private:
FuzzedDataProvider mFdp; FuzzedDataProvider fdp_;
std::ofstream mOutCertFile1; std::ofstream out_cert_file_1_;
std::ofstream mOutCertFile2; std::ofstream out_cert_file_2_;
std::ofstream mOutUsageFile1; std::ofstream out_usage_file_1_;
std::ofstream mOutUsageFile2; std::ofstream out_usage_file_2_;
std::string mAppId; std::string app_id_;
std::string mKeyId; std::string key_id_;
std::string mSign; std::string sign_;
std::string mDefaultUrl; std::string default_url_;
std::unique_ptr<wvutil::FileSystem> mFileSystem = std::unique_ptr<wvutil::FileSystem> file_system_ =
std::make_unique<wvutil::FileSystem>(); std::make_unique<wvutil::FileSystem>();
std::unique_ptr<FuzzCdmClientPropertySet> mFuzzCdmClientPropertySet = std::unique_ptr<FuzzCdmClientPropertySet> fuzz_cdm_client_property_ =
std::make_unique<FuzzCdmClientPropertySet>(&mFdp); std::make_unique<FuzzCdmClientPropertySet>(&fdp_);
CdmSessionId mSessionId; CdmSessionId session_id_;
CdmKeySystem mKeySystem; CdmKeySystem key_system_;
CdmKeySetId mKeySetId; CdmKeySetId key_set_id_;
}; };
void CdmEngineFuzzer::createUsageFile(std::string mAppId) { void CdmEngineFuzzer::CreateUsageFiles(std::string app_id_) {
/** /**
* These files are being fetched by the GetUsageInfo() & * These files are being fetched by the GetUsageInfo() &
* RemoveAllUsageInfo() APIs, since they were not created * RemoveAllUsageInfo() APIs, since they were not created
* by any other API calls in the fuzzer, we are creating them. * by any other API calls in the fuzzer, we are creating them.
*/ */
DeviceFiles deviceFiles(mFileSystem.get()); DeviceFiles device_files(file_system_.get());
std::string fileName = deviceFiles.GetUsageInfoFileName(mAppId); std::string file_name = device_files.GetUsageInfoFileName(app_id_);
std::string createFile1 = kUsageFilePrefixL1 + fileName; std::string create_file_1 = kUsageFilePrefixL1 + file_name;
std::string createFile2 = kUsageFilePrefixL3 + fileName; std::string create_file_2 = kUsageFilePrefixL3 + file_name;
mOutUsageFile1.open(createFile1.c_str()); out_usage_file_1_.open(create_file_1.c_str());
mOutUsageFile2.open(createFile2.c_str()); out_usage_file_2_.open(create_file_2.c_str());
} }
std::vector<std::string> CdmEngineFuzzer::createVector(bool enableKeySetId) { std::vector<std::string> CdmEngineFuzzer::CreateVector(bool enable_key_set_id) {
int32_t size = mFdp.ConsumeIntegralInRange(kMinSize, kMaxSize); int32_t size = fdp_.ConsumeIntegralInRange(kMinSize, kMaxSize);
std::vector<std::string> vector; std::vector<std::string> vector;
for (int i = 0; i < size; ++i) { for (int i = 0; i < size; ++i) {
vector.push_back(enableKeySetId ? mKeySetId vector.push_back(enable_key_set_id ? key_set_id_
: mFdp.ConsumeRandomLengthString(kMaxByte)); : fdp_.ConsumeRandomLengthString(kMaxByte));
} }
return vector; return vector;
} }
void CdmEngineFuzzer::init(CdmEngine *cdmEngine) { void CdmEngineFuzzer::Init(CdmEngine *cdm_engine) {
mAppId = app_id_ =
std::to_string(mFdp.ConsumeIntegralInRange<uint32_t>(kMinSize, kMaxSize)); std::to_string(fdp_.ConsumeIntegralInRange<uint32_t>(kMinSize, kMaxSize));
mKeyId = key_id_ =
std::to_string(mFdp.ConsumeIntegralInRange<uint32_t>(kMinSize, kMaxSize)); std::to_string(fdp_.ConsumeIntegralInRange<uint32_t>(kMinSize, kMaxSize));
mSign = mFdp.ConsumeRandomLengthString(kMaxByte); sign_ = fdp_.ConsumeRandomLengthString(kMaxByte);
mKeySystem = mFdp.ConsumeBool() ? kKeySystem key_system_ = fdp_.ConsumeBool() ? kKeySystem
: mFdp.ConsumeRandomLengthString(kMaxByte); : fdp_.ConsumeRandomLengthString(kMaxByte);
FuzzWvCdmEventListener fuzzWvCdmEventListener; FuzzWvCdmEventListener fuzz_wv_cdm_event_listener;
cdmEngine->OpenSession( cdm_engine->OpenSession(
mKeySystem, key_system_,
mFdp.ConsumeBool() ? mFuzzCdmClientPropertySet.get() : nullptr, fdp_.ConsumeBool() ? fuzz_cdm_client_property_.get() : nullptr,
mFdp.ConsumeBool() ? &fuzzWvCdmEventListener : nullptr, &mSessionId); fdp_.ConsumeBool() ? &fuzz_wv_cdm_event_listener : nullptr, &session_id_);
std::string request; std::string request;
mDefaultUrl = mFdp.ConsumeRandomLengthString(kMaxByte); default_url_ = fdp_.ConsumeRandomLengthString(kMaxByte);
cdmEngine->GetProvisioningRequest( cdm_engine->GetProvisioningRequest(
(CdmCertificateType)mFdp.ConsumeIntegralInRange<int32_t>(kMinValue, (CdmCertificateType)fdp_.ConsumeIntegralInRange<int32_t>(kMinValue,
kMaxValue), kMaxValue),
mFdp.ConsumeRandomLengthString(kMaxByte) /* cert_authority */, fdp_.ConsumeRandomLengthString(kMaxByte) /* cert_authority */,
mFdp.ConsumeRandomLengthString(kMaxByte) /* service_certificate */, fdp_.ConsumeRandomLengthString(kMaxByte) /* service_certificate */,
(RequestedSecurityLevel)mFdp.ConsumeIntegralInRange<uint32_t>(kMinValue, (RequestedSecurityLevel)fdp_.ConsumeIntegralInRange<uint32_t>(kMinValue,
kMaxValue), kMaxValue),
mFdp.ConsumeBool() ? &request : nullptr, &mDefaultUrl); fdp_.ConsumeBool() ? &request : nullptr, &default_url_);
std::string cert; std::string cert;
std::string wrappedKey; std::string wrapped_key;
CdmProvisioningResponse responseMessage = CdmProvisioningResponse response_message =
mFdp.ConsumeRandomLengthString(kMaxByte); fdp_.ConsumeRandomLengthString(kMaxByte);
cdmEngine->HandleProvisioningResponse( cdm_engine->HandleProvisioningResponse(
responseMessage, response_message,
(RequestedSecurityLevel)mFdp.ConsumeIntegralInRange<uint32_t>(kMinValue, (RequestedSecurityLevel)fdp_.ConsumeIntegralInRange<uint32_t>(kMinValue,
kMaxValue), kMaxValue),
mFdp.ConsumeBool() ? &cert : nullptr, fdp_.ConsumeBool() ? &cert : nullptr,
mFdp.ConsumeBool() ? &wrappedKey : nullptr); fdp_.ConsumeBool() ? &wrapped_key : nullptr);
CdmAppParameterMap appParameters; CdmAppParameterMap app_parameters;
appParameters.insert({mFdp.ConsumeRandomLengthString(kMaxByte), app_parameters.insert({fdp_.ConsumeRandomLengthString(kMaxByte),
mFdp.ConsumeRandomLengthString(kMaxByte)}); fdp_.ConsumeRandomLengthString(kMaxByte)});
CdmInitData data = mFdp.ConsumeRandomLengthString(kMaxByte); CdmInitData data = fdp_.ConsumeRandomLengthString(kMaxByte);
const std::string oecVersion = const std::string oec_version =
std::to_string(mFdp.ConsumeIntegralInRange<uint32_t>(kMinSize, kMaxSize)); std::to_string(fdp_.ConsumeIntegralInRange<uint32_t>(kMinSize, kMaxSize));
InitializationData init_data(mFdp.PickValueInArray<std::string>(kInitType), InitializationData init_data(fdp_.PickValueInArray<std::string>(kInitType),
data, oecVersion); data, oec_version);
mKeySetId = key_set_id_ =
kKeySetIdPrefix + kKeySetIdPrefix +
std::to_string(mFdp.ConsumeIntegralInRange<uint32_t>(kMinKey, kMaxKey)); std::to_string(fdp_.ConsumeIntegralInRange<uint32_t>(kMinKey, kMaxKey));
CdmLicenseType generateLicType = CdmLicenseType generate_lic_type =
static_cast<CdmLicenseType>(mFdp.ConsumeIntegralInRange( static_cast<CdmLicenseType>(fdp_.ConsumeIntegralInRange(
static_cast<int32_t>(CdmLicenseType::kLicenseTypeOffline), static_cast<int32_t>(CdmLicenseType::kLicenseTypeOffline),
static_cast<int32_t>(CdmLicenseType::kLicenseTypeEmbeddedKeyData))); static_cast<int32_t>(CdmLicenseType::kLicenseTypeEmbeddedKeyData)));
CdmKeyRequest keyRequest; CdmKeyRequest key_request;
keyRequest.message = mFdp.ConsumeRandomLengthString(kMaxByte); key_request.message = fdp_.ConsumeRandomLengthString(kMaxByte);
keyRequest.type = static_cast<CdmKeyRequestType>(mFdp.ConsumeIntegralInRange( key_request.type = static_cast<CdmKeyRequestType>(fdp_.ConsumeIntegralInRange(
static_cast<uint32_t>(CdmKeyRequestType::kKeyRequestTypeUnknown), static_cast<uint32_t>(CdmKeyRequestType::kKeyRequestTypeUnknown),
static_cast<uint32_t>(CdmKeyRequestType::kKeyRequestTypeUpdate))); static_cast<uint32_t>(CdmKeyRequestType::kKeyRequestTypeUpdate)));
keyRequest.url = mFdp.ConsumeBool() key_request.url = fdp_.ConsumeBool()
? mDefaultUrl ? default_url_
: mFdp.ConsumeRandomLengthString(kMaxByte); : fdp_.ConsumeRandomLengthString(kMaxByte);
cdmEngine->GenerateKeyRequest(mSessionId, cdm_engine->GenerateKeyRequest(session_id_,
mFdp.ConsumeBool() ? mKeySetId : kEmptyString, fdp_.ConsumeBool() ? key_set_id_ : kEmptyString,
init_data, generateLicType, appParameters, init_data, generate_lic_type, app_parameters,
mFdp.ConsumeBool() ? &keyRequest : nullptr); fdp_.ConsumeBool() ? &key_request : nullptr);
CdmLicenseType addLicType = CdmLicenseType add_lic_type =
static_cast<CdmLicenseType>(mFdp.ConsumeIntegralInRange( static_cast<CdmLicenseType>(fdp_.ConsumeIntegralInRange(
static_cast<int32_t>(CdmLicenseType::kLicenseTypeOffline), static_cast<int32_t>(CdmLicenseType::kLicenseTypeOffline),
static_cast<int32_t>(CdmLicenseType::kLicenseTypeEmbeddedKeyData))); static_cast<int32_t>(CdmLicenseType::kLicenseTypeEmbeddedKeyData)));
CdmKeyResponse keyData = CdmKeyResponse key_data =
std::to_string(mFdp.ConsumeIntegralInRange<uint32_t>(kMinKey, kMaxKey)); std::to_string(fdp_.ConsumeIntegralInRange<uint32_t>(kMinKey, kMaxKey));
cdmEngine->AddKey(mSessionId, mFdp.ConsumeBool() ? keyData : kEmptyString, cdm_engine->AddKey(session_id_, fdp_.ConsumeBool() ? key_data : kEmptyString,
&addLicType, &mKeySetId); &add_lic_type, &key_set_id_);
} }
void CdmEngineFuzzer::process() { void CdmEngineFuzzer::Process() {
CdmEngine *cdmEngine = CdmEngineFactory::CreateCdmEngine(mFileSystem.get()); CdmEngine *cdm_engine = CdmEngineFactory::CreateCdmEngine(file_system_.get());
CdmEngineFuzzer::init(cdmEngine); CdmEngineFuzzer::Init(cdm_engine);
int32_t runs = kMaxRuns; int32_t runs = kMaxRuns;
/* Limited the while loop to prevent a timeout caused by the /* Limited the while loop to prevent a timeout caused by the
/* CryptoSession constructor, which took time to initialize /* CryptoSession constructor, which took time to initialize
/* OEMCrypto in each iteration.*/ /* OEMCrypto in each iteration.*/
while (mFdp.remaining_bytes() > 0 && --runs) { while (fdp_.remaining_bytes() > 0 && --runs) {
auto invokeCdmEngineAPI = mFdp.PickValueInArray< auto invoke_cdm_engine_API = fdp_.PickValueInArray<
const std::function<void()>>({ const std::function<void()>>({
[&]() { cdmEngine->OnTimerEvent(); }, [&]() { cdm_engine->OnTimerEvent(); },
[&]() { cdmEngine->IsOpenSession(mSessionId); }, [&]() { cdm_engine->IsOpenSession(session_id_); },
[&]() { cdmEngine->SetDefaultOtaKeyboxFallbackDurationRules(); }, [&]() { cdm_engine->SetDefaultOtaKeyboxFallbackDurationRules(); },
[&]() { cdmEngine->SetFastOtaKeyboxFallbackDurationRules(); }, [&]() { cdm_engine->SetFastOtaKeyboxFallbackDurationRules(); },
[&]() { [&]() {
cdmEngine->OpenSession( cdm_engine->OpenSession(
mKeySystem, nullptr /* property_set */, key_system_, nullptr /* property_set */,
mFdp.ConsumeRandomLengthString(kMaxByte) /* forced_session_id */, fdp_.ConsumeRandomLengthString(kMaxByte) /* forced_session_id */,
nullptr /* event_listener */); nullptr /* event_listener */);
}, },
[&]() { [&]() {
cdmEngine->StoreAtscLicense( cdm_engine->StoreAtscLicense(
static_cast<RequestedSecurityLevel>(mFdp.ConsumeIntegralInRange( static_cast<RequestedSecurityLevel>(fdp_.ConsumeIntegralInRange(
static_cast<int32_t>(RequestedSecurityLevel::kLevelDefault), static_cast<int32_t>(RequestedSecurityLevel::kLevelDefault),
static_cast<int32_t>(RequestedSecurityLevel::kLevel3))), static_cast<int32_t>(RequestedSecurityLevel::kLevel3))),
mKeySetId, key_set_id_,
mFdp.ConsumeRandomLengthString( fdp_.ConsumeRandomLengthString(
kMaxByte) /* serialized_license_data */); kMaxByte) /* serialized_license_data */);
}, },
[&]() { cdmEngine->RestoreKey(mSessionId, mKeySetId); }, [&]() { cdm_engine->RestoreKey(session_id_, key_set_id_); },
[&]() { [&]() {
cdmEngine->SetSessionServiceCertificate( cdm_engine->SetSessionServiceCertificate(
mSessionId, mFdp.ConsumeRandomLengthString( session_id_, fdp_.ConsumeRandomLengthString(
kMaxByte) /* service_certificate */); kMaxByte) /* service_certificate */);
}, },
[&]() { [&]() {
std::string queryResponse; std::string query_response;
cdmEngine->QueryStatus( cdm_engine->QueryStatus(
static_cast<RequestedSecurityLevel>(mFdp.ConsumeIntegralInRange( static_cast<RequestedSecurityLevel>(fdp_.ConsumeIntegralInRange(
static_cast<int32_t>(RequestedSecurityLevel::kLevelDefault), static_cast<int32_t>(RequestedSecurityLevel::kLevelDefault),
static_cast<int32_t>(RequestedSecurityLevel::kLevel3))), static_cast<int32_t>(RequestedSecurityLevel::kLevel3))),
mFdp.PickValueInArray<std::string>(kQueryToken), fdp_.PickValueInArray<std::string>(kQueryToken),
mFdp.ConsumeBool() ? &queryResponse : nullptr); fdp_.ConsumeBool() ? &query_response : nullptr);
}, },
[&]() { [&]() {
CdmQueryMap queryResponse; CdmQueryMap query_response;
cdmEngine->QuerySessionStatus(mSessionId, &queryResponse); cdm_engine->QuerySessionStatus(session_id_, &query_response);
}, },
[&]() { [&]() {
CdmKeyRequest keyRequest; CdmKeyRequest key_request;
keyRequest.message = mFdp.ConsumeRandomLengthString(kMaxByte); key_request.message = fdp_.ConsumeRandomLengthString(kMaxByte);
keyRequest.type = key_request.type =
static_cast<CdmKeyRequestType>(mFdp.ConsumeIntegralInRange( static_cast<CdmKeyRequestType>(fdp_.ConsumeIntegralInRange(
static_cast<uint32_t>( static_cast<uint32_t>(
CdmKeyRequestType::kKeyRequestTypeUnknown), CdmKeyRequestType::kKeyRequestTypeUnknown),
static_cast<uint32_t>( static_cast<uint32_t>(
CdmKeyRequestType::kKeyRequestTypeUpdate))); CdmKeyRequestType::kKeyRequestTypeUpdate)));
keyRequest.url = mDefaultUrl; key_request.url = default_url_;
cdmEngine->GenerateRenewalRequest( cdm_engine->GenerateRenewalRequest(
mSessionId, mFdp.ConsumeBool() ? &keyRequest : nullptr); session_id_, fdp_.ConsumeBool() ? &key_request : nullptr);
CdmKeyResponse keyData = CdmKeyResponse key_data =
mFdp.ConsumeBool() fdp_.ConsumeBool()
? std::to_string( ? std::to_string(
mFdp.ConsumeIntegralInRange<uint32_t>(kMinKey, kMaxKey)) fdp_.ConsumeIntegralInRange<uint32_t>(kMinKey, kMaxKey))
: kEmptyString; : kEmptyString;
cdmEngine->RenewKey(mSessionId, keyData); cdm_engine->RenewKey(session_id_, key_data);
}, },
[&]() { cdmEngine->IsReleaseSession(mSessionId); }, [&]() { cdm_engine->IsReleaseSession(session_id_); },
[&]() { cdmEngine->IsOfflineSession(mSessionId); }, [&]() { cdm_engine->IsOfflineSession(session_id_); },
[&]() { [&]() {
mOutCertFile1.open(kCertFile.c_str()); out_cert_file_1_.open(kCertFile.c_str());
mOutCertFile2.open(kCertFile1.c_str()); out_cert_file_2_.open(kCertFile1.c_str());
cdmEngine->RemoveOfflineLicense( cdm_engine->RemoveOfflineLicense(
mKeySetId, key_set_id_,
static_cast<CdmSecurityLevel>(mFdp.ConsumeIntegralInRange( static_cast<CdmSecurityLevel>(fdp_.ConsumeIntegralInRange(
static_cast<int32_t>( static_cast<int32_t>(
CdmSecurityLevel::kSecurityLevelUninitialized), CdmSecurityLevel::kSecurityLevelUninitialized),
static_cast<int32_t>( static_cast<int32_t>(
CdmSecurityLevel::kSecurityLevelUnknown)))); CdmSecurityLevel::kSecurityLevelUnknown))));
}, },
[&]() { [&]() {
CdmQueryMap queryResponse; CdmQueryMap query_response;
cdmEngine->QueryKeyStatus(mSessionId, &queryResponse); cdm_engine->QueryKeyStatus(session_id_, &query_response);
}, },
[&]() { [&]() {
cdmEngine->IsSecurityLevelSupported( cdm_engine->IsSecurityLevelSupported(
(CdmSecurityLevel)mFdp.ConsumeIntegralInRange<int32_t>(kMinEnum, (CdmSecurityLevel)fdp_.ConsumeIntegralInRange<int32_t>(kMinEnum,
kMaxEnum)); kMaxEnum));
}, },
[&]() { [&]() {
CdmKeyAllowedUsage keyUsage; CdmKeyAllowedUsage key_usage;
cdmEngine->QueryKeyAllowedUsage( cdm_engine->QueryKeyAllowedUsage(
mSessionId, mKeyId, mFdp.ConsumeBool() ? &keyUsage : nullptr); session_id_, key_id_, fdp_.ConsumeBool() ? &key_usage : nullptr);
}, },
[&]() { [&]() {
CdmKeyAllowedUsage keyUsage; CdmKeyAllowedUsage key_usage;
cdmEngine->QueryKeyAllowedUsage(mKeyId, mFdp.ConsumeBool() ? &keyUsage cdm_engine->QueryKeyAllowedUsage(
: nullptr); key_id_, fdp_.ConsumeBool() ? &key_usage : nullptr);
}, },
[&]() { [&]() {
CdmQueryMap queryResponse; CdmQueryMap query_response;
cdmEngine->QueryOemCryptoSessionId(mSessionId, &queryResponse); cdm_engine->QueryOemCryptoSessionId(session_id_, &query_response);
}, },
[&]() { [&]() {
std::vector<std::string> keySetIds = createVector(true); std::vector<std::string> key_set_ids = CreateVector(true);
cdmEngine->ListStoredLicenses( cdm_engine->ListStoredLicenses(
(CdmSecurityLevel)mFdp.ConsumeIntegralInRange<int32_t>(kMinEnum, (CdmSecurityLevel)fdp_.ConsumeIntegralInRange<int32_t>(kMinEnum,
kMaxEnum), kMaxEnum),
mFdp.ConsumeBool() ? &keySetIds : nullptr); fdp_.ConsumeBool() ? &key_set_ids : nullptr);
}, },
[&]() { [&]() {
std::vector<std::string> keySetIds = createVector(true); std::vector<std::string> key_set_ids = CreateVector(true);
std::vector<std::string> providerSessionTokens = createVector(false); std::vector<std::string> provider_session_tokens = CreateVector(false);
cdmEngine->ListUsageIds( cdm_engine->ListUsageIds(
mAppId, app_id_,
(CdmSecurityLevel)mFdp.ConsumeIntegralInRange<int32_t>(kMinEnum, (CdmSecurityLevel)fdp_.ConsumeIntegralInRange<int32_t>(kMinEnum,
kMaxEnum), kMaxEnum),
mFdp.ConsumeBool() ? &keySetIds : nullptr, fdp_.ConsumeBool() ? &key_set_ids : nullptr,
mFdp.ConsumeBool() ? &providerSessionTokens : nullptr); fdp_.ConsumeBool() ? &provider_session_tokens : nullptr);
}, },
[&]() { [&]() {
cdmEngine->DeleteUsageRecord( cdm_engine->DeleteUsageRecord(
mAppId, app_id_,
(CdmSecurityLevel)mFdp.ConsumeIntegralInRange<int32_t>(kMinEnum, (CdmSecurityLevel)fdp_.ConsumeIntegralInRange<int32_t>(kMinEnum,
kMaxEnum), kMaxEnum),
mKeySetId); key_set_id_);
}, },
[&]() { [&]() {
CdmOfflineLicenseState licenseState = CdmOfflineLicenseState license_state =
static_cast<CdmOfflineLicenseState>(mFdp.ConsumeIntegralInRange( static_cast<CdmOfflineLicenseState>(fdp_.ConsumeIntegralInRange(
static_cast<int32_t>( static_cast<int32_t>(
CdmOfflineLicenseState::kLicenseStateActive), CdmOfflineLicenseState::kLicenseStateActive),
static_cast<int32_t>( static_cast<int32_t>(
CdmOfflineLicenseState::kLicenseStateUnknown))); CdmOfflineLicenseState::kLicenseStateUnknown)));
cdmEngine->GetOfflineLicenseState( cdm_engine->GetOfflineLicenseState(
mKeySetId, key_set_id_,
(CdmSecurityLevel)mFdp.ConsumeIntegralInRange<int32_t>(kMinEnum, (CdmSecurityLevel)fdp_.ConsumeIntegralInRange<int32_t>(kMinEnum,
kMaxEnum), kMaxEnum),
mFdp.ConsumeBool() ? &licenseState : nullptr); fdp_.ConsumeBool() ? &license_state : nullptr);
}, },
[&]() { [&]() {
cdmEngine->SetPlaybackId(mSessionId, cdm_engine->SetPlaybackId(session_id_,
mFdp.ConsumeRandomLengthString(kMaxByte)); fdp_.ConsumeRandomLengthString(kMaxByte));
}, },
[&]() { [&]() {
CdmUsageReport usageReport; CdmUsageReport usage_report;
createUsageFile(mAppId); CreateUsageFiles(app_id_);
int errorDetail; int error_detail;
cdmEngine->GetUsageInfo(mAppId, cdm_engine->GetUsageInfo(app_id_,
mFdp.ConsumeBool() ? &errorDetail : nullptr, fdp_.ConsumeBool() ? &error_detail : nullptr,
mFdp.ConsumeBool() ? &usageReport : nullptr); fdp_.ConsumeBool() ? &usage_report : nullptr);
}, },
[&]() { [&]() {
createUsageFile(mAppId); CreateUsageFiles(app_id_);
cdmEngine->RemoveAllUsageInfo(mAppId); cdm_engine->RemoveAllUsageInfo(app_id_);
}, },
[&]() { [&]() {
cdmEngine->ReleaseUsageInfo( cdm_engine->ReleaseUsageInfo(
mFdp.ConsumeRandomLengthString(kMaxByte) /* message */); fdp_.ConsumeRandomLengthString(kMaxByte) /* message */);
}, },
[&]() { [&]() {
std::string releaseMessage = mFdp.ConsumeRandomLengthString(kMaxByte); std::string release_message = fdp_.ConsumeRandomLengthString(kMaxByte);
cdmEngine->LoadUsageSession( cdm_engine->LoadUsageSession(
mKeySetId, mFdp.ConsumeBool() ? &releaseMessage : nullptr); key_set_id_, fdp_.ConsumeBool() ? &release_message : nullptr);
}, },
[&]() { [&]() {
CdmDecryptionParametersV16 parameters(mKeyId); CdmDecryptionParametersV16 parameters(key_id_);
cdmEngine->DecryptV16(mSessionId, parameters); cdm_engine->DecryptV16(session_id_, parameters);
}, },
[&]() { [&]() {
std::string out = mFdp.ConsumeRandomLengthString(kMaxByte); std::string out = fdp_.ConsumeRandomLengthString(kMaxByte);
std::string ivGE = mFdp.ConsumeRandomLengthString(kMaxByte); std::string iv_GE = fdp_.ConsumeRandomLengthString(kMaxByte);
cdmEngine->GenericEncrypt( cdm_engine->GenericEncrypt(
mSessionId, mFdp.ConsumeRandomLengthString(kMaxByte), mKeyId, session_id_, fdp_.ConsumeRandomLengthString(kMaxByte), key_id_,
ivGE, iv_GE,
(CdmEncryptionAlgorithm)mFdp.ConsumeIntegralInRange<int32_t>( (CdmEncryptionAlgorithm)fdp_.ConsumeIntegralInRange<int32_t>(
kMinValue, kMaxValue), kMinValue, kMaxValue),
mFdp.ConsumeBool() ? &out : nullptr); fdp_.ConsumeBool() ? &out : nullptr);
}, },
[&]() { [&]() {
std::string out = mFdp.ConsumeRandomLengthString(kMaxByte); std::string out = fdp_.ConsumeRandomLengthString(kMaxByte);
std::string ivGE = mFdp.ConsumeRandomLengthString(kMaxByte); std::string iv_GE = fdp_.ConsumeRandomLengthString(kMaxByte);
cdmEngine->GenericDecrypt( cdm_engine->GenericDecrypt(
mSessionId, mFdp.ConsumeRandomLengthString(kMaxByte), mKeyId, session_id_, fdp_.ConsumeRandomLengthString(kMaxByte), key_id_,
ivGE, iv_GE,
(CdmEncryptionAlgorithm)mFdp.ConsumeIntegralInRange<int32_t>( (CdmEncryptionAlgorithm)fdp_.ConsumeIntegralInRange<int32_t>(
kMinValue, kMaxValue), kMinValue, kMaxValue),
mFdp.ConsumeBool() ? &out : nullptr); fdp_.ConsumeBool() ? &out : nullptr);
}, },
[&]() { [&]() {
cdmEngine->GenericSign( cdm_engine->GenericSign(
mSessionId, mFdp.ConsumeRandomLengthString(kMaxByte), mKeyId, session_id_, fdp_.ConsumeRandomLengthString(kMaxByte), key_id_,
(CdmSigningAlgorithm)mFdp.ConsumeIntegralInRange<int32_t>( (CdmSigningAlgorithm)fdp_.ConsumeIntegralInRange<int32_t>(
kMinValue, kMaxValue), kMinValue, kMaxValue),
mFdp.ConsumeBool() ? &mSign : nullptr); fdp_.ConsumeBool() ? &sign_ : nullptr);
cdmEngine->GenericVerify( cdm_engine->GenericVerify(
mSessionId, mFdp.ConsumeRandomLengthString(kMaxByte), mKeyId, session_id_, fdp_.ConsumeRandomLengthString(kMaxByte), key_id_,
(CdmSigningAlgorithm)mFdp.ConsumeIntegralInRange<int32_t>( (CdmSigningAlgorithm)fdp_.ConsumeIntegralInRange<int32_t>(
kMinValue, kMaxValue), kMinValue, kMaxValue),
mSign); sign_);
}, },
[&]() { [&]() {
cdmEngine->SetDebugIgnoreKeyboxCount( cdm_engine->SetDebugIgnoreKeyboxCount(
mFdp.ConsumeIntegral<uint32_t>()); fdp_.ConsumeIntegral<uint32_t>());
}, },
[&]() { [&]() {
std::string sessId = mFdp.ConsumeRandomLengthString(kMaxByte); std::string sess_id = fdp_.ConsumeRandomLengthString(kMaxByte);
std::string hash; std::string hash;
std::string hashString = std::string hash_string =
mFdp.ConsumeRandomLengthString(kMaxByte) + "," + fdp_.ConsumeRandomLengthString(kMaxByte) + "," +
mFdp.ConsumeRandomLengthString(kMaxByte) + "," + fdp_.ConsumeRandomLengthString(kMaxByte) + "," +
mFdp.ConsumeRandomLengthString(kMaxByte); fdp_.ConsumeRandomLengthString(kMaxByte);
uint32_t frameNum = mFdp.ConsumeIntegral<uint32_t>(); uint32_t frame_num = fdp_.ConsumeIntegral<uint32_t>();
cdmEngine->ParseDecryptHashString( cdm_engine->ParseDecryptHashString(
hashString, mFdp.ConsumeBool() ? &sessId : nullptr, hash_string, fdp_.ConsumeBool() ? &sess_id : nullptr,
mFdp.ConsumeBool() ? &frameNum : nullptr, fdp_.ConsumeBool() ? &frame_num : nullptr,
mFdp.ConsumeBool() ? &hash : nullptr); fdp_.ConsumeBool() ? &hash : nullptr);
cdmEngine->SetDecryptHash(mSessionId, cdm_engine->SetDecryptHash(session_id_,
mFdp.ConsumeIntegral<uint32_t>(), hash); fdp_.ConsumeIntegral<uint32_t>(), hash);
std::string hashError; std::string hash_error;
cdmEngine->GetDecryptHashError( cdm_engine->GetDecryptHashError(
mSessionId, mFdp.ConsumeBool() ? &hashError : nullptr); session_id_, fdp_.ConsumeBool() ? &hash_error : nullptr);
}, },
[&]() { [&]() {
std::string mSessionId = mFdp.ConsumeRandomLengthString(kMaxByte); std::string session_id = fdp_.ConsumeRandomLengthString(kMaxByte);
cdmEngine->FindSessionForKey(mKeyId, mFdp.ConsumeBool() ? &mSessionId cdm_engine->FindSessionForKey(
: nullptr); key_id_, fdp_.ConsumeBool() ? &session_id : nullptr);
}, },
[&]() { [&]() {
cdmEngine->NotifyResolution( cdm_engine->NotifyResolution(
mSessionId, mFdp.ConsumeIntegral<uint32_t>() /* width */, session_id_, fdp_.ConsumeIntegral<uint32_t>() /* width */,
mFdp.ConsumeIntegral<uint32_t>() /* height */); fdp_.ConsumeIntegral<uint32_t>() /* height */);
}, },
[&]() { [&]() {
cdmEngine->ValidateServiceCertificate( cdm_engine->ValidateServiceCertificate(
mFdp.ConsumeRandomLengthString(kMaxByte) /* cert */); fdp_.ConsumeRandomLengthString(kMaxByte) /* cert */);
}, },
[&]() { [&]() {
CdmUsageReport usageReport; CdmUsageReport usage_report;
createUsageFile(mAppId); CreateUsageFiles(app_id_);
CdmSecureStopId ssid = mFdp.ConsumeRandomLengthString(kMaxByte); CdmSecureStopId ssid = fdp_.ConsumeRandomLengthString(kMaxByte);
int errorDetail = mFdp.ConsumeIntegral<int32_t>(); int error_detail = fdp_.ConsumeIntegral<int32_t>();
cdmEngine->GetUsageInfo(mAppId, ssid, cdm_engine->GetUsageInfo(app_id_, ssid,
mFdp.ConsumeBool() ? &errorDetail : nullptr, fdp_.ConsumeBool() ? &error_detail : nullptr,
mFdp.ConsumeBool() ? &usageReport : nullptr); fdp_.ConsumeBool() ? &usage_report : nullptr);
}, },
[&]() { [&]() {
CdmSecureStopId ssid = mFdp.ConsumeRandomLengthString(kMaxByte); CdmSecureStopId ssid = fdp_.ConsumeRandomLengthString(kMaxByte);
cdmEngine->RemoveUsageInfo(mAppId, ssid); cdm_engine->RemoveUsageInfo(app_id_, ssid);
}, },
[&]() { cdmEngine->RemoveLicense(mSessionId); }, [&]() { cdm_engine->RemoveLicense(session_id_); },
[&]() { cdmEngine->IsKeyLoaded(mKeyId); }, [&]() { cdm_engine->IsKeyLoaded(key_id_); },
}); });
invokeCdmEngineAPI(); invoke_cdm_engine_API();
} }
cdmEngine->Unprovision((CdmSecurityLevel)mFdp.ConsumeIntegralInRange<int32_t>( cdm_engine->Unprovision((CdmSecurityLevel)fdp_.ConsumeIntegralInRange<int32_t>(
kMinEnum, kMaxEnum)); kMinEnum, kMaxEnum));
cdmEngine->RemoveKeys(mSessionId); cdm_engine->RemoveKeys(session_id_);
mOutCertFile1.close(); out_cert_file_1_.close();
mOutCertFile2.close(); out_cert_file_2_.close();
mOutUsageFile1.close(); out_usage_file_1_.close();
mOutUsageFile2.close(); out_usage_file_2_.close();
delete cdmEngine; delete cdm_engine;
} }
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
CdmEngineFuzzer cdmEngineFuzzer(data, size); CdmEngineFuzzer cdm_engine_fuzzer(data, size);
cdmEngineFuzzer.process(); cdm_engine_fuzzer.Process();
return 0; return 0;
} }