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

179
fuzzer/policy_timers_fuzzer.cpp
View File

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