2415894e2f
Implemented google c++ code style changes for cdm_license_fuzzer exec/s: 91 Test: ./cdm_license_fuzzer Bug: 312374669 Change-Id: Iac18772277cddad8ca182e60fc426721717d38d4
537 lines
22 KiB
C++
537 lines
22 KiB
C++
/*
|
|
* Copyright (C) 2023 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*/
|
|
#include <fuzzer/FuzzedDataProvider.h>
|
|
|
|
#include "cdm_client_property_set.h"
|
|
#include "cdm_identifier.h"
|
|
#include "cdm_session.h"
|
|
#include "license.h"
|
|
#include "policy_engine.h"
|
|
#include "string_conversions.h"
|
|
#include "vendor_widevine_fuzz_helper.h"
|
|
#include "wv_cdm_constants.h"
|
|
#include "wv_cdm_event_listener.h"
|
|
|
|
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;
|
|
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",
|
|
"webm"};
|
|
const std::string kRequestId = "request_id";
|
|
|
|
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 kToken = a2bs_hex(
|
|
"0AAE02080212107E0A892DEEB021E7AF696B938BB1D5B1188B85AD9D05228E023082010A02"
|
|
"82010100DBEDF2BFB0EC98213766E65049B9AB176FA4B1FBFBB2A0C96C87D9F2B895E0ED77"
|
|
"93BDA057E6BC3E0CA2348BC6831E03609445CA4D418CB98EAC98FFC87AB2364CE76BA26BEE"
|
|
"CDB0C45BD2A6FE9FD38CC5A1C26303AEEB7E9C3CAFAB0D10E46C07E50BEDAB42BF21F40BD2"
|
|
"E055DB0B455191D6B4CEEB11B3F1AFA42B5C0CE4C96B75A5283C0E3AE049AA7CF86D1C4EF6"
|
|
"6A9088B53BCF320ABC9B98A22C219DC109014EFEA72DA5FF2ED5D655DE7AE06EAC6C6B4191"
|
|
"523B2CD2DC1EBFF5F08B11CFE056F2826C1323F12704EC7EBBC1AF935129E5543804492AF9"
|
|
"23B848F4AF47B4BFB131C39DDDC99DBAEEE0F30AD2ADBBC63E60793D0876E37391008BB4DB"
|
|
"F7020301000128DD22128002A9E571776EA9D22A1BD14248DA88E12FD859989F613360B8D2"
|
|
"DA40AF31CC071C7A138466F0EB745E3FD664C0E1A5E4F01098B8D56C34A0158DF9916D192F"
|
|
"841ADCA17FD630E1C0CBE652CAC6A52B6A1581BE4029CE6FAE0E04D2D2C7861187AF8299D8"
|
|
"3E008DB9A2789672CA1DED903773D7E82B234CE2C799EB73CF80600C08F17EEDDDF369D2B8"
|
|
"4A08292F22D1F18FE89521905E713BA674F2217881DBD7711B8C48D5FDCE6FAB51F935E293"
|
|
"CB29191AB012B115FD2F5F23164B063D0A929C3E254BF0F4FA60051EB6B3498ED99FF77C19"
|
|
"68E8CD83A35CEB054D05433FD0EA6AAE43C87DDA377591D1DCC1831EE130BFFF6D139A5ADA"
|
|
"738B0F257CCE2649E71AB4050AAE020801121017DCBC27D11341D497135442A188DAA6188F"
|
|
"89809105228E023082010A0282010100D21ADD7549D2748B3494526A9C3FB86C79376BBE8C"
|
|
"8856F601B8D10461F77ACC7331B10DEBF365120056CDB5662D25907B74F12382F0F4A0CA47"
|
|
"5EEA9562815C6228F6F698ADA27879D8890F2A2D96A746DDEF5316301C003519C2A2250354"
|
|
"674169FDDA41CE14D3C52BEA7A20384515012D5952B38AA19E15E8563CC7AAA81C2122880A"
|
|
"A370A64FEA23C53FB83AC3DB5753214730A349E07F64BF32BE7EAD30D02612AF110BB44FB0"
|
|
"8E1D308173B327EF64D40C41639542B2D1A73C98A6607EC6C683B513A58470514106EF87AE"
|
|
"1E7B9C695B93A104DF7437BFC4167789748A43ED208F2C1FA710793C688885EAE732A8BFDF"
|
|
"5B423B23D75B88FC0ADC8FBDB5020301000128DD2212800372D2FB88098BA3B85B6B4354E0"
|
|
"3767DBE2D7724663FB0A62ABF7704EA910E01F221349EE16D0152C769384050CE78520668C"
|
|
"06CCFD3D789AF3EB69FF163615CD609169FDBE2E15A029D34AD2605625BC81844C9D1E2CE0"
|
|
"519039F3799ADAEF86641E20B033DC16DF2E5B9A1A2A417B8BB3B7A4D9AD1A99367448587D"
|
|
"A13DDE05A3ED9D62FA42078973B4AA40263D7BFA23F1072E94CDF323FA45F78408823E55C4"
|
|
"F4C5C723819CF44CE6D98E50C04EC24D93B1AAB8877B9108B9CA391308E1A3645EBB0E7CAC"
|
|
"BB40B5451560ED799421873BFB5ABB917FA60DB9C77CB8606AF7E3142626F5EA40E5CB8AA0"
|
|
"89D8E7D6A9361935C426A4450EA8BC2E57290D3BF0A0962991D2A91B752FC80C3E7E4E5503"
|
|
"3D71C94B325307A68815F026448F56A2741CEBEFC18E8C142F5F62BFAA67A291517DDE982D"
|
|
"8CD5A9DF6E3D3A99B806F6D60991358C5BE77117D4F3168F3348E9A048539F892F4D783152"
|
|
"C7A8095224AA56B78C5CF7BD1AB1B179C0C0D11E3C3BAC84C141A00191321E3ACC17242E68"
|
|
"3C");
|
|
|
|
class FuzzCryptoSession : public CryptoSession {
|
|
public:
|
|
FuzzCryptoSession(metrics::CryptoMetrics *metrics, FuzzedDataProvider *fdp)
|
|
: CryptoSession(metrics), fdp_(fdp){};
|
|
|
|
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 fdp_->ConsumeBool();
|
|
};
|
|
|
|
CdmResponseType GenerateNonce(uint32_t *license_nonce) override {
|
|
*license_nonce = fdp_->ConsumeIntegral<uint32_t>();
|
|
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*/,
|
|
OEMCrypto_SignatureHashAlgorithm & /*algorithm*/) override {
|
|
*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<CryptoKey> & /*key_array*/) override {
|
|
return (fdp_->ConsumeBool()
|
|
? CdmResponseType(KEY_ADDED)
|
|
: CdmResponseType(INSUFFICIENT_CRYPTO_RESOURCES));
|
|
};
|
|
|
|
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 (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 = fdp_->ConsumeRandomLengthString(kMaxByte);
|
|
*usage_duration_status = fdp_->ConsumeBool()
|
|
? CryptoSession::kUsageDurationPlaybackNotBegun
|
|
: CryptoSession::kUsageDurationsValid;
|
|
*seconds_since_started = fdp_->ConsumeIntegral<int64_t>();
|
|
*seconds_since_last_played = fdp_->ConsumeIntegral<int64_t>();
|
|
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 = fdp_->ConsumeRandomLengthString(kMaxByte);
|
|
*signature = fdp_->ConsumeRandomLengthString(kMaxByte);
|
|
return (fdp_->ConsumeBool() ? CdmResponseType(NO_ERROR)
|
|
: CdmResponseType(PARAMETER_NULL));
|
|
};
|
|
|
|
CdmResponseType UseSecondaryKey(bool /*dual_key*/) override {
|
|
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 (fdp_->ConsumeBool()
|
|
? CdmResponseType(KEY_ADDED)
|
|
: CdmResponseType(INSUFFICIENT_CRYPTO_RESOURCES));
|
|
};
|
|
|
|
CdmResponseType LoadLicense(const std::string & /*signed_message*/,
|
|
const std::string & /*core_message*/,
|
|
const std::string & /*signature*/,
|
|
CdmLicenseKeyType /*key_type*/) override {
|
|
return (fdp_->ConsumeBool()
|
|
? CdmResponseType(KEY_ADDED)
|
|
: CdmResponseType(INSUFFICIENT_CRYPTO_RESOURCES));
|
|
};
|
|
|
|
CdmSecurityLevel GetSecurityLevel() override {
|
|
return (CdmSecurityLevel)fdp_->ConsumeIntegralInRange<int32_t>(
|
|
kSecurityLevelUninitialized, kSecurityLevelUnknown);
|
|
}
|
|
|
|
private:
|
|
FuzzedDataProvider *fdp_;
|
|
};
|
|
|
|
class FuzzPolicyEngine : public PolicyEngine {
|
|
public:
|
|
FuzzPolicyEngine(CryptoSession *crypto, FuzzedDataProvider *fdp)
|
|
: PolicyEngine("mock_session_id", nullptr, crypto), fdp_(fdp){};
|
|
|
|
void SetEntitledLicenseKeys(const std::vector<WidevinePsshData_EntitledKey>
|
|
& /*entitled_keys*/) override{};
|
|
|
|
bool CanRenew() { return fdp_->ConsumeBool(); }
|
|
|
|
bool GetSecondsSinceStarted(int64_t *seconds_since_started) {
|
|
*seconds_since_started = fdp_->ConsumeIntegral<int64_t>();
|
|
return fdp_->ConsumeBool();
|
|
}
|
|
|
|
bool GetSecondsSinceLastPlayed(int64_t *seconds_since_last_played) {
|
|
*seconds_since_last_played = fdp_->ConsumeIntegral<int64_t>();
|
|
return fdp_->ConsumeBool();
|
|
};
|
|
void UpdateLicense(const License & /*license*/,
|
|
bool /*defer_license_state_update*/){};
|
|
|
|
void RestorePlaybackTimes(int64_t /*playback_start_time*/,
|
|
int64_t /*last_playback_time*/,
|
|
int64_t /*grace_period_end_time*/){};
|
|
|
|
void SetLicenseForRelease(const License & /*license*/){};
|
|
|
|
void SetLicense(const License & /*license*/,
|
|
bool /*defer_license_state_update*/){};
|
|
|
|
private:
|
|
FuzzedDataProvider *fdp_;
|
|
};
|
|
|
|
class CdmLicenseFuzzer {
|
|
public:
|
|
CdmLicenseFuzzer(const uint8_t *data, size_t size) : fdp_(data, size){};
|
|
void Process();
|
|
|
|
private:
|
|
FuzzedDataProvider fdp_;
|
|
void CreateResponse(CdmKeyResponse *response);
|
|
void SetLicenseMsg(std::string *msg);
|
|
};
|
|
|
|
void PolicySetBool(std::function<void(bool)> function,
|
|
FuzzedDataProvider *fdp) {
|
|
if (fdp->ConsumeBool()) {
|
|
function(fdp->ConsumeBool());
|
|
}
|
|
}
|
|
|
|
void CdmLicenseFuzzer::SetLicenseMsg(std::string *msg) {
|
|
License license;
|
|
|
|
if (fdp_.ConsumeBool()) {
|
|
std::string provider_client_token =
|
|
fdp_.ConsumeRandomLengthString(kMaxByte);
|
|
license.set_provider_client_token(provider_client_token);
|
|
}
|
|
if (fdp_.ConsumeBool()) {
|
|
uint32_t scheme = fdp_.ConsumeBool()
|
|
? fdp_.PickValueInArray(kProtectionScheme)
|
|
: fdp_.ConsumeIntegral<uint32_t>();
|
|
license.set_protection_scheme(scheme);
|
|
}
|
|
|
|
License::KeyContainer *container = license.add_key();
|
|
|
|
if (fdp_.ConsumeBool()) {
|
|
uint32_t key_type = fdp_.ConsumeIntegralInRange<uint8_t>(
|
|
License::KeyContainer::SIGNING, License::KeyContainer::ENTITLEMENT);
|
|
container->set_type((License_KeyContainer_KeyType)key_type);
|
|
}
|
|
|
|
if (fdp_.ConsumeBool()) {
|
|
const std::string iv_string = fdp_.ConsumeRandomLengthString(kMaxByte);
|
|
container->set_iv(iv_string);
|
|
} else if (fdp_.ConsumeBool()) {
|
|
container->mutable_iv();
|
|
}
|
|
|
|
if (fdp_.ConsumeBool()) {
|
|
std::string key_string = fdp_.ConsumeRandomLengthString(kMaxByte);
|
|
container->set_key(key_string);
|
|
} else if (fdp_.ConsumeBool()) {
|
|
container->mutable_key();
|
|
}
|
|
|
|
if (fdp_.ConsumeBool()) {
|
|
const std::string id_string = fdp_.ConsumeRandomLengthString(kMaxByte);
|
|
container->set_id(id_string);
|
|
} else if (fdp_.ConsumeBool()) {
|
|
container->mutable_id();
|
|
}
|
|
|
|
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 *key_control =
|
|
container->mutable_key_control();
|
|
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 (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 (fdp_.ConsumeBool()) {
|
|
License_Policy *policy = license.mutable_policy();
|
|
|
|
PolicySetBool(std::bind(&License_Policy::set_can_persist, policy,
|
|
std::placeholders::_1),
|
|
&fdp_);
|
|
|
|
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,
|
|
policy, std::placeholders::_1),
|
|
&fdp_);
|
|
}
|
|
|
|
LicenseIdentification *id = license.mutable_id();
|
|
if (fdp_.ConsumeBool()) {
|
|
id->set_type(fdp_.ConsumeBool() ? STREAMING : OFFLINE);
|
|
}
|
|
if (fdp_.ConsumeBool()) {
|
|
std::string provider_session_token =
|
|
fdp_.ConsumeRandomLengthString(kMaxByte);
|
|
id->set_provider_session_token(provider_session_token);
|
|
}
|
|
license.SerializeToString(msg);
|
|
}
|
|
|
|
void CdmLicenseFuzzer::CreateResponse(CdmKeyResponse *response) {
|
|
SignedMessage signed_message;
|
|
SignedMessage type;
|
|
signed_message.set_type(
|
|
(SignedMessage_MessageType)fdp_.PickValueInArray(kSignedType));
|
|
|
|
if (fdp_.ConsumeBool()) {
|
|
signed_message.mutable_service_version_info();
|
|
}
|
|
|
|
if (fdp_.ConsumeBool()) {
|
|
signed_message.set_signature(fdp_.ConsumeRandomLengthString(kMaxByte));
|
|
}
|
|
|
|
if (fdp_.ConsumeBool()) {
|
|
signed_message.set_session_key(fdp_.ConsumeRandomLengthString(kMaxByte));
|
|
}
|
|
|
|
if (fdp_.ConsumeBool()) {
|
|
signed_message.set_oemcrypto_core_message(
|
|
fdp_.ConsumeRandomLengthString(kMaxByte));
|
|
}
|
|
|
|
if (fdp_.ConsumeBool()) {
|
|
signed_message.set_using_secondary_key(fdp_.ConsumeBool());
|
|
}
|
|
|
|
if (fdp_.ConsumeBool()) {
|
|
std::string set_msg;
|
|
SetLicenseMsg(&set_msg);
|
|
signed_message.set_msg(set_msg);
|
|
}
|
|
signed_message.SerializeToString(response);
|
|
}
|
|
|
|
void CdmLicenseFuzzer::Process() {
|
|
CdmSessionId session_id = fdp_.ConsumeRandomLengthString(kMaxByte);
|
|
CdmLicense cdm_license(session_id);
|
|
|
|
metrics::CryptoMetrics crypto_metrics;
|
|
std::unique_ptr<CryptoSession> crypto_session(
|
|
new FuzzCryptoSession(&crypto_metrics, &fdp_));
|
|
std::unique_ptr<PolicyEngine> policy_engine(
|
|
new FuzzPolicyEngine(crypto_session.get(), &fdp_));
|
|
|
|
bool status = cdm_license.Init(fdp_.ConsumeBool(), kDefaultServiceCertificate,
|
|
crypto_session.get(), policy_engine.get());
|
|
|
|
if (status) {
|
|
std::shared_ptr<metrics::SessionMetrics> cdm_metrics(
|
|
new metrics::SessionMetrics);
|
|
wvutil::FileSystem file_system;
|
|
std::unique_ptr<CdmSession> cdm_session(
|
|
new CdmSession(&file_system, cdm_metrics));
|
|
std::unique_ptr<FuzzCdmClientPropertySet> 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<InitializationData> init_data(new InitializationData(
|
|
data_type, a2bs_hex(fdp_.ConsumeRandomLengthString(kMaxByte))));
|
|
|
|
CdmKeyResponse response;
|
|
if (fdp_.ConsumeBool()) {
|
|
CreateResponse(&response);
|
|
} else {
|
|
response =
|
|
fdp_.ConsumeBool() ? "" : fdp_.ConsumeRandomLengthString(kMaxByte);
|
|
}
|
|
|
|
CdmKeyMessage signed_request = fdp_.ConsumeRandomLengthString(kMaxByte);
|
|
while (fdp_.remaining_bytes()) {
|
|
auto invoke_license_API =
|
|
fdp_.PickValueInArray<const std::function<void()>>({
|
|
[&]() {
|
|
CdmLicenseType license_type =
|
|
(CdmLicenseType)fdp_.ConsumeIntegralInRange<int32_t>(
|
|
kLicenseTypeOffline, kLicenseTypeEmbeddedKeyData);
|
|
std::string server_url;
|
|
CdmAppParameterMap param;
|
|
int32_t max_size =
|
|
fdp_.ConsumeIntegralInRange<int32_t>(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 client_token =
|
|
fdp_.ConsumeBool()
|
|
? fdp_.ConsumeRandomLengthString(kMaxByte)
|
|
: kToken;
|
|
cdm_license.PrepareKeyRequest(
|
|
*init_data, client_token,
|
|
license_type /*kLicenseTypeStreaming*/, param,
|
|
(fdp_.ConsumeBool() ? &signed_request : nullptr),
|
|
(fdp_.ConsumeBool() ? &server_url : nullptr));
|
|
},
|
|
[&]() {
|
|
std::string signed_service_certificate =
|
|
fdp_.ConsumeRandomLengthString(kMaxByte);
|
|
cdm_license.SetServiceCertificate(signed_service_certificate);
|
|
},
|
|
[&]() {
|
|
std::string server_url;
|
|
CdmAppParameterMap param;
|
|
int32_t max_size =
|
|
fdp_.ConsumeIntegralInRange<int32_t>(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;
|
|
}
|
|
cdm_license.PrepareKeyUpdateRequest(
|
|
fdp_.ConsumeBool(), param, cdm_session.get(),
|
|
(fdp_.ConsumeBool() ? &signed_request : nullptr),
|
|
(fdp_.ConsumeBool() ? &server_url : nullptr));
|
|
},
|
|
[&]() {
|
|
cdm_license.HandleKeyResponse(fdp_.ConsumeBool(), response);
|
|
},
|
|
[&]() {
|
|
cdm_license.HandleKeyUpdateResponse(
|
|
fdp_.ConsumeBool() /*is_renewal*/,
|
|
fdp_.ConsumeBool() /*is_restore*/, response);
|
|
},
|
|
[&]() { cdm_license.HandleEmbeddedKeyData(*init_data); },
|
|
[&]() {
|
|
CdmKeyResponse renew_response;
|
|
CreateResponse(&renew_response);
|
|
std::string client_token =
|
|
fdp_.ConsumeBool()
|
|
? fdp_.ConsumeRandomLengthString(kMaxByte)
|
|
: kToken;
|
|
cdm_license.RestoreOfflineLicense(
|
|
client_token, signed_request, response, renew_response,
|
|
fdp_.ConsumeIntegral<int64_t>() /*playback_start_time*/,
|
|
fdp_.ConsumeIntegral<int64_t>() /*last_playback_time*/,
|
|
fdp_.ConsumeIntegral<int64_t>() /*grace_period_end_time*/,
|
|
cdm_session.get());
|
|
},
|
|
[&]() {
|
|
std::string client_token =
|
|
fdp_.ConsumeBool()
|
|
? fdp_.ConsumeRandomLengthString(kMaxByte)
|
|
: kToken;
|
|
cdm_license.RestoreLicenseForRelease(client_token,
|
|
signed_request, response);
|
|
},
|
|
[&]() {
|
|
KeyId key_id = fdp_.ConsumeRandomLengthString(kMaxByte);
|
|
cdm_license.IsKeyLoaded(key_id);
|
|
},
|
|
[&]() {
|
|
std::string session_token;
|
|
cdm_license.ExtractProviderSessionToken(response,
|
|
&session_token);
|
|
},
|
|
});
|
|
invoke_license_API();
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
|
|
CdmLicenseFuzzer cdm_license_fuzzer(data, size);
|
|
cdm_license_fuzzer.Process();
|
|
return 0;
|
|
}
|