95 lines
3.8 KiB
C++
95 lines
3.8 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
// Copyright 2019 Google LLC.
|
|
//
|
|
// This software is licensed under the terms defined in the Widevine Master
|
|
// License Agreement. For a copy of this agreement, please contact
|
|
// widevine-licensing@google.com.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "common/core_message_util.h"
|
|
|
|
#include "common/oemcrypto_core_message/odk/include/core_message_deserialize.h"
|
|
#include "common/oemcrypto_core_message/odk/include/core_message_serialize.h"
|
|
#include "common/oemcrypto_core_message/odk/include/core_message_serialize_proto.h"
|
|
#include "common/sha_util.h"
|
|
|
|
using oemcrypto_core_message::deserialize::CoreCommonRequestFromMessage;
|
|
using oemcrypto_core_message::deserialize::CoreLicenseRequestFromMessage;
|
|
using oemcrypto_core_message::deserialize::CoreProvisioningRequestFromMessage;
|
|
using oemcrypto_core_message::deserialize::CoreRenewalRequestFromMessage;
|
|
using oemcrypto_core_message::serialize::CreateCoreLicenseResponseFromProto;
|
|
using oemcrypto_core_message::serialize::
|
|
CreateCoreProvisioningResponseFromProto;
|
|
using oemcrypto_core_message::serialize::CreateCoreRenewalResponse;
|
|
using widevine::Sha256_Hash;
|
|
|
|
namespace widevine {
|
|
namespace core_message_util {
|
|
bool GetCoreProvisioningResponse(
|
|
const std::string& serialized_provisioning_response,
|
|
const std::string& request_core_message,
|
|
std::string* response_core_message) {
|
|
if (request_core_message.empty()) {
|
|
return false;
|
|
}
|
|
oemcrypto_core_message::ODK_ProvisioningRequest odk_provisioning_request;
|
|
if (CoreProvisioningRequestFromMessage(request_core_message,
|
|
&odk_provisioning_request)) {
|
|
return CreateCoreProvisioningResponseFromProto(
|
|
serialized_provisioning_response, odk_provisioning_request,
|
|
response_core_message);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool GetCoreRenewalOrReleaseLicenseResponse(
|
|
uint64_t renewal_duration_seconds, const std::string& request_core_message,
|
|
std::string* response_core_message) {
|
|
if (request_core_message.empty()) {
|
|
return false;
|
|
}
|
|
oemcrypto_core_message::ODK_RenewalRequest odk_renewal_request;
|
|
if (!CoreRenewalRequestFromMessage(request_core_message,
|
|
&odk_renewal_request)) {
|
|
return false;
|
|
}
|
|
return CreateCoreRenewalResponse(
|
|
odk_renewal_request, renewal_duration_seconds, response_core_message);
|
|
}
|
|
|
|
bool GetCoreNewLicenseResponse(const std::string& license,
|
|
const std::string& request_core_message,
|
|
const bool nonce_required,
|
|
std::string* response_core_message) {
|
|
if (request_core_message.empty()) {
|
|
return false;
|
|
}
|
|
oemcrypto_core_message::ODK_LicenseRequest odk_license_request;
|
|
if (!CoreLicenseRequestFromMessage(request_core_message,
|
|
&odk_license_request)) {
|
|
return false;
|
|
}
|
|
std::string core_request_sha256 = Sha256_Hash(request_core_message);
|
|
return CreateCoreLicenseResponseFromProto(license, odk_license_request,
|
|
core_request_sha256, nonce_required,
|
|
response_core_message);
|
|
}
|
|
|
|
bool GetCoreVersion(const std::string& request_core_message,
|
|
uint16_t* odk_major_version, uint16_t* odk_minor_version) {
|
|
if (odk_major_version == nullptr || odk_minor_version == nullptr) {
|
|
return false;
|
|
}
|
|
oemcrypto_core_message::ODK_CommonRequest odk_common_request;
|
|
if (!CoreCommonRequestFromMessage(request_core_message,
|
|
&odk_common_request)) {
|
|
return false;
|
|
}
|
|
*odk_major_version = odk_common_request.api_major_version;
|
|
*odk_minor_version = odk_common_request.api_minor_version;
|
|
return true;
|
|
}
|
|
|
|
} // namespace core_message_util
|
|
} // namespace widevine
|