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

Group license support

Browse Source
This commit is contained in:
Lu Chen
2021-03-05 16:09:59 -08:00
parent 00785b2ccd
commit 5c81c1aa9e
30 changed files with 1236 additions and 585 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
plugin/src/crypto_session.cpp
View File

@@ -265,13 +265,6 @@ OEMCryptoResult CryptoInterface::OEMCrypto_DeriveKeysFromSessionKey(
});
}
OEMCryptoResult CryptoInterface::OEMCrypto_LoadKeys(
const LoadKeysParams& load_key_params) {
return lock_->WithOecSessionLock("LoadKeys", [&] {
return oemcrypto_interface_->OEMCrypto_LoadKeys(load_key_params);
});
}
OEMCryptoResult CryptoInterface::OEMCrypto_LoadLicense(
OEMCrypto_SESSION session, const uint8_t* message, size_t message_length,
size_t core_message_length, const uint8_t* signature,
@@ -320,17 +313,6 @@ OEMCryptoResult CryptoInterface::OEMCrypto_GetHDCPCapability(
});
}
OEMCryptoResult CryptoInterface::OEMCrypto_RefreshKeys(
OEMCrypto_SESSION session, const uint8_t* message, size_t message_length,
const uint8_t* signature, size_t signature_length, size_t num_keys,
const OEMCrypto_KeyRefreshObject* key_array) {
return lock_->WithOecSessionLock("RefreshKeys", [&] {
return oemcrypto_interface_->OEMCrypto_RefreshKeys(
session, message, message_length, signature, signature_length, num_keys,
key_array);
});
}
OEMCryptoResult CryptoInterface::OEMCrypto_GetDeviceID(uint8_t* deviceID,
size_t* idLength) {
return lock_->WithOecReadLock("GetDeviceID", [&] {
@@ -828,64 +810,6 @@ CasStatus CryptoSession::DeriveKeysFromSessionKey(
return CasStatus::OkStatus();
}
CasStatus CryptoSession::LoadKeys(const std::string& message,
const std::string& signature,
const std::string& mac_key_iv,
const std::string& mac_key,
const std::vector<CryptoKey>& key_array,
const std::string& pst,
const std::string& srm_requirement) {
if (key_array.empty()) {
return CasStatus::OkStatus();
}
LoadKeysParams load_key_params;
load_key_params.session = session_;
load_key_params.message = reinterpret_cast<const uint8_t*>(message.data());
load_key_params.message_length = message.size();
load_key_params.signature =
reinterpret_cast<const uint8_t*>(signature.data());
load_key_params.signature_length = signature.size();
load_key_params.enc_mac_keys_iv.offset = GetOffset(message, mac_key_iv);
load_key_params.enc_mac_keys_iv.length = mac_key_iv.size();
load_key_params.enc_mac_keys.offset = GetOffset(message, mac_key);
load_key_params.enc_mac_keys.length = mac_key.size();
load_key_params.pst.offset = GetOffset(message, pst);
load_key_params.pst.length = pst.size();
load_key_params.srm_requirement.offset = GetOffset(message, srm_requirement);
load_key_params.srm_requirement.length = srm_requirement.size();
std::vector<OEMCrypto_KeyObject> key_objects;
key_objects.reserve(key_array.size());
for (const auto& ki : key_array) {
key_objects.resize(key_objects.size() + 1);
OEMCrypto_KeyObject& ko = key_objects.back();
ko.key_id.offset = GetOffset(message, ki.key_id());
ko.key_id.length = ki.key_id().length();
ko.key_data_iv.offset = GetOffset(message, ki.key_data_iv());
ko.key_data_iv.length = ki.key_data_iv().length();
ko.key_data.offset = GetOffset(message, ki.key_data());
ko.key_data.length = ki.key_data().length();
if (ki.HasKeyControl()) {
ko.key_control_iv.offset = GetOffset(message, ki.key_control_iv());
ko.key_control_iv.length = ki.key_control_iv().length();
ko.key_control.offset = GetOffset(message, ki.key_control());
ko.key_control.length = ki.key_control().length();
}
}
load_key_params.key_array = &key_objects[0];
load_key_params.num_keys = key_objects.size();
load_key_params.license_type = OEMCrypto_EntitlementLicense;
OEMCryptoResult result =
crypto_interface_->OEMCrypto_LoadKeys(load_key_params);
if (result != OEMCrypto_SUCCESS) {
std::ostringstream err_string;
err_string << "OEMCrypto_LoadKeys returned " << result;
return CasStatus(CasStatusCode::kCryptoSessionError, err_string.str());
}
return CasStatus::OkStatus();
}
CasStatus CryptoSession::LoadLicense(const std::string& signed_message,
const std::string& core_message,
const std::string& signature) {
@@ -1040,42 +964,6 @@ OEMCryptoResult CryptoSession::getCryptoInterface(
return CryptoInterface::create(interface);
}
CasStatus CryptoSession::RefreshKeys(const std::string& message,
const std::string& signature,
const std::vector<CryptoKey>& key_array) {
if (key_array.empty()) {
return CasStatus::OkStatus();
}
// Assume the message and signature parameters are valid.
const uint8_t* message_ptr = reinterpret_cast<const uint8_t*>(message.data());
const uint8_t* signature_ptr =
reinterpret_cast<const uint8_t*>(signature.data());
std::vector<OEMCrypto_KeyRefreshObject> load_key_array;
load_key_array.reserve(key_array.size());
for (const auto& key : key_array) {
load_key_array.emplace_back();
auto& key_object = load_key_array.back();
key_object.key_id.offset = GetOffset(message, key.key_id());
key_object.key_id.length = key.key_id().length();
if (!key.key_control().empty()) {
key_object.key_control_iv.offset =
GetOffset(message, key.key_control_iv());
key_object.key_control_iv.length = key.key_control_iv().length();
key_object.key_control.offset = GetOffset(message, key.key_control());
key_object.key_control.length = key.key_control().length();
}
}
OEMCryptoResult result = crypto_interface_->OEMCrypto_RefreshKeys(
session_, message_ptr, message.size(), signature_ptr, signature.size(),
load_key_array.size(), &load_key_array[0]);
if (result != OEMCrypto_SUCCESS) {
std::ostringstream err_string;
err_string << "OEMCrypto_RefreshKeys returned " << result;
return CasStatus(CasStatusCode::kCryptoSessionError, err_string.str());
}
return CasStatus::OkStatus();
}
CasStatus CryptoSession::GetDeviceID(std::string* buffer) {
if (!crypto_interface_) {
return CasStatus(CasStatusCode::kCryptoSessionError,