From 2415894e2f65fced0fb1e7cf7a6d5ddb534edbbb Mon Sep 17 00:00:00 2001 From: Onkar Shinde Date: Tue, 12 Dec 2023 09:01:03 +0000 Subject: [PATCH] Updated cdm_license_fuzzer Implemented google c++ code style changes for cdm_license_fuzzer exec/s: 91 Test: ./cdm_license_fuzzer Bug: 312374669 Change-Id: Iac18772277cddad8ca182e60fc426721717d38d4 --- fuzzer/cdm_license_fuzzer.cpp | 477 +++++++++++++++++----------------- 1 file changed, 238 insertions(+), 239 deletions(-) diff --git a/fuzzer/cdm_license_fuzzer.cpp b/fuzzer/cdm_license_fuzzer.cpp index 923a1bab..52750baf 100644 --- a/fuzzer/cdm_license_fuzzer.cpp +++ b/fuzzer/cdm_license_fuzzer.cpp @@ -14,6 +14,8 @@ * limitations under the License. * */ +#include + #include "cdm_client_property_set.h" #include "cdm_identifier.h" #include "cdm_session.h" @@ -23,15 +25,14 @@ #include "vendor_widevine_fuzz_helper.h" #include "wv_cdm_constants.h" #include "wv_cdm_event_listener.h" -#include using namespace wvcdm; using wvutil::a2bs_hex; using namespace video_widevine; const static constexpr int32_t kMaxByte = 256; -const static constexpr int32_t kAPPVersion = 16; -const static constexpr int32_t kMaxAppParamSize = 10; +const static constexpr int32_t kAppVersion = 16; +static constexpr int32_t kMaxAppParamSize = 10; const static constexpr uint32_t kProtectionScheme[] = { 0x63626331, 0x63626373, 0x31636263, 0x73636263, 0x63656e63}; const std::string kInitDataType[] = {"video/mp4", "video/webm", "cenc", "hls", @@ -42,31 +43,31 @@ const static constexpr int32_t kSignedType[] = { SignedMessage::LICENSE, SignedMessage::SERVICE_CERTIFICATE, SignedMessage::ERROR_RESPONSE}; -const std::string kDefaultServiceCertificate = - a2bs_hex("0ABF020803121028703454C008F63618ADE7443DB6C4C8188BE7F9900522" - "8E023082010A0282010100B52112B8D05D023FCC5D95E2C251C1C649B417" - "7CD8D2BEEF355BB06743DE661E3D2ABC3182B79946D55FDC08DFE9540781" - "5E9A6274B322A2C7F5E067BB5F0AC07A89D45AEA94B2516F075B66EF811D" - "0D26E1B9A6B894F2B9857962AA171C4F66630D3E4C602718897F5E1EF9B6" - "AAF5AD4DBA2A7E14176DF134A1D3185B5A218AC05A4C41F081EFFF80A3A0" - "40C50B09BBC740EEDCD8F14D675A91980F92CA7DDC646A06ADAD5101F74A" - "0E498CC01F00532BAC217850BD905E90923656B7DFEFEF42486767F33EF6" - "283D4F4254AB72589390BEE55808F1D668080D45D893C2BCA2F74D60A0C0" - "D0A0993CEF01604703334C3638139486BC9DAF24FD67A07F9AD943020301" - "00013A1273746167696E672E676F6F676C652E636F6D128003983E303526" - "75F40BA715FC249BDAE5D4AC7249A2666521E43655739529721FF880E0AA" - "EFC5E27BC980DAEADABF3FC386D084A02C82537848CC753FF497B011A7DA" - "97788A00E2AA6B84CD7D71C07A48EBF61602CCA5A3F32030A7295C30DA91" - "5B91DC18B9BC9593B8DE8BB50F0DEDC12938B8E9E039CDDE18FA82E81BB0" - "32630FE955D85A566CE154300BF6D4C1BD126966356B287D657B18CE63D0" - "EFD45FC5269E97EAB11CB563E55643B26FF49F109C2101AFCAF35B832F28" - "8F0D9D45960E259E85FB5D24DBD2CF82764C5DD9BF727EFBE9C861F86932" - "1F6ADE18905F4D92F9A6DA6536DB8475871D168E870BB2303CF70C6E9784" - "C93D2DE845AD8262BE7E0D4E2E4A0759CEF82D109D2592C72429F8C01742" - "BAE2B3DECADBC33C3E5F4BAF5E16ECB74EADBAFCB7C6705F7A9E3B6F3940" - "383F9C5116D202A20C9229EE969C2519718303B50D0130C3352E06B014D8" - "38540F8A0C227C0011E0F5B38E4E298ED2CB301EB4564965F55C5D79757A" - "250A4EB9C84AB3E6539F6B6FDF56899EA29914"); +const std::string kDefaultServiceCertificate = a2bs_hex( + "0ABF020803121028703454C008F63618ADE7443DB6C4C8188BE7F9900522" + "8E023082010A0282010100B52112B8D05D023FCC5D95E2C251C1C649B417" + "7CD8D2BEEF355BB06743DE661E3D2ABC3182B79946D55FDC08DFE9540781" + "5E9A6274B322A2C7F5E067BB5F0AC07A89D45AEA94B2516F075B66EF811D" + "0D26E1B9A6B894F2B9857962AA171C4F66630D3E4C602718897F5E1EF9B6" + "AAF5AD4DBA2A7E14176DF134A1D3185B5A218AC05A4C41F081EFFF80A3A0" + "40C50B09BBC740EEDCD8F14D675A91980F92CA7DDC646A06ADAD5101F74A" + "0E498CC01F00532BAC217850BD905E90923656B7DFEFEF42486767F33EF6" + "283D4F4254AB72589390BEE55808F1D668080D45D893C2BCA2F74D60A0C0" + "D0A0993CEF01604703334C3638139486BC9DAF24FD67A07F9AD943020301" + "00013A1273746167696E672E676F6F676C652E636F6D128003983E303526" + "75F40BA715FC249BDAE5D4AC7249A2666521E43655739529721FF880E0AA" + "EFC5E27BC980DAEADABF3FC386D084A02C82537848CC753FF497B011A7DA" + "97788A00E2AA6B84CD7D71C07A48EBF61602CCA5A3F32030A7295C30DA91" + "5B91DC18B9BC9593B8DE8BB50F0DEDC12938B8E9E039CDDE18FA82E81BB0" + "32630FE955D85A566CE154300BF6D4C1BD126966356B287D657B18CE63D0" + "EFD45FC5269E97EAB11CB563E55643B26FF49F109C2101AFCAF35B832F28" + "8F0D9D45960E259E85FB5D24DBD2CF82764C5DD9BF727EFBE9C861F86932" + "1F6ADE18905F4D92F9A6DA6536DB8475871D168E870BB2303CF70C6E9784" + "C93D2DE845AD8262BE7E0D4E2E4A0759CEF82D109D2592C72429F8C01742" + "BAE2B3DECADBC33C3E5F4BAF5E16ECB74EADBAFCB7C6705F7A9E3B6F3940" + "383F9C5116D202A20C9229EE969C2519718303B50D0130C3352E06B014D8" + "38540F8A0C227C0011E0F5B38E4E298ED2CB301EB4564965F55C5D79757A" + "250A4EB9C84AB3E6539F6B6FDF56899EA29914"); const std::string kToken = a2bs_hex( "0AAE02080212107E0A892DEEB021E7AF696B938BB1D5B1188B85AD9D05228E023082010A02" @@ -106,92 +107,89 @@ const std::string kToken = a2bs_hex( "3C"); class FuzzCryptoSession : public CryptoSession { -public: + public: FuzzCryptoSession(metrics::CryptoMetrics *metrics, FuzzedDataProvider *fdp) - : CryptoSession(metrics), mFdp(fdp){}; + : CryptoSession(metrics), fdp_(fdp){}; - bool IsOpen() override { return mFdp->ConsumeBool(); }; + bool IsOpen() override { return fdp_->ConsumeBool(); }; const std::string &request_id() override { return kRequestId; }; bool GetApiVersion(uint32_t *api_version) override { - *api_version = kAPPVersion; - return mFdp->ConsumeBool(); + *api_version = kAppVersion; + return fdp_->ConsumeBool(); }; CdmResponseType GenerateNonce(uint32_t *license_nonce) override { - *license_nonce = mFdp->ConsumeIntegral(); - return (mFdp->ConsumeBool() ? CdmResponseType(NO_ERROR) + *license_nonce = fdp_->ConsumeIntegral(); + return (fdp_->ConsumeBool() ? CdmResponseType(NO_ERROR) : CdmResponseType(SESSION_LOST_STATE_ERROR)); }; CdmResponseType PrepareAndSignLicenseRequest( - const std::string& /*message*/, - std::string *core_message, - std::string *license_request_signature, - bool & /*shouldSpecifyAlgorithm*/, + const std::string & /*message*/, std::string *core_message, + std::string *license_request_signature, bool & /*shouldSpecifyAlgorithm*/, OEMCrypto_SignatureHashAlgorithm & /*algorithm*/) override { - *core_message = mFdp->ConsumeRandomLengthString(kMaxByte); - *license_request_signature = mFdp->ConsumeRandomLengthString(kMaxByte); - return (mFdp->ConsumeBool() ? CdmResponseType(NO_ERROR) + *core_message = fdp_->ConsumeRandomLengthString(kMaxByte); + *license_request_signature = fdp_->ConsumeRandomLengthString(kMaxByte); + return (fdp_->ConsumeBool() ? CdmResponseType(NO_ERROR) : CdmResponseType(NEED_PROVISIONING)); }; CdmResponseType LoadEntitledContentKeys( const std::vector & /*key_array*/) override { - return (mFdp->ConsumeBool() + return (fdp_->ConsumeBool() ? CdmResponseType(KEY_ADDED) : CdmResponseType(INSUFFICIENT_CRYPTO_RESOURCES)); }; - CdmResponseType - GenerateDerivedKeys(const std::string & /*message*/, - const std::string & /*session_key*/) override { - return (mFdp->ConsumeBool() + CdmResponseType GenerateDerivedKeys( + const std::string & /*message*/, + const std::string & /*session_key*/) override { + return (fdp_->ConsumeBool() ? CdmResponseType(NO_ERROR) : CdmResponseType(INSUFFICIENT_CRYPTO_RESOURCES)); }; CdmResponseType DeactivateUsageInformation( const std::string & /*provider_session_token*/) override { - return (mFdp->ConsumeBool() ? CdmResponseType(NO_ERROR) + return (fdp_->ConsumeBool() ? CdmResponseType(NO_ERROR) : CdmResponseType(SYSTEM_INVALIDATED_ERROR)); }; - CdmResponseType - GenerateUsageReport(const std::string & /*provider_session_token*/, - std::string *usage_report, - UsageDurationStatus *usage_duration_status, - int64_t *seconds_since_started, - int64_t *seconds_since_last_played) override { - *usage_report = mFdp->ConsumeRandomLengthString(kMaxByte); - *usage_duration_status = mFdp->ConsumeBool() + CdmResponseType GenerateUsageReport( + const std::string & /*provider_session_token*/, std::string *usage_report, + UsageDurationStatus *usage_duration_status, + int64_t *seconds_since_started, + int64_t *seconds_since_last_played) override { + *usage_report = fdp_->ConsumeRandomLengthString(kMaxByte); + *usage_duration_status = fdp_->ConsumeBool() ? CryptoSession::kUsageDurationPlaybackNotBegun : CryptoSession::kUsageDurationsValid; - *seconds_since_started = mFdp->ConsumeIntegral(); - *seconds_since_last_played = mFdp->ConsumeIntegral(); - return (mFdp->ConsumeBool() ? CdmResponseType(NO_ERROR) + *seconds_since_started = fdp_->ConsumeIntegral(); + *seconds_since_last_played = fdp_->ConsumeIntegral(); + return (fdp_->ConsumeBool() ? CdmResponseType(NO_ERROR) : CdmResponseType(SYSTEM_INVALIDATED_ERROR)); }; CdmResponseType PrepareAndSignRenewalRequest(const std::string & /*message*/, std::string *core_message, std::string *signature) { - *core_message = mFdp->ConsumeRandomLengthString(kMaxByte); - *signature = mFdp->ConsumeRandomLengthString(kMaxByte); - return (mFdp->ConsumeBool() ? CdmResponseType(NO_ERROR) + *core_message = fdp_->ConsumeRandomLengthString(kMaxByte); + *signature = fdp_->ConsumeRandomLengthString(kMaxByte); + return (fdp_->ConsumeBool() ? CdmResponseType(NO_ERROR) : CdmResponseType(PARAMETER_NULL)); }; CdmResponseType UseSecondaryKey(bool /*dual_key*/) override { - return (mFdp->ConsumeBool() ? CdmResponseType(NO_ERROR) + return (fdp_->ConsumeBool() ? CdmResponseType(NO_ERROR) : CdmResponseType(SYSTEM_INVALIDATED_ERROR)); }; CdmResponseType LoadRenewal(const std::string & /*signed_message*/, const std::string & /*core_message*/, const std::string & /*signature*/) override { - return (mFdp->ConsumeBool() + return (fdp_->ConsumeBool() ? CdmResponseType(KEY_ADDED) : CdmResponseType(INSUFFICIENT_CRYPTO_RESOURCES)); }; @@ -200,38 +198,38 @@ public: const std::string & /*core_message*/, const std::string & /*signature*/, CdmLicenseKeyType /*key_type*/) override { - return (mFdp->ConsumeBool() + return (fdp_->ConsumeBool() ? CdmResponseType(KEY_ADDED) : CdmResponseType(INSUFFICIENT_CRYPTO_RESOURCES)); }; CdmSecurityLevel GetSecurityLevel() override { - return (CdmSecurityLevel)mFdp->ConsumeIntegralInRange( + return (CdmSecurityLevel)fdp_->ConsumeIntegralInRange( kSecurityLevelUninitialized, kSecurityLevelUnknown); } -private: - FuzzedDataProvider *mFdp; + private: + FuzzedDataProvider *fdp_; }; class FuzzPolicyEngine : public PolicyEngine { -public: + public: FuzzPolicyEngine(CryptoSession *crypto, FuzzedDataProvider *fdp) - : PolicyEngine("mock_session_id", nullptr, crypto), mFdp(fdp){}; + : PolicyEngine("mock_session_id", nullptr, crypto), fdp_(fdp){}; void SetEntitledLicenseKeys(const std::vector & /*entitled_keys*/) override{}; - bool CanRenew() { return mFdp->ConsumeBool(); } + bool CanRenew() { return fdp_->ConsumeBool(); } bool GetSecondsSinceStarted(int64_t *seconds_since_started) { - *seconds_since_started = mFdp->ConsumeIntegral(); - return mFdp->ConsumeBool(); + *seconds_since_started = fdp_->ConsumeIntegral(); + return fdp_->ConsumeBool(); } bool GetSecondsSinceLastPlayed(int64_t *seconds_since_last_played) { - *seconds_since_last_played = mFdp->ConsumeIntegral(); - return mFdp->ConsumeBool(); + *seconds_since_last_played = fdp_->ConsumeIntegral(); + return fdp_->ConsumeBool(); }; void UpdateLicense(const License & /*license*/, bool /*defer_license_state_update*/){}; @@ -245,293 +243,294 @@ public: void SetLicense(const License & /*license*/, bool /*defer_license_state_update*/){}; -private: - FuzzedDataProvider *mFdp; + private: + FuzzedDataProvider *fdp_; }; class CdmLicenseFuzzer { -public: - CdmLicenseFuzzer(const uint8_t *data, size_t size) : mFdp(data, size){}; - void process(); + public: + CdmLicenseFuzzer(const uint8_t *data, size_t size) : fdp_(data, size){}; + void Process(); -private: - FuzzedDataProvider mFdp; - void createResponse(CdmKeyResponse *response); - void setLicenseMsg(std::string *msg); + private: + FuzzedDataProvider fdp_; + void CreateResponse(CdmKeyResponse *response); + void SetLicenseMsg(std::string *msg); }; -void policySetBool(std::function function, +void PolicySetBool(std::function function, FuzzedDataProvider *fdp) { if (fdp->ConsumeBool()) { function(fdp->ConsumeBool()); } } -void CdmLicenseFuzzer::setLicenseMsg(std::string *msg) { +void CdmLicenseFuzzer::SetLicenseMsg(std::string *msg) { 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.ConsumeBool() - ? mFdp.PickValueInArray(kProtectionScheme) - : mFdp.ConsumeIntegral(); + if (fdp_.ConsumeBool()) { + uint32_t scheme = fdp_.ConsumeBool() + ? fdp_.PickValueInArray(kProtectionScheme) + : fdp_.ConsumeIntegral(); license.set_protection_scheme(scheme); } License::KeyContainer *container = license.add_key(); - if (mFdp.ConsumeBool()) { - uint32_t keyType = mFdp.ConsumeIntegralInRange( + if (fdp_.ConsumeBool()) { + uint32_t key_type = fdp_.ConsumeIntegralInRange( License::KeyContainer::SIGNING, License::KeyContainer::ENTITLEMENT); - container->set_type((License_KeyContainer_KeyType)keyType); + container->set_type((License_KeyContainer_KeyType)key_type); } - if (mFdp.ConsumeBool()) { - const std::string ivString = mFdp.ConsumeRandomLengthString(kMaxByte); - container->set_iv(ivString); - } else if (mFdp.ConsumeBool()) { + if (fdp_.ConsumeBool()) { + const std::string iv_string = fdp_.ConsumeRandomLengthString(kMaxByte); + container->set_iv(iv_string); + } else if (fdp_.ConsumeBool()) { container->mutable_iv(); } - if (mFdp.ConsumeBool()) { - std::string keyString = mFdp.ConsumeRandomLengthString(kMaxByte); - container->set_key(keyString); - } else if (mFdp.ConsumeBool()) { - container->mutable_key(); + if (fdp_.ConsumeBool()) { + std::string key_string = fdp_.ConsumeRandomLengthString(kMaxByte); + container->set_key(key_string); + } else if (fdp_.ConsumeBool()) { + container->mutable_key(); } - if (mFdp.ConsumeBool()) { - const std::string idString = mFdp.ConsumeRandomLengthString(kMaxByte); - container->set_id(idString); - } else if (mFdp.ConsumeBool()) { + if (fdp_.ConsumeBool()) { + const std::string id_string = fdp_.ConsumeRandomLengthString(kMaxByte); + container->set_id(id_string); + } else if (fdp_.ConsumeBool()) { container->mutable_id(); } - if (mFdp.ConsumeBool()) { - const std::string trackLabel = mFdp.ConsumeRandomLengthString(kMaxByte); - container->set_track_label(trackLabel); - } else if (mFdp.ConsumeBool()) { + if (fdp_.ConsumeBool()) { + const std::string track_label = fdp_.ConsumeRandomLengthString(kMaxByte); + container->set_track_label(track_label); + } else if (fdp_.ConsumeBool()) { container->mutable_track_label(); } - License_KeyContainer_KeyControl *keyControl = + License_KeyContainer_KeyControl *key_control = container->mutable_key_control(); - if (mFdp.ConsumeBool()) { - std::string keyControlMsg = mFdp.ConsumeRandomLengthString(kMaxByte); - keyControl->set_key_control_block(keyControlMsg); - } else if (mFdp.ConsumeBool()) { - keyControl->mutable_key_control_block(); + if (fdp_.ConsumeBool()) { + std::string key_control_msg = fdp_.ConsumeRandomLengthString(kMaxByte); + key_control->set_key_control_block(key_control_msg); + } else if (fdp_.ConsumeBool()) { + key_control->mutable_key_control_block(); } - if (mFdp.ConsumeBool()) { - const std::string ivString = mFdp.ConsumeRandomLengthString(kMaxByte); - keyControl->set_iv(ivString); - } else if (mFdp.ConsumeBool()) { - keyControl->mutable_iv(); + if (fdp_.ConsumeBool()) { + const std::string iv_string = fdp_.ConsumeRandomLengthString(kMaxByte); + key_control->set_iv(iv_string); + } else if (fdp_.ConsumeBool()) { + key_control->mutable_iv(); } - if (mFdp.ConsumeBool()) { + if (fdp_.ConsumeBool()) { License_Policy *policy = license.mutable_policy(); - policySetBool(std::bind(&License_Policy::set_can_persist, policy, + PolicySetBool(std::bind(&License_Policy::set_can_persist, policy, std::placeholders::_1), - &mFdp); + &fdp_); - if (mFdp.ConsumeBool()) { - std::string server_url = mFdp.ConsumeRandomLengthString(kMaxByte); + if (fdp_.ConsumeBool()) { + std::string server_url = fdp_.ConsumeRandomLengthString(kMaxByte); policy->set_renewal_server_url(server_url); } - policySetBool(std::bind(&License_Policy::set_always_include_client_id, + PolicySetBool(std::bind(&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() ? STREAMING : OFFLINE); + if (fdp_.ConsumeBool()) { + id->set_type(fdp_.ConsumeBool() ? STREAMING : 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 CdmLicenseFuzzer::createResponse(CdmKeyResponse *response) { +void CdmLicenseFuzzer::CreateResponse(CdmKeyResponse *response) { SignedMessage signed_message; SignedMessage type; signed_message.set_type( - (SignedMessage_MessageType)mFdp.PickValueInArray(kSignedType)); + (SignedMessage_MessageType)fdp_.PickValueInArray(kSignedType)); - if (mFdp.ConsumeBool()) { + if (fdp_.ConsumeBool()) { signed_message.mutable_service_version_info(); } - if (mFdp.ConsumeBool()) { - signed_message.set_signature(mFdp.ConsumeRandomLengthString(kMaxByte)); + if (fdp_.ConsumeBool()) { + signed_message.set_signature(fdp_.ConsumeRandomLengthString(kMaxByte)); } - if (mFdp.ConsumeBool()) { - signed_message.set_session_key(mFdp.ConsumeRandomLengthString(kMaxByte)); + if (fdp_.ConsumeBool()) { + signed_message.set_session_key(fdp_.ConsumeRandomLengthString(kMaxByte)); } - if (mFdp.ConsumeBool()) { + if (fdp_.ConsumeBool()) { signed_message.set_oemcrypto_core_message( - mFdp.ConsumeRandomLengthString(kMaxByte)); + fdp_.ConsumeRandomLengthString(kMaxByte)); } - if (mFdp.ConsumeBool()) { - signed_message.set_using_secondary_key(mFdp.ConsumeBool()); + if (fdp_.ConsumeBool()) { + signed_message.set_using_secondary_key(fdp_.ConsumeBool()); } - if (mFdp.ConsumeBool()) { - std::string setMsg; - setLicenseMsg(&setMsg); - signed_message.set_msg(setMsg); + if (fdp_.ConsumeBool()) { + std::string set_msg; + SetLicenseMsg(&set_msg); + signed_message.set_msg(set_msg); } signed_message.SerializeToString(response); } -void CdmLicenseFuzzer::process() { - CdmSessionId sessionId = mFdp.ConsumeRandomLengthString(kMaxByte); - CdmLicense cdmLicense(sessionId); +void CdmLicenseFuzzer::Process() { + CdmSessionId session_id = fdp_.ConsumeRandomLengthString(kMaxByte); + CdmLicense cdm_license(session_id); metrics::CryptoMetrics crypto_metrics; - std::unique_ptr cryptoSession( - new FuzzCryptoSession(&crypto_metrics, &mFdp)); - std::unique_ptr policyEngine( - new FuzzPolicyEngine(cryptoSession.get(), &mFdp)); + std::unique_ptr crypto_session( + new FuzzCryptoSession(&crypto_metrics, &fdp_)); + std::unique_ptr policy_engine( + new FuzzPolicyEngine(crypto_session.get(), &fdp_)); - bool status = cdmLicense.Init(mFdp.ConsumeBool(), kDefaultServiceCertificate, - cryptoSession.get(), policyEngine.get()); + bool status = cdm_license.Init(fdp_.ConsumeBool(), kDefaultServiceCertificate, + crypto_session.get(), policy_engine.get()); if (status) { - std::shared_ptr cdmMetrics( + std::shared_ptr cdm_metrics( new metrics::SessionMetrics); wvutil::FileSystem file_system; - std::unique_ptr cdmSession( - new CdmSession(&file_system, cdmMetrics)); - std::unique_ptr fuzzCdmClientPropertySet( - new FuzzCdmClientPropertySet(&mFdp)); - cdmSession->Init(fuzzCdmClientPropertySet.get()); - std::string dataType = mFdp.ConsumeBool() - ? mFdp.PickValueInArray(kInitDataType) - : mFdp.ConsumeRandomLengthString(kMaxByte); - std::unique_ptr initData(new InitializationData( - dataType, a2bs_hex(mFdp.ConsumeRandomLengthString(kMaxByte)))); + std::unique_ptr cdm_session( + new CdmSession(&file_system, cdm_metrics)); + std::unique_ptr fuzz_cdm_client_property_set( + new FuzzCdmClientPropertySet(&fdp_)); + cdm_session->Init(fuzz_cdm_client_property_set.get()); + std::string data_type = fdp_.ConsumeBool() + ? fdp_.PickValueInArray(kInitDataType) + : fdp_.ConsumeRandomLengthString(kMaxByte); + std::unique_ptr init_data(new InitializationData( + data_type, a2bs_hex(fdp_.ConsumeRandomLengthString(kMaxByte)))); CdmKeyResponse response; - if (mFdp.ConsumeBool()) { - createResponse(&response); + if (fdp_.ConsumeBool()) { + CreateResponse(&response); } else { response = - mFdp.ConsumeBool() ? "" : mFdp.ConsumeRandomLengthString(kMaxByte); + fdp_.ConsumeBool() ? "" : fdp_.ConsumeRandomLengthString(kMaxByte); } - CdmKeyMessage signedRequest = mFdp.ConsumeRandomLengthString(kMaxByte); - while (mFdp.remaining_bytes()) { - auto invokeLicenseAPI = - mFdp.PickValueInArray>({ + CdmKeyMessage signed_request = fdp_.ConsumeRandomLengthString(kMaxByte); + while (fdp_.remaining_bytes()) { + auto invoke_license_API = + fdp_.PickValueInArray>({ [&]() { - CdmLicenseType licenseType = - (CdmLicenseType)mFdp.ConsumeIntegralInRange( + CdmLicenseType license_type = + (CdmLicenseType)fdp_.ConsumeIntegralInRange( kLicenseTypeOffline, kLicenseTypeEmbeddedKeyData); - std::string serverUrl; + std::string server_url; CdmAppParameterMap param; - int32_t maxSize = - mFdp.ConsumeIntegralInRange(0, kMaxAppParamSize); - for (size_t i = 0; i < maxSize; ++i) { - std::string key = mFdp.ConsumeRandomLengthString(kMaxByte); - std::string value = mFdp.ConsumeRandomLengthString(kMaxByte); - std::string cdmKey(key.c_str(), key.size()); - std::string cdmValue(value.c_str(), value.size()); - param[cdmKey] = cdmValue; + int32_t max_size = + fdp_.ConsumeIntegralInRange(0, kMaxAppParamSize); + for (size_t i = 0; i < max_size; ++i) { + std::string key = fdp_.ConsumeRandomLengthString(kMaxByte); + std::string value = fdp_.ConsumeRandomLengthString(kMaxByte); + std::string cdm_key(key.c_str(), key.size()); + std::string cdm_value(value.c_str(), value.size()); + param[cdm_key] = cdm_value; } - std::string clientToken = - mFdp.ConsumeBool() - ? mFdp.ConsumeRandomLengthString(kMaxByte) + std::string client_token = + fdp_.ConsumeBool() + ? fdp_.ConsumeRandomLengthString(kMaxByte) : kToken; - cdmLicense.PrepareKeyRequest( - *initData, clientToken, - licenseType /*kLicenseTypeStreaming*/, param, - (mFdp.ConsumeBool() ? &signedRequest : nullptr), - (mFdp.ConsumeBool() ? &serverUrl : nullptr)); + cdm_license.PrepareKeyRequest( + *init_data, client_token, + license_type /*kLicenseTypeStreaming*/, param, + (fdp_.ConsumeBool() ? &signed_request : nullptr), + (fdp_.ConsumeBool() ? &server_url : nullptr)); }, [&]() { - std::string signedServiceCertificate = - mFdp.ConsumeRandomLengthString(kMaxByte); - cdmLicense.SetServiceCertificate(signedServiceCertificate); + std::string signed_service_certificate = + fdp_.ConsumeRandomLengthString(kMaxByte); + cdm_license.SetServiceCertificate(signed_service_certificate); }, [&]() { - std::string serverUrl; + std::string server_url; CdmAppParameterMap param; - int32_t maxSize = - mFdp.ConsumeIntegralInRange(0, kMaxAppParamSize); - for (size_t i = 0; i < maxSize; ++i) { - std::string key = mFdp.ConsumeRandomLengthString(kMaxByte); - std::string value = mFdp.ConsumeRandomLengthString(kMaxByte); - std::string cdmKey(key.c_str(), key.size()); - std::string cdmValue(value.c_str(), value.size()); - param[cdmKey] = cdmValue; + int32_t max_size = + fdp_.ConsumeIntegralInRange(0, kMaxAppParamSize); + for (size_t i = 0; i < max_size; ++i) { + std::string key = fdp_.ConsumeRandomLengthString(kMaxByte); + std::string value = fdp_.ConsumeRandomLengthString(kMaxByte); + std::string cdm_key(key.c_str(), key.size()); + std::string cdm_value(value.c_str(), value.size()); + param[cdm_key] = cdm_value; } - cdmLicense.PrepareKeyUpdateRequest( - mFdp.ConsumeBool(), param, cdmSession.get(), - (mFdp.ConsumeBool() ? &signedRequest : nullptr), - (mFdp.ConsumeBool() ? &serverUrl : nullptr)); + cdm_license.PrepareKeyUpdateRequest( + fdp_.ConsumeBool(), param, cdm_session.get(), + (fdp_.ConsumeBool() ? &signed_request : nullptr), + (fdp_.ConsumeBool() ? &server_url : nullptr)); }, [&]() { - cdmLicense.HandleKeyResponse(mFdp.ConsumeBool(), response); + cdm_license.HandleKeyResponse(fdp_.ConsumeBool(), response); }, [&]() { - cdmLicense.HandleKeyUpdateResponse( - mFdp.ConsumeBool() /*is_renewal*/, - mFdp.ConsumeBool() /*is_restore*/, response); + cdm_license.HandleKeyUpdateResponse( + fdp_.ConsumeBool() /*is_renewal*/, + fdp_.ConsumeBool() /*is_restore*/, response); }, - [&]() { cdmLicense.HandleEmbeddedKeyData(*initData); }, + [&]() { cdm_license.HandleEmbeddedKeyData(*init_data); }, [&]() { - CdmKeyResponse renewResponse; - createResponse(&renewResponse); - std::string clientToken = - mFdp.ConsumeBool() - ? mFdp.ConsumeRandomLengthString(kMaxByte) + CdmKeyResponse renew_response; + CreateResponse(&renew_response); + std::string client_token = + fdp_.ConsumeBool() + ? fdp_.ConsumeRandomLengthString(kMaxByte) : kToken; - cdmLicense.RestoreOfflineLicense( - clientToken, signedRequest, response, renewResponse, - mFdp.ConsumeIntegral() /*playback_start_time*/, - mFdp.ConsumeIntegral() /*last_playback_time*/, - mFdp.ConsumeIntegral() /*grace_period_end_time*/, - cdmSession.get()); + cdm_license.RestoreOfflineLicense( + client_token, signed_request, response, renew_response, + fdp_.ConsumeIntegral() /*playback_start_time*/, + fdp_.ConsumeIntegral() /*last_playback_time*/, + fdp_.ConsumeIntegral() /*grace_period_end_time*/, + cdm_session.get()); }, [&]() { - std::string clientToken = - mFdp.ConsumeBool() - ? mFdp.ConsumeRandomLengthString(kMaxByte) + std::string client_token = + fdp_.ConsumeBool() + ? fdp_.ConsumeRandomLengthString(kMaxByte) : kToken; - cdmLicense.RestoreLicenseForRelease(clientToken, signedRequest, - response); + cdm_license.RestoreLicenseForRelease(client_token, + signed_request, response); }, [&]() { - KeyId keyId = mFdp.ConsumeRandomLengthString(kMaxByte); - cdmLicense.IsKeyLoaded(keyId); + KeyId key_id = fdp_.ConsumeRandomLengthString(kMaxByte); + cdm_license.IsKeyLoaded(key_id); }, [&]() { - std::string sessionToken; - cdmLicense.ExtractProviderSessionToken(response, &sessionToken); + std::string session_token; + cdm_license.ExtractProviderSessionToken(response, + &session_token); }, }); - invokeLicenseAPI(); + invoke_license_API(); } } } extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { - CdmLicenseFuzzer cdmLicenseFuzzer(data, size); - cdmLicenseFuzzer.process(); + CdmLicenseFuzzer cdm_license_fuzzer(data, size); + cdm_license_fuzzer.Process(); return 0; }