From f3c22ff3f1591bb794e806cec87cee20407be444 Mon Sep 17 00:00:00 2001 From: Kunal Rai Date: Tue, 21 Nov 2023 09:53:58 +0000 Subject: [PATCH] Updated policy_engine_fuzzer Implemented google c++ code style changes for policy_engine_fuzzer execs/s: 71 Test: ./policy_engine_fuzzer Bug: 312374669 Change-Id: I8320f360f0c58c4fd3309a9f159ca49568da2abc --- fuzzer/policy_engine_fuzzer.cpp | 454 ++++++++++++++++---------------- 1 file changed, 226 insertions(+), 228 deletions(-) diff --git a/fuzzer/policy_engine_fuzzer.cpp b/fuzzer/policy_engine_fuzzer.cpp index 435b7f97..a7dc84f3 100644 --- a/fuzzer/policy_engine_fuzzer.cpp +++ b/fuzzer/policy_engine_fuzzer.cpp @@ -22,7 +22,7 @@ using namespace wvcdm; using namespace wvcdm::metrics; using namespace video_widevine; -static constexpr int32_t kLicenseIDVersion = 1; +static constexpr int32_t kLicenseIdVersion = 1; static constexpr int32_t kMaxByte = 256; static constexpr int32_t kMinResolution = 1; static constexpr int32_t kMaxResolution = 1024; @@ -42,304 +42,302 @@ class FuzzWvCdmEventListener : public WvCdmEventListener { }; class PolicyEngineFuzzer { -public: - PolicyEngineFuzzer(const uint8_t *data, size_t size) : mFdp(data, size){}; - void process(); + public: + PolicyEngineFuzzer(const uint8_t *data, size_t size) : fdp_(data, size){}; + void Process(); -private: - FuzzedDataProvider mFdp; - KeyId mKeyId; - License mLicense; - void setUp(); + private: + FuzzedDataProvider fdp_; + KeyId key_id_; + License license_; + void SetUp(); }; -void policySetBool(std::function function, +void PolicySetBool(std::function function, FuzzedDataProvider *fdp) { if (fdp->ConsumeBool()) { function(fdp->ConsumeBool()); } } -void policySetInt64(std::function function, +void PolicySetInt64(std::function function, FuzzedDataProvider *fdp) { if (fdp->ConsumeBool()) { function(fdp->ConsumeIntegral()); } } -void PolicyEngineFuzzer::setUp() { +void PolicyEngineFuzzer::SetUp() { - License::KeyContainer *key = mLicense.add_key(); - int32_t keyType = mFdp.ConsumeIntegralInRange( + License::KeyContainer *key = license_.add_key(); + int32_t key_type = fdp_.ConsumeIntegralInRange( License::KeyContainer::SIGNING, License::KeyContainer::ENTITLEMENT); - key->set_type((License_KeyContainer_KeyType)keyType); - mKeyId = mFdp.ConsumeRandomLengthString(kMaxByte); + key->set_type((License_KeyContainer_KeyType)key_type); + key_id_ = fdp_.ConsumeRandomLengthString(kMaxByte); - LicenseIdentification *id = mLicense.mutable_id(); - if (mFdp.ConsumeBool()) { - id->set_version(kLicenseIDVersion); + LicenseIdentification *id = license_.mutable_id(); + if (fdp_.ConsumeBool()) { + id->set_version(kLicenseIdVersion); } - if (mFdp.ConsumeBool()) { - id->set_type(mFdp.ConsumeBool() ? STREAMING : OFFLINE); + if (fdp_.ConsumeBool()) { + id->set_type(fdp_.ConsumeBool() ? STREAMING : OFFLINE); } - if (mFdp.ConsumeBool()) { - id->set_provider_session_token(mFdp.ConsumeRandomLengthString(kMaxByte)); + if (fdp_.ConsumeBool()) { + id->set_provider_session_token(fdp_.ConsumeRandomLengthString(kMaxByte)); } - if (mFdp.ConsumeBool()) { - mLicense.set_license_start_time(mFdp.ConsumeIntegral()); + if (fdp_.ConsumeBool()) { + license_.set_license_start_time(fdp_.ConsumeIntegral()); } - if (mFdp.ConsumeBool()) { - License_KeyContainer_OutputProtection *outputProtection = + if (fdp_.ConsumeBool()) { + License_KeyContainer_OutputProtection *output_protection = key->mutable_required_protection(); - License_KeyContainer_OutputProtection_HDCP hdcpLevel = - (License_KeyContainer_OutputProtection_HDCP)mFdp + License_KeyContainer_OutputProtection_HDCP hdcp_level = + (License_KeyContainer_OutputProtection_HDCP)fdp_ .ConsumeIntegralInRange(HDCP_NONE, HDCP_NO_DIGITAL_OUTPUT); - outputProtection->set_hdcp(hdcpLevel); + output_protection->set_hdcp(hdcp_level); } - if (mFdp.ConsumeBool()) { - const std::string ivString = mFdp.ConsumeRandomLengthString(kMaxByte); - key->set_iv(ivString); + if (fdp_.ConsumeBool()) { + const std::string iv_string = fdp_.ConsumeRandomLengthString(kMaxByte); + key->set_iv(iv_string); } - switch (keyType) { - case License::KeyContainer::SIGNING: { - if (mFdp.ConsumeBool()) { - mKeyId = mFdp.ConsumeBool() ? kSigningKeyId : mKeyId; - key->set_id(mKeyId); - } - break; - } - case License::KeyContainer::CONTENT: { - if (mFdp.ConsumeBool()) { - key->set_id(mKeyId); - } - if (mFdp.ConsumeBool()) { - int32_t level = mFdp.ConsumeIntegralInRange( - License::KeyContainer::SW_SECURE_CRYPTO, - License::KeyContainer::HW_SECURE_ALL); - key->set_level((License_KeyContainer_SecurityLevel)level); - } - - License_Policy *policy = mLicense.mutable_policy(); - policySetBool( + switch (key_type) { + case License::KeyContainer::SIGNING: { + if (fdp_.ConsumeBool()) { + key_id_ = fdp_.ConsumeBool() ? kSigningKeyId : key_id_; + key->set_id(key_id_); + } + break; + } + case License::KeyContainer::CONTENT: { + if (fdp_.ConsumeBool()) { + key->set_id(key_id_); + } + if (fdp_.ConsumeBool()) { + int32_t level = fdp_.ConsumeIntegralInRange( + License::KeyContainer::SW_SECURE_CRYPTO, + License::KeyContainer::HW_SECURE_ALL); + key->set_level((License_KeyContainer_SecurityLevel)level); + } + License_Policy *policy = license_.mutable_policy(); + PolicySetBool( std::bind(&License_Policy::set_can_play, policy, std::placeholders::_1), - &mFdp); - policySetBool(std::bind(&License_Policy::set_can_persist, policy, - std::placeholders::_1), &mFdp); - policySetBool(std::bind(&License_Policy::set_can_renew, policy, - std::placeholders::_1), &mFdp); - policySetBool(std::bind(&License_Policy::set_renew_with_usage, policy, - std::placeholders::_1), &mFdp); - policySetBool(std::bind(&License_Policy::set_soft_enforce_rental_duration, - policy, std::placeholders::_1), &mFdp); - policySetBool(std::bind(&License_Policy::set_soft_enforce_playback_duration, - policy, std::placeholders::_1), &mFdp); + &fdp_); + PolicySetBool(std::bind(&License_Policy::set_can_persist, policy, + std::placeholders::_1), &fdp_); + PolicySetBool(std::bind(&License_Policy::set_can_renew, policy, + std::placeholders::_1), &fdp_); + PolicySetBool(std::bind(&License_Policy::set_renew_with_usage, policy, + std::placeholders::_1), &fdp_); + PolicySetBool(std::bind(&License_Policy::set_soft_enforce_rental_duration, + policy, std::placeholders::_1), &fdp_); + PolicySetBool(std::bind(&License_Policy::set_soft_enforce_playback_duration, + policy, std::placeholders::_1), &fdp_); - policySetInt64(std::bind(&License_Policy::set_rental_duration_seconds, - policy, std::placeholders::_1), &mFdp); - policySetInt64(std::bind(&License_Policy::set_playback_duration_seconds, - policy, std::placeholders::_1), &mFdp); - policySetInt64(std::bind(&License_Policy::set_license_duration_seconds, - policy, std::placeholders::_1), &mFdp); - policySetInt64( - std::bind(&License_Policy::set_renewal_recovery_duration_seconds, - policy, std::placeholders::_1), &mFdp); - policySetInt64( - std::bind(&License_Policy::set_renewal_retry_interval_seconds, policy, - std::placeholders::_1), &mFdp); - policySetInt64( - std::bind(&License_Policy::set_renewal_delay_seconds, policy, - std::placeholders::_1), &mFdp); + PolicySetInt64(std::bind(&License_Policy::set_rental_duration_seconds, + policy, std::placeholders::_1), &fdp_); + PolicySetInt64(std::bind(&License_Policy::set_playback_duration_seconds, + policy, std::placeholders::_1), &fdp_); + PolicySetInt64(std::bind(&License_Policy::set_license_duration_seconds, + policy, std::placeholders::_1), &fdp_); + PolicySetInt64(std::bind(&License_Policy::set_renewal_recovery_duration_seconds, + policy, std::placeholders::_1), &fdp_); + PolicySetInt64(std::bind(&License_Policy::set_renewal_retry_interval_seconds, policy, + std::placeholders::_1), &fdp_); + PolicySetInt64(std::bind(&License_Policy::set_renewal_delay_seconds, policy, + std::placeholders::_1), &fdp_); - if (mFdp.ConsumeBool()) { - video_widevine::License::Policy::TimerDelayBase timeDelayBase = - (video_widevine::License::Policy::TimerDelayBase)mFdp.ConsumeIntegralInRange( - License_Policy_TimerDelayBase_TIMER_DELAY_BASE_UNSPECIFIED , - License_Policy_TimerDelayBase_FIRST_DECRYPT); - policy->set_initial_renewal_delay_base(timeDelayBase); - } + if (fdp_.ConsumeBool()) { + video_widevine::License::Policy::TimerDelayBase time_delay_base = + (video_widevine::License::Policy::TimerDelayBase) + fdp_.ConsumeIntegralInRange( + License_Policy_TimerDelayBase_TIMER_DELAY_BASE_UNSPECIFIED, + License_Policy_TimerDelayBase_FIRST_DECRYPT); + policy->set_initial_renewal_delay_base(time_delay_base); + } - if (mFdp.ConsumeBool()) { - std::string serverUrl = mFdp.ConsumeBool() - ? kRenewalServerUrl - : mFdp.ConsumeRandomLengthString(kMaxByte); - policy->set_renewal_server_url(serverUrl); - } - break; - } - case License::KeyContainer::KEY_CONTROL: { - key->set_type(License::KeyContainer::KEY_CONTROL); - // No control bits for this type of key container used for license - break; - } - case License::KeyContainer::OPERATOR_SESSION: { - key->set_type(License::KeyContainer::OPERATOR_SESSION); + if (fdp_.ConsumeBool()) { + std::string serverUrl = fdp_.ConsumeBool() + ? kRenewalServerUrl + : fdp_.ConsumeRandomLengthString(kMaxByte); + policy->set_renewal_server_url(serverUrl); + } + break; + } + case License::KeyContainer::KEY_CONTROL: { + key->set_type(License::KeyContainer::KEY_CONTROL); + // No control bits for this type of key container used for license + break; + } + case License::KeyContainer::OPERATOR_SESSION: { + key->set_type(License::KeyContainer::OPERATOR_SESSION); + if (fdp_.ConsumeBool()) { + key->set_id(key_id_); + } - if (mFdp.ConsumeBool()) { - key->set_id(mKeyId); - } + if (fdp_.ConsumeBool()) { + int32_t level = fdp_.ConsumeIntegralInRange( + License::KeyContainer::SW_SECURE_CRYPTO, + License::KeyContainer::HW_SECURE_ALL); + key->set_level((License_KeyContainer_SecurityLevel)level); + } - if (mFdp.ConsumeBool()) { - int32_t level = mFdp.ConsumeIntegralInRange( - License::KeyContainer::SW_SECURE_CRYPTO, - License::KeyContainer::HW_SECURE_ALL); - key->set_level((License_KeyContainer_SecurityLevel)level); - } + if (fdp_.ConsumeBool()) { + PolicySetBool(std::bind(&License_Policy::set_can_persist,license_.mutable_policy(), + std::placeholders::_1),&fdp_); + } - if (mFdp.ConsumeBool()) { - policySetBool(std::bind(&License_Policy::set_can_persist, mLicense.mutable_policy(), - std::placeholders::_1), &mFdp); - } + License::KeyContainer::OperatorSessionKeyPermissions *permissions = + key->mutable_operator_session_key_permissions(); + PolicySetBool( + std::bind(&License::KeyContainer::OperatorSessionKeyPermissions:: + set_allow_encrypt, + permissions, std::placeholders::_1), &fdp_); + PolicySetBool( + std::bind(&License::KeyContainer::OperatorSessionKeyPermissions:: + set_allow_decrypt, + permissions, std::placeholders::_1), &fdp_); + PolicySetBool(std::bind(&License::KeyContainer:: + OperatorSessionKeyPermissions::set_allow_sign, + permissions, std::placeholders::_1), &fdp_); + PolicySetBool( + std::bind(&License::KeyContainer::OperatorSessionKeyPermissions:: + set_allow_signature_verify, + permissions, std::placeholders::_1), &fdp_); + break; + } + case License::KeyContainer::ENTITLEMENT: + default: { + if (fdp_.ConsumeBool()) { + key_id_ = fdp_.ConsumeBool() ? kEntitlementKeyId : key_id_; + key->set_id(key_id_); + } + if (fdp_.ConsumeBool()) { + int32_t level = fdp_.ConsumeIntegralInRange( + License::KeyContainer::SW_SECURE_CRYPTO, + License::KeyContainer::HW_SECURE_ALL); + key->set_level((License_KeyContainer_SecurityLevel)level); + } - License::KeyContainer::OperatorSessionKeyPermissions *permissions = - key->mutable_operator_session_key_permissions(); - policySetBool( - std::bind(&License::KeyContainer::OperatorSessionKeyPermissions:: - set_allow_encrypt, - permissions, std::placeholders::_1), &mFdp); - policySetBool( - std::bind(&License::KeyContainer::OperatorSessionKeyPermissions:: - set_allow_decrypt, - permissions, std::placeholders::_1), &mFdp); - policySetBool(std::bind(&License::KeyContainer:: - OperatorSessionKeyPermissions::set_allow_sign, - permissions, std::placeholders::_1), &mFdp); - policySetBool( - std::bind(&License::KeyContainer::OperatorSessionKeyPermissions:: - set_allow_signature_verify, - permissions, std::placeholders::_1), &mFdp); - break; - } - case License::KeyContainer::ENTITLEMENT: - default: { - if (mFdp.ConsumeBool()) { - mKeyId = mFdp.ConsumeBool() ? kEntitlementKeyId : mKeyId; - key->set_id(mKeyId); - } - if (mFdp.ConsumeBool()) { - int32_t level = mFdp.ConsumeIntegralInRange( - License::KeyContainer::SW_SECURE_CRYPTO, - License::KeyContainer::HW_SECURE_ALL); - key->set_level((License_KeyContainer_SecurityLevel)level); - } + License_Policy *policy = license_.mutable_policy(); + PolicySetBool( + std::bind(&License_Policy::set_can_play, policy, std::placeholders::_1), + &fdp_); + PolicySetBool(std::bind(&License_Policy::set_can_persist, policy, + std::placeholders::_1), &fdp_); + PolicySetBool(std::bind(&License_Policy::set_can_renew, policy, + std::placeholders::_1), &fdp_); + PolicySetBool(std::bind(&License_Policy::set_renew_with_usage, policy, + std::placeholders::_1), &fdp_); + PolicySetBool(std::bind(&License_Policy::set_soft_enforce_rental_duration, + policy, std::placeholders::_1), &fdp_); + PolicySetBool(std::bind(&License_Policy::set_soft_enforce_playback_duration, + policy, std::placeholders::_1), &fdp_); - License_Policy *policy = mLicense.mutable_policy(); - policySetBool( - std::bind(&License_Policy::set_can_play, policy, std::placeholders::_1), - &mFdp); - policySetBool(std::bind(&License_Policy::set_can_persist, policy, - std::placeholders::_1), &mFdp); - policySetBool(std::bind(&License_Policy::set_can_renew, policy, - std::placeholders::_1), &mFdp); - policySetBool(std::bind(&License_Policy::set_renew_with_usage, policy, - std::placeholders::_1), &mFdp); - policySetBool(std::bind(&License_Policy::set_soft_enforce_rental_duration, - policy, std::placeholders::_1), &mFdp); - policySetBool(std::bind(&License_Policy::set_soft_enforce_playback_duration, - policy, std::placeholders::_1), &mFdp); + PolicySetInt64(std::bind(&License_Policy::set_rental_duration_seconds, + policy, std::placeholders::_1), &fdp_); + PolicySetInt64(std::bind(&License_Policy::set_playback_duration_seconds, + policy, std::placeholders::_1), &fdp_); + PolicySetInt64(std::bind(&License_Policy::set_license_duration_seconds, + policy, std::placeholders::_1), &fdp_); + PolicySetInt64( + std::bind(&License_Policy::set_renewal_recovery_duration_seconds, + policy, std::placeholders::_1), &fdp_); + PolicySetInt64( + std::bind(&License_Policy::set_renewal_retry_interval_seconds, policy, + std::placeholders::_1), &fdp_); + PolicySetInt64( + std::bind(&License_Policy::set_renewal_delay_seconds, policy, + std::placeholders::_1), &fdp_); - policySetInt64(std::bind(&License_Policy::set_rental_duration_seconds, - policy, std::placeholders::_1), &mFdp); - policySetInt64(std::bind(&License_Policy::set_playback_duration_seconds, - policy, std::placeholders::_1), &mFdp); - policySetInt64(std::bind(&License_Policy::set_license_duration_seconds, - policy, std::placeholders::_1), &mFdp); - policySetInt64( - std::bind(&License_Policy::set_renewal_recovery_duration_seconds, - policy, std::placeholders::_1), &mFdp); - policySetInt64( - std::bind(&License_Policy::set_renewal_retry_interval_seconds, policy, - std::placeholders::_1), &mFdp); - policySetInt64( - std::bind(&License_Policy::set_renewal_delay_seconds, policy, - std::placeholders::_1), &mFdp); - - if (mFdp.ConsumeBool()) { - video_widevine::License::Policy::TimerDelayBase timeDelayBase = (video_widevine::License::Policy::TimerDelayBase)mFdp.ConsumeIntegralInRange( - License_Policy_TimerDelayBase_TIMER_DELAY_BASE_UNSPECIFIED , - License_Policy_TimerDelayBase_FIRST_DECRYPT); - policy->set_initial_renewal_delay_base(timeDelayBase); - } - break; - } + if (fdp_.ConsumeBool()) { + video_widevine::License::Policy::TimerDelayBase time_delay_base = + (video_widevine::License::Policy::TimerDelayBase) + fdp_.ConsumeIntegralInRange( + License_Policy_TimerDelayBase_TIMER_DELAY_BASE_UNSPECIFIED, + License_Policy_TimerDelayBase_FIRST_DECRYPT); + policy->set_initial_renewal_delay_base(time_delay_base); + } + break; + } } } -void PolicyEngineFuzzer::process() { - setUp(); - FuzzWvCdmEventListener fuzzWvCdmEventListener; - CdmSessionId sessionId = mFdp.ConsumeRandomLengthString(kMaxByte); +void PolicyEngineFuzzer::Process() { + SetUp(); + FuzzWvCdmEventListener fuzz_wv_cdm_event_listener; + CdmSessionId session_id = fdp_.ConsumeRandomLengthString(kMaxByte); metrics::CryptoMetrics crypto_metrics; std::unique_ptr cryptoSession( wvcdm::CryptoSession::MakeCryptoSession(&crypto_metrics)); - std::unique_ptr policyEngine(new PolicyEngine( - sessionId, &fuzzWvCdmEventListener, cryptoSession.get())); + std::unique_ptr policy_engine(new PolicyEngine( + session_id, &fuzz_wv_cdm_event_listener, cryptoSession.get())); - while (mFdp.remaining_bytes()) { + while (fdp_.remaining_bytes()) { auto invokePolicyEngineAPI = - mFdp.PickValueInArray>({ - [&]() { policyEngine->CanDecryptContent(mKeyId); }, - [&]() { policyEngine->CanUseKeyForSecurityLevel(mKeyId); }, - [&]() { policyEngine->OnTimerEvent(); }, + fdp_.PickValueInArray>({ + [&]() { policy_engine->CanDecryptContent(key_id_); }, + [&]() { policy_engine->CanUseKeyForSecurityLevel(key_id_); }, + [&]() { policy_engine->OnTimerEvent(); }, [&]() { - policyEngine->SetLicense( - mLicense, mFdp.ConsumeBool() /*defer_license_state_update*/); + policy_engine->SetLicense( + license_, fdp_.ConsumeBool() /*defer_license_state_update**/); }, [&]() { - int32_t maxEntitledKey = - mFdp.ConsumeIntegralInRange(1, kMaxEntitledKey); + int32_t max_entitled_key= + fdp_.ConsumeIntegralInRange(1, kMaxEntitledKey); std::vector entitled_keys( - maxEntitledKey); - for (int i = 0; i < maxEntitledKey; ++i) { + max_entitled_key); + for (int i = 0; i < max_entitled_key; ++i) { entitled_keys[i].set_entitlement_key_id( - mFdp.ConsumeRandomLengthString(kMaxByte)); + fdp_.ConsumeRandomLengthString(kMaxByte)); entitled_keys[i].set_key_id( - mFdp.ConsumeBool() - ? mFdp.ConsumeRandomLengthString(kMaxByte) - : mKeyId); + fdp_.ConsumeBool() + ? fdp_.ConsumeRandomLengthString(kMaxByte) + : key_id_); } - policyEngine->SetEntitledLicenseKeys(entitled_keys); + policy_engine->SetEntitledLicenseKeys(entitled_keys); }, - [&]() { policyEngine->SetLicenseForRelease(mLicense); }, - [&]() { policyEngine->BeginDecryption(); }, - [&]() { policyEngine->DecryptionEvent(); }, + [&]() { policy_engine->SetLicenseForRelease(license_); }, + [&]() { policy_engine->BeginDecryption(); }, + [&]() { policy_engine->DecryptionEvent(); }, [&]() { - policyEngine->UpdateLicense( - mLicense, mFdp.ConsumeBool() /*defer_license_state_update*/); + policy_engine->UpdateLicense( + license_, fdp_.ConsumeBool() /*defer_license_state_update*/); }, [&]() { - policyEngine->UpdateLicenseState( - mFdp.ConsumeIntegral() /*current_time*/); + policy_engine->UpdateLicenseState( + fdp_.ConsumeIntegral() /*current_time*/); }, [&]() { - int32_t width = mFdp.ConsumeIntegralInRange( + int32_t width = fdp_.ConsumeIntegralInRange( kMinResolution, kMaxResolution); - int32_t height = mFdp.ConsumeIntegralInRange( + int32_t height = fdp_.ConsumeIntegralInRange( kMinResolution, kMaxResolution); - policyEngine->NotifyResolution(width, height); + policy_engine->NotifyResolution(width, height); }, - [&]() { policyEngine->NotifySessionExpiration(); }, + [&]() { policy_engine->NotifySessionExpiration(); }, [&]() { CdmQueryMap query_info; - policyEngine->Query(&query_info); + policy_engine->Query(&query_info); }, [&]() { CdmKeyAllowedUsage key_usage; - policyEngine->QueryKeyAllowedUsage( - mKeyId, (mFdp.ConsumeBool() ? nullptr : &key_usage)); + policy_engine->QueryKeyAllowedUsage( + key_id_, (fdp_.ConsumeBool() ? nullptr : &key_usage)); }, [&]() { - policyEngine->RestorePlaybackTimes( - mFdp.ConsumeIntegral() /*playback_start_time*/, - mFdp.ConsumeIntegral() /*last_playback_time*/, - mFdp.ConsumeIntegral() /*grace_period_end_time*/); + policy_engine->RestorePlaybackTimes( + fdp_.ConsumeIntegral() /*playback_start_time*/, + fdp_.ConsumeIntegral() /*last_playback_time*/, + fdp_.ConsumeIntegral() /*grace_period_end_time*/); }, [&]() { - policyEngine->HasLicenseOrRentalOrPlaybackDurationExpired( - mFdp.ConsumeIntegral()); + policy_engine->HasLicenseOrRentalOrPlaybackDurationExpired( + fdp_.ConsumeIntegral()); }, }); invokePolicyEngineAPI(); @@ -347,7 +345,7 @@ void PolicyEngineFuzzer::process() { } extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { - PolicyEngineFuzzer policyEngineFuzzer(data, size); - policyEngineFuzzer.process(); + PolicyEngineFuzzer policy_engine_fuzzer(data, size); + policy_engine_fuzzer.Process(); return 0; }