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

Updated policy_timers_fuzzer

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

exec/s: 15780
Test: ./policy_timers_fuzzer
Bug: 312374669

Change-Id: I0868deac9ec55549db0da3eaeee23daee9516c0f
This commit is contained in:
Onkar Shinde
2023-12-08 10:31:28 +00:00
committed by Aditya Wazir
parent 2b3de00a36
commit c010396125
1 changed files with 131 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

265
fuzzer/policy_timers_fuzzer.cpp
View File

@@ -15,172 +15,169 @@
* *
*/ */
#include <fuzzer/FuzzedDataProvider.h>
#include "policy_timers.h" #include "policy_timers.h"
#include "policy_timers_v16.h" #include "policy_timers_v16.h"
#include "policy_timers_v18.h" #include "policy_timers_v18.h"
#include "wv_cdm_event_listener.h" #include "wv_cdm_event_listener.h"
#include <fuzzer/FuzzedDataProvider.h>
using namespace wvcdm; using namespace wvcdm;
using namespace video_widevine; using namespace video_widevine;
class PolicyTimersFuzzer { class PolicyTimersFuzzer {
public: public:
PolicyTimersFuzzer(const uint8_t* data, size_t size) : mFdp(data, size) {}; PolicyTimersFuzzer(const uint8_t* data, size_t size) : fdp_(data, size){};
void process(); void Process();
private: private:
FuzzedDataProvider mFdp; FuzzedDataProvider fdp_;
License mLicense; License license_;
void setUp(); void SetUp();
}; };
void policySetBool(std::function<void(bool)> function, void PolicySetBool(std::function<void(bool)> function,
FuzzedDataProvider *fdp) { FuzzedDataProvider* fdp) {
if (fdp->ConsumeBool()) { if (fdp->ConsumeBool()) {
function(fdp->ConsumeBool()); function(fdp->ConsumeBool());
} }
} }
void policySetInt64(std::function<void(int64_t)> function, void PolicySetInt64(std::function<void(int64_t)> function,
FuzzedDataProvider *fdp) { FuzzedDataProvider* fdp) {
if (fdp->ConsumeBool()) { if (fdp->ConsumeBool()) {
function(fdp->ConsumeIntegral<int64_t>()); function(fdp->ConsumeIntegral<int64_t>());
} }
} }
void PolicyTimersFuzzer::setUp() { void PolicyTimersFuzzer::SetUp() {
License_Policy* policy = mLicense.mutable_policy(); License_Policy* policy = license_.mutable_policy();
policySetBool( PolicySetBool(
std::bind(&License_Policy::set_can_renew, policy, std::placeholders::_1), std::bind(&License_Policy::set_can_renew, policy, std::placeholders::_1),
&mFdp); &fdp_);
policySetInt64(std::bind(&License_Policy::set_renewal_delay_seconds, policy, PolicySetInt64(std::bind(&License_Policy::set_renewal_delay_seconds, policy,
std::placeholders::_1), std::placeholders::_1),
&mFdp); &fdp_);
policySetBool(std::bind(&License_Policy::set_soft_enforce_playback_duration, PolicySetBool(std::bind(&License_Policy::set_soft_enforce_playback_duration,
policy, std::placeholders::_1), policy, std::placeholders::_1),
&mFdp); &fdp_);
policySetInt64(std::bind(&License_Policy::set_renewal_retry_interval_seconds, PolicySetInt64(std::bind(&License_Policy::set_renewal_retry_interval_seconds,
policy, std::placeholders::_1), policy, std::placeholders::_1),
&mFdp); &fdp_);
policySetInt64(std::bind(&License_Policy::set_license_duration_seconds, PolicySetInt64(std::bind(&License_Policy::set_license_duration_seconds,
policy, std::placeholders::_1), policy, std::placeholders::_1),
&mFdp); &fdp_);
if (mFdp.ConsumeBool()) { if (fdp_.ConsumeBool()) {
video_widevine::License::Policy::TimerDelayBase timeDelayBase = video_widevine::License::Policy::TimerDelayBase time_delay_base =
(video_widevine::License::Policy::TimerDelayBase) (video_widevine::License::Policy::TimerDelayBase)
mFdp.ConsumeIntegralInRange<uint8_t>( fdp_.ConsumeIntegralInRange<uint8_t>(
License_Policy_TimerDelayBase_TIMER_DELAY_BASE_UNSPECIFIED, License_Policy_TimerDelayBase_TIMER_DELAY_BASE_UNSPECIFIED,
License_Policy_TimerDelayBase_FIRST_DECRYPT); License_Policy_TimerDelayBase_FIRST_DECRYPT);
policy->set_initial_renewal_delay_base(timeDelayBase); policy->set_initial_renewal_delay_base(time_delay_base);
} }
if (mFdp.ConsumeBool()) { if (fdp_.ConsumeBool()) {
policy->set_playback_duration_seconds(mFdp.ConsumeIntegral<int64_t>()); policy->set_playback_duration_seconds(fdp_.ConsumeIntegral<int64_t>());
} }
if (mFdp.ConsumeBool()) { if (fdp_.ConsumeBool()) {
policy->set_rental_duration_seconds(mFdp.ConsumeIntegral<int64_t>()); policy->set_rental_duration_seconds(fdp_.ConsumeIntegral<int64_t>());
} }
if (mFdp.ConsumeBool()) { if (fdp_.ConsumeBool()) {
policy->set_renewal_recovery_duration_seconds(mFdp.ConsumeIntegral<int64_t>()); policy->set_renewal_recovery_duration_seconds(
} fdp_.ConsumeIntegral<int64_t>());
if (mFdp.ConsumeBool()) { }
policy->set_soft_enforce_rental_duration(mFdp.ConsumeBool()); if (fdp_.ConsumeBool()) {
} policy->set_soft_enforce_rental_duration(fdp_.ConsumeBool());
if (mFdp.ConsumeBool()) { }
policy->set_can_play(mFdp.ConsumeBool()); if (fdp_.ConsumeBool()) {
} policy->set_can_play(fdp_.ConsumeBool());
mLicense.set_license_start_time(mFdp.ConsumeIntegral<int64_t>()); }
license_.set_license_start_time(fdp_.ConsumeIntegral<int64_t>());
} }
void PolicyTimersFuzzer::process() { void PolicyTimersFuzzer::Process() {
std::unique_ptr<PolicyTimers> policyTimers; std::unique_ptr<PolicyTimers> policy_timers;
if (mFdp.ConsumeBool()) { if (fdp_.ConsumeBool()) {
policyTimers = std::make_unique<PolicyTimersV16>(); policy_timers = std::make_unique<PolicyTimersV16>();
} } else {
else { policy_timers = std::make_unique<PolicyTimersV18>();
policyTimers = std::make_unique<PolicyTimersV18>(); }
}
while (mFdp.remaining_bytes()) { while (fdp_.remaining_bytes()) {
auto invokePolicyTimersAPI = auto invoke_policy_timers_API =
mFdp.PickValueInArray<const std::function<void()>>({ fdp_.PickValueInArray<const std::function<void()>>({
[&]() { [&]() { SetUp(); },
setUp(); [&]() { policy_timers->SetLicense(license_); },
}, [&]() {
[&]() { policy_timers->BeginDecryption(
policyTimers->SetLicense(mLicense); fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
}, },
[&]() { [&]() {
policyTimers->BeginDecryption( policy_timers->DecryptionEvent(
mFdp.ConsumeIntegral<int64_t>() /*current_time*/); fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
}, },
[&]() { [&]() {
policyTimers->DecryptionEvent( policy_timers->RestorePlaybackTimes(
mFdp.ConsumeIntegral<int64_t>() /*current_time*/); fdp_.ConsumeIntegral<int64_t>() /*current_time*/,
}, fdp_.ConsumeIntegral<int64_t>() /*playback_start_time*/,
[&]() { fdp_.ConsumeIntegral<int64_t>() /*last_playback_time*/,
policyTimers->RestorePlaybackTimes( fdp_.ConsumeIntegral<int64_t>() /* grace_period_end_time */);
mFdp.ConsumeIntegral<int64_t>() /*current_time*/, },
mFdp.ConsumeIntegral<int64_t>() /*playback_start_time*/, [&]() {
mFdp.ConsumeIntegral<int64_t>() /*last_playback_time*/, policy_timers->GetLicenseOrRentalOrPlaybackDurationRemaining(
mFdp.ConsumeIntegral<int64_t>() /* grace_period_end_time */); fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
}, },
[&]() { [&]() {
policyTimers->GetLicenseOrRentalOrPlaybackDurationRemaining( policy_timers->GetPlaybackDurationRemaining(
mFdp.ConsumeIntegral<int64_t>() /*current_time*/); fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
}, },
[&]() { [&]() {
policyTimers->GetPlaybackDurationRemaining( int64_t seconds_since_last_played = fdp_.ConsumeIntegral<int64_t>();
mFdp.ConsumeIntegral<int64_t>() /*current_time*/); policy_timers->GetSecondsSinceStarted(
}, fdp_.ConsumeIntegral<int64_t>() /*current_time*/,
[&]() { fdp_.ConsumeBool() ? &seconds_since_last_played : nullptr);
int64_t secondsSinceLastPlayed = mFdp.ConsumeIntegral<int64_t>(); },
policyTimers->GetSecondsSinceStarted( [&]() {
mFdp.ConsumeIntegral<int64_t>() /*current_time*/, int64_t seconds_since_last_played = fdp_.ConsumeIntegral<int64_t>();
mFdp.ConsumeBool() ? &secondsSinceLastPlayed : nullptr); policy_timers->GetSecondsSinceLastPlayed(
}, fdp_.ConsumeIntegral<int64_t>() /*current_time*/,
[&]() { fdp_.ConsumeBool() ? &seconds_since_last_played : nullptr);
int64_t secondsSinceLastPlayed = mFdp.ConsumeIntegral<int64_t>(); },
policyTimers->GetSecondsSinceLastPlayed( [&]() {
mFdp.ConsumeIntegral<int64_t>() /*current_time*/, policy_timers->IsLicenseForFuture(
mFdp.ConsumeBool() ? &secondsSinceLastPlayed : nullptr); fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
}, },
[&]() { [&]() {
policyTimers->IsLicenseForFuture( int64_t expiry_time = fdp_.ConsumeIntegral<int64_t>();
mFdp.ConsumeIntegral<int64_t>() /*current_time*/); policy_timers->UpdateExpirationTime(
}, fdp_.ConsumeIntegral<int64_t>() /*current_time*/,
[&]() { fdp_.ConsumeBool() ? &expiry_time : nullptr);
int64_t expiryTime = mFdp.ConsumeIntegral<int64_t>(); },
policyTimers->UpdateExpirationTime( [&]() {
mFdp.ConsumeIntegral<int64_t>() /*current_time*/, policy_timers->HasRenewalRetryIntervalExpired(
mFdp.ConsumeBool() ? &expiryTime : nullptr); fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
}, },
[&]() { [&]() {
policyTimers->HasRenewalRetryIntervalExpired( policy_timers->UpdateRenewalRequest(
mFdp.ConsumeIntegral<int64_t>() /*current_time*/); fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
}, },
[&]() { [&]() {
policyTimers->UpdateRenewalRequest( policy_timers->HasRenewalRecoveryDurationExpired(
mFdp.ConsumeIntegral<int64_t>() /*current_time*/); fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
}, },
[&]() { [&]() {
policyTimers->HasRenewalRecoveryDurationExpired( policy_timers->HasRenewalDelayExpired(
mFdp.ConsumeIntegral<int64_t>() /*current_time*/); fdp_.ConsumeIntegral<int64_t>() /*current_time*/);
}, },
[&]() { [&]() {
policyTimers->HasRenewalDelayExpired( policy_timers->UpdateLicense(
mFdp.ConsumeIntegral<int64_t>() /*current_time*/); fdp_.ConsumeIntegral<int64_t>() /*current_time*/, license_);
}, },
[&]() { });
policyTimers->UpdateLicense( invoke_policy_timers_API();
mFdp.ConsumeIntegral<int64_t>() /*current_time*/, mLicense); }
},
});
invokePolicyTimersAPI();
}
} }
extern "C" int LLVMFuzzerTestOneInput(const uint8_t * data, size_t size) { extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
PolicyTimersFuzzer policyTimersFuzzer(data, size); PolicyTimersFuzzer policy_timers_fuzzer(data, size);
policyTimersFuzzer.process(); policy_timers_fuzzer.Process();
return 0; return 0;
} }