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

Move testing file which contains keysmith response to export/sdk/testing.

Browse Source 
-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=221487408
This commit is contained in:
Widevine Buildbot
2018-11-14 22:21:12 +00:00
committed by Fang Yu
parent 6b4de78ce3
commit 57385ffb5e
9 changed files with 1620 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
sdk/external/common/wvpl/wvpl_sdk_environment.h vendored Normal file
View File

@@ -0,0 +1,132 @@
////////////////////////////////////////////////////////////////////////////////
// Copyright 2017 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.
////////////////////////////////////////////////////////////////////////////////
#ifndef SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_ENVIRONMENT_H_
#define SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_ENVIRONMENT_H_
#include <string>
#include "common/certificate_type.h"
#include "sdk/external/common/wvpl/wvpl_types.h"
#include "protos/public/device_certificate_status.pb.h"
#include "protos/public/provisioned_device_info.pb.h"
namespace widevine_server {
namespace wv_pl_sdk {
// These fields show the configuration options that can be initialized via
// the implementation classes (WvPLEnvironment and WvPLProxyEnvironment).
const char kDeviceCertificateExpiration[] = "device_certificate_expiration";
const char kAllowUnknownDevice[] = "allow_unknown_device";
const char kProvider[] = "provider";
const char kProviderIv[] = "provider_iv";
const char kProviderKey[] = "provider_key";
const char kApiVerInKcb[] = "api_ver_in_kcb";
const char kLimitUsageStatsToErrorsOnly[] = "limit_usage_stats_to_errors_only";
// Valid values are 'test' and 'prod'.
const char kDrmCertificateType[] = "drm_certificate_type";
/**
* Parent class of SDK environment. This class is not be instantiated directly,
* but its API can be accessed via the derived environment classes.
*/
class WvPLSDKEnvironment {
public:
virtual ~WvPLSDKEnvironment() {}
static void SetConfigValue(const std::map<std::string, std::string>& config_values);
// Generates a license response containing a message generated in response to
// an error condition. |create_session_status| is a previous error status
// returned by the CreateSession(). |license_response| points to a std::string to
// contain the license response and may not be NULL. This method returns true
// if there is an error license to be sent to the client, or false
// otherwise.
static bool GenerateErrorResponse(const WvPLStatus& create_session_status,
std::string* license_response);
/**
* Add a service certificate system-wide at the sdk. |service_certificate|
* is a Google-generated certificate used to authenticate the service
* provider. |service_private_key| is the encrypted PKCS#8 private RSA key
* corresponding to the service certificate. |service_private_key_passphrase|
* is the password required to decrypt |service_private_key|. This is a
* thread-safe call.
*
* @param service_certificate
* @param service_private_key
* @param service_private_key_passphrase
*
* @return WvPLStatus enumeration
*/
virtual WvPLStatus SetDrmServiceCertificate(
const std::string& service_certificate, const std::string& service_private_key,
const std::string& service_private_key_passphrase);
// Returns the DRM Root Certificate type. This would be a setting passed into
// the environment, by a derived class constructor.
virtual std::string GetDrmCertificateType() { return drm_certificate_type_; }
protected:
// Return the signature for the provider specified in the |config_values|
// parameter in the constructor. |signature| is owned by the caller.
static WvPLStatus GenerateSignature(const std::string& plain_text,
std::string* signature);
/**
* Insert or update provisionedDeviceInfoMap with device info in
* certificate_status_list.
*/
static WvPLStatus UpdateProvisionedDeviceInfoMap(
const widevine::DeviceCertificateStatusList&
certificate_status_list);
// Number of seconds until the certificate status list expires after its
// creation time. Default value is 604800 seconds.
uint32_t device_certificate_expiration_seconds_ = 604800;
// "config_values" setting for "kDrmCertificateType".
// Supported values are "test" and "prod". Default value is "prod".
std::string drm_certificate_type_ = "prod";
// name of the provider hosting this service.
std::string provider_;
// value of the "iv" specified for the provider.
std::string* provider_iv_;
// value of the "key" specified for the provider.
std::string* provider_key_;
static std::map<std::string, std::string>* config_values_;
// is_service_certificate_loaded_ is not thread safe.
bool is_service_certificate_loaded_ = false;
// If true, allow devices not in the certificate status list.
bool allow_unknown_device_ = false;
// DRM Certificate type.
widevine::CertificateType certificate_type_ =
widevine::kCertificateTypeProduction;
private:
/**
* Return provisioned_device_info if the device_info_map_ contains system_id.
*
* @return WvPLStatus - Status::OK if success, else error.
*/
static WvPLStatus LookupDeviceInfo(
uint32_t system_id,
widevine::ProvisionedDeviceInfo* provisioned_device_info);
/**
* Add a device to the current environment/session.
*/
static void AddDeviceInfo(
const widevine::ProvisionedDeviceInfo& provisioned_device_info);
static std::map<std::string, std::string>* GetConfigValue();
friend class WvPLSDKSession;
friend class WvPLProxySessionTest;
friend class WvPLSessionTest;
};
} // namespace wv_pl_sdk
} // namespace widevine_server
#endif // SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_ENVIRONMENT_H_

198
sdk/external/common/wvpl/wvpl_sdk_session.h vendored Normal file
View File

@@ -0,0 +1,198 @@
////////////////////////////////////////////////////////////////////////////////
// Copyright 2018 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.
////////////////////////////////////////////////////////////////////////////////
#ifndef SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_SESSION_H_
#define SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_SESSION_H_
#include "sdk/external/common/wvpl/wvpl_types.h"
#include "protos/public/client_identification.pb.h"
#include "protos/public/device_certificate_status.pb.h"
#include "protos/public/license_protocol.pb.h"
#include "protos/public/license_server_sdk.pb.h"
#include "protos/public/provisioned_device_info.pb.h"
namespace widevine {
class SessionInit;
}
namespace widevine_server {
namespace wv_pl_sdk {
class WvPLSDKSession {
public:
virtual ~WvPLSDKSession() = 0;
public:
// Add WvPLKey.
virtual WvPLStatus AddKey(const WvPLKey& key);
// Get the WvPLKey.
virtual const std::vector<WvPLKey>& key() const { return keys_; }
// Set the license policy.
virtual void set_policy(const WvPLPlaybackPolicy& policy) {
policy_ = policy;
}
// Get the license policy.
virtual const WvPLPlaybackPolicy& policy() const { return policy_; }
// Set the Session Init.
virtual void set_session_init(const WvPLSessionInit& session_init) {
session_init_ = session_init;
}
// Get the Session Init.
virtual const WvPLSessionInit& session_init() const { return session_init_; }
virtual bool IsChromeCDM() const;
/**
* Returns the Widevine PSSH data for the license request handled by this
* session.
*
* @param wvpl_widevine_pssh_data.
* @return WvPLStatus - Status::OK if success, else error.
*/
virtual WvPLStatus GetPsshData(
WvPLWidevinePsshData* wvpl_widevine_pssh_data) const;
/**
* Returns the ClientIdentification information for the license request
* handled by this session.
*
* @param client_info
* @return WvPLStatus - Status::OK if success, else error.
*/
virtual WvPLStatus GetClientInfo(WvPLClientInfo* client_info) const;
/**
* Returns the WvPL Client Capabilities information for the license request
* handled by this session.
*
* @param client_capabilities.
* @return WvPLStatus - Status::OK if success, else error.
*/
virtual WvPLStatus GetClientCapabilities(
WvPLClientCapabilities* client_capabilities) const;
/**
* Returns the WvPLDeviceInfo information for the license request
* handled by this session.
*
* @param device_info
* @return WvPLStatus - Status::OK if success, else error.
*/
virtual WvPLStatus GetDeviceInfo(WvPLDeviceInfo* device_info) const;
/**
* Returns the type of the message handled by this session.
*
* @return MessageType enumeration.
*/
virtual MessageType message_type() const;
virtual PlatformVerificationStatus VerifyPlatform() = 0;
virtual widevine::LicenseRequest::RequestType request_type() const {
return request_type_;
}
protected:
uint32_t system_id_ = 0xFFFFFFFF;
std::string user_agent_;
std::vector<WvPLKey> keys_;
WvPLPlaybackPolicy policy_;
WvPLSessionInit session_init_;
WvPLWidevinePsshData pssh_data_;
widevine::ClientIdentification client_id_;
bool has_pssh_data_ = false;
bool has_system_id_ = false;
bool has_client_id_ = false;
MessageType message_type_ = UNKNOWN;
PlatformVerificationStatus platform_verification_status_ =
PLATFORM_NO_VERIFICATION;
std::unique_ptr<widevine::SignedMessage>
signed_message_request_from_cdm_;
std::string license_request_from_cdm_;
std::string remote_attestation_cert_serial_number_;
std::unique_ptr<widevine::LicenseRequest> sdk_license_request_;
widevine::LicenseRequest::RequestType request_type_;
virtual WvPLStatus VerifyRemoteAttestation();
// Returns the WvPL Client Capabilities information for the license request
// handled by this session.
WvPLStatus GetWvPLClientCapabilities(
const widevine::ClientIdentification& client_id,
WvPLClientCapabilities* client_capabilities) const;
// Copies/translates the output protection from a WvPL Key into an SDK
// key container.
void CopyOutputProtection(
const WvPLKey& wvpl_key,
widevine::License_KeyContainer* sdk_key_container);
virtual void CopySecurityLevel(
const WvPLOutputProtection& output_protection, TrackType track_type,
widevine::License::KeyContainer* key_container);
// Copies/translates the policy from a WvPL policy into an SDK policy. A
// helper function for GenerateLicenseRequestAsJSON.
virtual void CopyPlaybackPolicy(const WvPLPlaybackPolicy& wvpl_policy,
widevine::License::Policy* sdk_policy);
// Copy the |cgms_value| into the key container. A helper function for
// GenerateLicenseRequestAsJSON.
virtual void CopyCGMS(CGMS cgms_value,
widevine::License::KeyContainer::OutputProtection*
output_protection);
// Copy the |hdcp_value| into the key container.
virtual void CopyHDCP(HDCP hdcp_value,
widevine::License::KeyContainer::OutputProtection*
output_protection);
// Copy the |hdcp_value| into the client_capabilities.
virtual void CopyHDCPToClientCapabilities(
widevine::ClientIdentification::ClientCapabilities::HdcpVersion
hdcp_value,
WvPLClientCapabilities* client_capabilities) const;
// Copy the |analog_output_capabilities| into the client_capabilities.
virtual void CopyAnalogOutputCapabilities(
widevine::ClientIdentification::ClientCapabilities::
AnalogOutputCapabilities analog_output_capabilities,
WvPLClientCapabilities* client_capabilities) const;
// Copy the WvPLSession Init into Session Init.
virtual void CopySessionInit(const WvPLSessionInit& wvpl_session_init,
widevine::SessionInit* session_init);
// Copy the WvPLDeviceInfo into ProvisionedDeviceInfo.
virtual void CopyProvisionedDeviceInfo(
const WvPLDeviceInfo& wvpl_device_info,
widevine::ProvisionedDeviceInfo* device_info);
// Populate deviceInfo, clientIdentification and psshdata for license request.
WvPLStatus ParseLicenseRequest();
// Copy the WvPLSessionState to SessionState.
void CopySessionState(const WvPLSessionState& wvpl_session_state,
widevine::SessionState* session_state);
private:
/**
* Parses WvPLWidevinePsshData in the new license request.
*
* @return WvPLStatus - Status::OK if success, else error.
*/
virtual WvPLStatus ParsePsshData(
WvPLWidevinePsshData* wvpl_widevine_pssh_data) const = 0;
};
} // namespace wv_pl_sdk
} // namespace widevine_server
#endif // SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_SESSION_H_

931
sdk/external/common/wvpl/wvpl_types.h vendored Normal file
View File

@@ -0,0 +1,931 @@
////////////////////////////////////////////////////////////////////////////////
// Copyright 2017 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.
////////////////////////////////////////////////////////////////////////////////
#ifndef SDK_EXTERNAL_COMMON_WVPL_WVPL_TYPES_H_
#define SDK_EXTERNAL_COMMON_WVPL_WVPL_TYPES_H_
#include <stdint.h>
#include <list>
#include <map>
#include <memory>
#include <vector>
#include "util/status.h"
// TODO(user) Split wvpl_types.h into wvpl_common_types.h ,
// wvpl_license_sdk_types.h, wvpl_proxy_sdk_types.h and
// wvpl_packager_sdk_types.h.
namespace widevine_server {
namespace wv_pl_sdk {
typedef widevine::util::Status WvPLStatus;
typedef uint32_t uint32_t;
typedef int64_t int64_t;
/**
* Represents the key type for the keys that are used when generating a license.
* The generated license includes a key container, which in turn, contains the
* key material, metadata and policy needed to use the key.
*/
enum KeyType {
UNKNOWN_KEY = 0,
// Key used to decrypt media content.
CONTENT = 1,
// Key used for wrapping content keys.
ENTITLEMENT = 2
};
enum LicenseType {
STREAMING = 1,
OFFLINE = 2,
};
/**
* Represents the type of message. This struct is used by Proxy SDK.
*/
enum MessageType {
UNKNOWN = 0,
LICENSE_REQUEST = 1,
SERVICE_CERTIFICATE_REQUEST = 4
};
enum CertificateKeyType {
RSA_2048 = 0,
RSA_3072 = 1,
};
enum PlatformVerificationStatus {
PLATFORM_UNVERIFIED = 0,
PLATFORM_TAMPERED = 1,
PLATFORM_SOFTWARE_VERIFIED = 2,
PLATFORM_HARDWARE_VERIFIED = 3,
PLATFORM_NO_VERIFICATION = 4,
PLATFORM_SECURE_STORAGE_SOFTWARE_VERIFIED = 5
};
// LINT.IfChange
enum HDCP {
HDCP_NONE = 0,
HDCP_V1 = 1,
HDCP_V2 = 2,
HDCP_V2_1 = 3,
HDCP_V2_2 = 4,
HDCP_V2_3 = 5,
HDCP_NO_DIGITAL_OUTPUT = 0xff
};
enum SecurityLevel {
SECURITY_LEVEL_UNDEFINED = 0,
SW_SECURE_CRYPTO = 1,
SW_SECURE_DECODE = 2,
HW_SECURE_CRYPTO = 3,
HW_SECURE_DECODE = 4,
HW_SECURE_ALL = 5
};
enum DeviceSecurityLevel {
DEVICE_LEVEL_UNSPECIFIED = 0,
DEVICE_LEVEL_1 = 1,
DEVICE_LEVEL_2 = 2,
DEVICE_LEVEL_3 = 3
};
enum CGMS {
CGMS_NONE = 42,
COPY_FREE = 0,
COPY_ONCE = 2,
COPY_NEVER = 3,
};
enum TrackType {
TRACK_TYPE_UNSPECIFIED = 0,
AUDIO = 1,
VIDEO_SD = 2,
VIDEO_HD = 3,
VIDEO_UHD1 = 4,
VIDEO_UHD2 = 5,
};
enum AnalogOutputCapabilities {
ANALOG_OUTPUT_UNKNOWN = 0,
ANALOG_OUTPUT_NONE = 1,
ANALOG_OUTPUT_SUPPORTED = 2,
ANALOG_OUTPUT_SUPPORTS_CGMS_A = 3,
};
struct WvPLPlaybackPolicy {
WvPLPlaybackPolicy() {
license_duration_seconds_ = 0;
playback_duration_seconds_ = 0;
renewal_interval_seconds_ = 0;
renewal_recovery_duration_seconds_ = 0;
renewal_retry_interval_seconds_ = 0;
can_play_ = true;
can_renew_ = false;
can_persist_ = false;
}
void set_license_duration_seconds(uint32_t duration) {
license_duration_seconds_ = duration;
}
uint32_t license_duration_seconds() const { return license_duration_seconds_; }
void set_playback_duration_seconds(uint32_t duration) {
playback_duration_seconds_ = duration;
}
uint32_t playback_duration_seconds() const {
return playback_duration_seconds_;
}
void set_renewal_interval_seconds(uint32_t duration) {
renewal_interval_seconds_ = duration;
}
uint32_t renewal_interval_seconds() const { return renewal_interval_seconds_; }
void set_renewal_recovery_duration_seconds(int64_t dur) {
renewal_recovery_duration_seconds_ = dur;
}
int64_t renewal_recovery_duration_seconds() const {
return renewal_recovery_duration_seconds_;
}
void set_renewal_retry_interval_seconds(int64_t retry_interval) {
renewal_retry_interval_seconds_ = retry_interval;
}
int64_t renewal_retry_interval_seconds() const {
return renewal_retry_interval_seconds_;
}
void set_renew_with_usage(bool usage_flag) { renew_with_usage_ = usage_flag; }
bool renew_with_usage() const { return renew_with_usage_; }
void set_renewal_url(const std::string& url) { renewal_url_ = url; }
const std::string& renewal_url() const { return renewal_url_; }
void set_can_play(bool play_flag) { can_play_ = play_flag; }
bool can_play() const { return can_play_; }
void set_can_persist(bool persist_flag) { can_persist_ = persist_flag; }
bool can_persist() const { return can_persist_; }
void set_can_renew(bool renew_flag) { can_renew_ = renew_flag; }
bool can_renew() const { return can_renew_; }
// The license window. Once a license is granted, the number of seconds to use
// this license. Default is 0, indicating unlimited license.
uint32_t license_duration_seconds_;
// The playback window. Once initial playback starts, the number of seconds
// to use the license. Default is 0, indicating unlimited but not to exceed
// the license_duration_window.
uint32_t playback_duration_seconds_;
// How many seconds after license_start_time, before renewal is first
// attempted.
uint32_t renewal_interval_seconds_;
// The window of time, in which playback is allowed to continue while
// renewal is attempted, yet unsuccessful due to backend problems with
// the license server.
int64_t renewal_recovery_duration_seconds_;
// Specifies the delay in seconds between subsequent license
// renewal requests, in case of failure.
int64_t renewal_retry_interval_seconds_;
// Indicates that the license shall be sent for renewal when usage is
// started.
bool renew_with_usage_;
// Renewal requests are sent to this URL.
std::string renewal_url_;
// Indicates that playback of ths content is allowed.
bool can_play_;
// Indicates that the license may be persisted to non-volatile storage for
// offline use.
bool can_persist_;
// Indicates that renewal of this license is allowed.
bool can_renew_;
};
/**
* LicenseIdentification is propagated from LicenseRequest to License,
* incrementing version with each iteration.
* */
struct LicenseIdentification {
LicenseIdentification() {
version_ = 0;
type_ = STREAMING;
}
// |request_id| must be specified in bytes.
void set_request_id(const std::string& request_id) {
request_id_ = request_id;
}
const std::string& request_id() { return request_id_; }
// |session_id| must be specified in bytes.
void set_session_id(const std::string& session_id) {
session_id_ = session_id;
}
const std::string& session_id() { return session_id_; }
// |purchase_id| must be specified in bytes.
void set_purchase_id(const std::string& purchase_id) {
purchase_id_ = purchase_id;
}
const std::string& purchase_id() { return purchase_id_; }
void set_type(LicenseType type) { type_ = type; }
LicenseType type() { return type_; }
uint32_t version() { return version_; }
void set_version(uint32_t version) { version_ = version; }
// |provider_session_token| must be specified in bytes.
void set_provider_session_token(const std::string& provider_session_token) {
provider_session_token_ = provider_session_token;
}
const std::string& provider_session_token() {
return provider_session_token_;
}
// License request id.
std::string request_id_; // NOLINT
// Session identifier for license request.
std::string session_id_; // NOLINT
// Session token for the session. This token is for use by the license
// provider, and is akin to a session cookie. It will be copied to
// LicenseIdentfication::provider_session_token, and sent back in all
std::string provider_session_token_; // NOLINT
// Purchase identifier.
std::string purchase_id_; // NOLINT
// Type of the license, default value is Streaming.
LicenseType type_; // NOLINT
// Version of license request.
uint32_t version_; // NOLINT
};
/**
* This message is used by the server to preserve and restore session state.
* */
struct WvPLSessionState {
WvPLSessionState() {
keybox_system_id_ = 0;
license_counter_ = 0;
}
void set_license_id(const LicenseIdentification& license_id) {
license_id_ = license_id;
}
const LicenseIdentification& license_id() const { return license_id_; }
LicenseIdentification* mutable_license_id() { return &license_id_; }
const std::string& signing_key() const { return signing_key_; }
// |signing_key| must be specified in bytes.
void set_signing_key(const std::string& signing_key) {
signing_key_ = signing_key;
}
uint32_t keybox_system_id() const { return keybox_system_id_; }
void set_keybox_system_id(uint32_t keybox_system_id) {
keybox_system_id_ = keybox_system_id;
}
uint32_t license_counter() const { return license_counter_; }
void set_license_counter(uint32_t license_counter) {
license_counter_ = license_counter;
}
const std::string& provider_client_token() const {
return provider_client_token_;
}
// |provider_client_token| must be specified in bytes.
void set_provider_client_token(const std::string& provider_client_token) {
provider_client_token_ = provider_client_token;
}
// License information propagated from license request to the license.
LicenseIdentification license_id_; // NOLINT
// Provider client token sent back in the license.
std::string provider_client_token_; // NOLINT
// Signing_key should be 512 bits in length to be split into two
// (server || client) HMAC-SHA256 keys.
std::string signing_key_; // NOLINT
// System_id in keybox.
uint32_t keybox_system_id_; // NOLINT
// License counter associated with the |provider_client_token|.
uint32_t license_counter_; // NOLINT
};
struct WvPLVideoResolutionConstraint {
WvPLVideoResolutionConstraint() {
min_resolution_pixels_ = 0;
max_resolution_pixels_ = 0;
hdcp_ = HDCP_NONE;
}
void set_min_resolution_pixels(uint32_t pixels) {
min_resolution_pixels_ = pixels;
}
void set_max_resolution_pixels(uint32_t pixels) {
max_resolution_pixels_ = pixels;
}
void set_hdcp(HDCP hdcp_value) { hdcp_ = hdcp_value; }
HDCP hdcp() const { return hdcp_; }
uint32_t min_resolution_pixels() const { return min_resolution_pixels_; }
uint32_t max_resolution_pixels() const { return max_resolution_pixels_; }
// Minimum and maximum video resolutions in the range (height x width).
uint32_t min_resolution_pixels_;
uint32_t max_resolution_pixels_;
// Optional output protection requirements for this range. If not
// specified, the output protection in WvPLKey applies.
HDCP hdcp_;
};
struct WvPLOutputProtection {
WvPLOutputProtection() {
hdcp_ = HDCP_NONE;
secure_data_path_ = false;
security_level_ = SECURITY_LEVEL_UNDEFINED;
disable_analog_output_ = false;
disable_digital_output_ = false;
cgms_ = CGMS_NONE;
}
void set_hdcp(HDCP hdcp_value) { hdcp_ = hdcp_value; }
HDCP hdcp() const { return hdcp_; }
// Setting true indicates security_level is HW_SECURE_ALL, otherwise the
// default is false which maps to security_level of SW_SECURE_CRYPTO. This
// value is ignored if security_level is set directly.
void set_secure_data_path(bool secure_flag) {
secure_data_path_ = secure_flag;
}
bool secure_data_path() const { return secure_data_path_; }
// Setting security_level directly takes precedence over setting the
// |secure_data_path|. For most applications, there is no need to set the
// security_level directly. Using |secure_data_path| is sufficient.
void set_security_level(SecurityLevel level) { security_level_ = level; }
SecurityLevel security_level() const { return security_level_; }
// Set to true to disable analog output.
void set_disable_analog_output(bool flag) { disable_analog_output_ = flag; }
bool disable_analog_output() const { return disable_analog_output_; }
// Set to true to disable digital output.
void set_disable_digital_output(bool flag) { disable_digital_output_ = flag; }
bool disable_digital_output() const { return disable_digital_output_; }
// CGMS-A setting
void set_cgms(CGMS cgms_value) { cgms_ = cgms_value; }
CGMS cgms() const { return cgms_; }
// Indicates whether HDCP is required on digital outputs. Default is None.
HDCP hdcp_;
// Crypto operations and handling of the media must be performed within a
// hardware backed trusted environment. Default is false.
bool secure_data_path_;
// Security level robustness defined by Widevine. Default is UNDEFINED in
// which case secure_data_path_ is used. If secure_data_path_ is false,
// security_level_ is set to SW_SECURE_CRYPTO. If secure_data_path_ is
// true, security_level_ is set to HW_SECURE_ALL;
SecurityLevel security_level_;
// Set to disable analog output.
bool disable_analog_output_;
// Set to disable digital output.
bool disable_digital_output_;
// CGMS-A analog output.
CGMS cgms_;
};
struct WvPLKey {
WvPLKey() {}
// |key_id| must be specified in bytes.
void set_key_id(const std::string& key_id) { key_id_ = key_id; }
const std::string& key_id() const { return key_id_; }
// |key_bytes| must be specified in bytes.
void set_key_bytes(const std::string& key_bytes) { key_bytes_ = key_bytes; }
const std::string& key_bytes() const { return key_bytes_; }
void set_output_protection(const WvPLOutputProtection& out_prot) {
output_protection_ = out_prot;
}
void set_requested_output_protection(const WvPLOutputProtection& out_prot) {
requested_output_protection_ = out_prot;
}
const WvPLOutputProtection& output_protection() const {
return output_protection_;
}
const WvPLOutputProtection& requested_output_protection() const {
return requested_output_protection_;
}
WvPLOutputProtection* mutable_output_protection() {
return &output_protection_;
}
WvPLOutputProtection* mutable_requested_output_protection() {
return &requested_output_protection_;
}
const std::vector<WvPLVideoResolutionConstraint>
video_resolution_constraints() const {
return video_resolution_constraints_;
}
void AddVideoResolutionConstraint(
const WvPLVideoResolutionConstraint& constraint) {
video_resolution_constraints_.push_back(constraint);
}
void set_track_type(const TrackType track_type) { track_type_ = track_type; }
TrackType track_type() const { return track_type_; }
void set_key_type(const KeyType key_type) { key_type_ = key_type; }
KeyType key_type() const { return key_type_; }
std::string key_id_;
std::string key_bytes_;
WvPLOutputProtection output_protection_;
WvPLOutputProtection requested_output_protection_;
// If the video resolution of the content being decrypted/decoded falls
// within one of the specified ranges, the optional output protections may
// be applied.
std::vector<WvPLVideoResolutionConstraint> video_resolution_constraints_;
TrackType track_type_ = TRACK_TYPE_UNSPECIFIED;
KeyType key_type_ = CONTENT;
};
struct WvPLDeviceInfo {
WvPLDeviceInfo() {
security_level_ = DEVICE_LEVEL_UNSPECIFIED;
system_id_ = 0;
test_device_ = false;
}
void set_system_id(uint32_t system_id) { system_id_ = system_id; }
uint32_t system_id() const { return system_id_; }
void set_soc(const std::string& soc) { soc_ = soc; }
const std::string& soc() const { return soc_; }
void set_manufacturer(const std::string& manufacturer) {
manufacturer_ = manufacturer;
}
const std::string& manufacturer() const { return manufacturer_; }
void set_model(const std::string& model) { model_ = model; }
const std::string& model() const { return model_; }
void set_device_type(const std::string& device_type) {
device_type_ = device_type;
}
const std::string& device_type() const { return device_type_; }
void set_security_level(DeviceSecurityLevel level) {
security_level_ = level;
}
DeviceSecurityLevel security_level() const { return security_level_; }
void set_test_device(bool test_device) { test_device_ = test_device; }
bool test_device() const { return test_device_; }
void set_serial_number(const std::string& serial_number) {
serial_number_ = serial_number;
}
const std::string& serial_number() const { return serial_number_; }
void set_service_id(const std::string& service_id) {
service_id_ = service_id;
}
const std::string& service_id() const { return service_id_; }
// Widevine system ID for this device family.
uint32_t system_id_;
// Name of system-on-a-chip.
std::string soc_;
// Name of manufacturer.
std::string manufacturer_;
// Manufacturer's model name.
std::string model_;
// Type of device (Phone, Tablet, TV, etc).
std::string device_type_;
// Widevine-defined security level.
DeviceSecurityLevel security_level_;
// True if the certificate corresponds to a test (non production) device.
bool test_device_;
// 128-bit globally unique serial number of certificate.
std::string serial_number_;
// Service identifier (web origin) for the provider which owns the
// certificate.
std::string service_id_;
};
// This message is used to hold usage data for each Widevine system Id.
struct WvPLLicenseStatusCounterData {
// Initialize members
WvPLLicenseStatusCounterData() : license_status_(0), status_count_(0) {}
uint32_t license_status_;
// Count of occurences of the above status;
uint32_t status_count_;
};
// This message is used to hold usage data for each device model.
struct WvPLDeviceModelCounterData {
std::string device_model_;
// Key is each status we returned associated with the above model;
std::map<uint32_t, WvPLLicenseStatusCounterData> status_map_;
};
// This message is used to hold usage data for each device make.
struct WvPLDeviceMakeCounterData {
std::string device_make_;
// Key is each model associated with this device make.
std::map<std::string, WvPLDeviceModelCounterData> model_map_;
};
// This message is used to hold usage data for each Widevine system Id.
struct WvPLSystemIdCounterData {
// Initialize members
WvPLSystemIdCounterData() : system_id_(0) {}
uint32_t system_id_;
// Key is each make we handled associated with the above system Id.
std::map<std::string, WvPLDeviceMakeCounterData> make_map_;
};
// This top level message contains aggregated usage data for license requests.
struct WvPLCounterData {
// Initialize members
WvPLCounterData() : start_time_utc_(0), end_time_utc_(0) {}
// Time of the first license in this structure, represented as seconds since
// Unix epoch.
time_t start_time_utc_;
// Time of the last license in this structure, represented as seconds since
// Unix epoch.
time_t end_time_utc_;
// Key is each system Id we handled.
std::map<uint32_t, WvPLSystemIdCounterData> system_id_map_;
};
struct WvPLSessionInit {
WvPLSessionInit()
: license_start_time_(0), override_provider_client_token_(false) {}
// Accessors
void set_session_id(const std::string& session_id) {
session_id_ = session_id;
}
std::string session_id() const { return session_id_; }
void set_purchase_id(const std::string& purchase_id) {
purchase_id_ = purchase_id;
}
std::string purchase_id() const { return purchase_id_; }
void set_master_signing_key(const std::string& master_signing_key) {
master_signing_key_ = master_signing_key;
}
std::string master_signing_key() const { return master_signing_key_; }
void set_license_start_time(const int64_t license_start_time) {
license_start_time_ = license_start_time;
}
int64_t license_start_time() const { return license_start_time_; }
void set_provider_client_token(const std::string& provider_client_token) {
provider_client_token_ = provider_client_token;
}
std::string provider_client_token() const { return provider_client_token_; }
void set_provider_session_token(const std::string& provider_session_token) {
provider_session_token_ = provider_session_token;
}
std::string provider_session_token() const { return provider_session_token_; }
void set_override_provider_client_token(bool override_provider_client_token) {
override_provider_client_token_ = override_provider_client_token;
}
bool override_provider_client_token() const {
return override_provider_client_token_;
}
// Identifier for the session.
std::string session_id_;
// Identifier for the purchased content.
std::string purchase_id_;
// Master signing key should be 128 bits in length.
std::string master_signing_key_;
// signing_key should be 512 bits in length to be split into two
// (server || client) HMAC-SHA256 keys.
std::string signing_key_;
// The reference time in UTC as calculated by the client clock.
int64_t license_start_time_;
// Client token for the session.
std::string provider_client_token_;
// Session token for the session.
std::string provider_session_token_;
// If false and the license request contains a |provider_client_token_|,
// use the token from that request even if |provider_client_token_| is
// specified.
// If true and the license request contains a |provider_client_token_|,
// use |provider_client_token_|.
bool override_provider_client_token_;
};
struct WvPLClientCapabilities {
WvPLClientCapabilities() {}
// Accessors
void set_client_token(bool client_token) { client_token_ = client_token; }
bool client_token() const { return client_token_; }
void set_session_token(bool session_token) { session_token_ = session_token; }
bool session_token() const { return session_token_; }
void set_video_resolution_constraints(bool video_resolution_constraints) {
video_resolution_constraints_ = video_resolution_constraints;
}
bool video_resolution_constraints() const {
return video_resolution_constraints_;
}
void set_max_hdcp_version(HDCP max_hdcp_version) {
max_hdcp_version_ = max_hdcp_version;
}
HDCP max_hdcp_version() const { return max_hdcp_version_; }
void set_oem_crypto_api_version(uint32_t oem_crypto_api_version) {
oem_crypto_api_version_ = oem_crypto_api_version;
}
uint32_t oem_crypto_api_version() const { return oem_crypto_api_version_; }
void set_anti_rollback_usage_table(bool anti_rollback_usage_table) {
anti_rollback_usage_table_ = anti_rollback_usage_table;
}
bool anti_rollback_usage_table() const { return anti_rollback_usage_table_; }
void set_srm_version(uint32_t srm_version) { srm_version_ = srm_version; }
uint32_t srm_version() const { return srm_version_; }
void set_can_update_srm(bool can_update_srm) {
can_update_srm_ = can_update_srm;
}
bool can_update_srm() const { return can_update_srm_; }
void add_supported_certificate_key_type(const CertificateKeyType key_type) {
supported_certificate_key_type_.push_back(key_type);
}
const std::list<CertificateKeyType> supported_certificate_key_type() const {
return supported_certificate_key_type_;
}
void set_analog_output_capabilities(
const AnalogOutputCapabilities analog_output_capabilities) {
analog_output_capabilities_ = analog_output_capabilities;
}
const AnalogOutputCapabilities analog_output_capabilities() const {
return analog_output_capabilities_;
}
void set_can_disable_analog_output(bool can_disable_analog_output) {
can_disable_analog_output_ = can_disable_analog_output;
}
bool can_disable_analog_output() const { return can_disable_analog_output_; }
// Member variables
// Client token generated by the content provider.
bool client_token_ = false;
// A token associated with the client session.
bool session_token_ = false;
// Video resolution constraints. If the video resolution of the
// content being decrypted/decoded falls within one of the specified ranges,
// the required_protections may be applied. Otherwise an error will be
// reported.
// NOTE: Use of this feature is not recommended, as it is only supported on
// a small number of platforms.
bool video_resolution_constraints_ = false;
// The max "High-bandwidth Digital Content Protection" (HDCP) version
// supported by the client.
HDCP max_hdcp_version_ = HDCP_NONE;
// The OEM Crypto API version supported by the client.
uint32_t oem_crypto_api_version_;
// Flag to indicate the key must only be used if the client
// supports anti rollback of the user table. Content provider can query the
// client capabilities to determine if the client support this feature.
bool anti_rollback_usage_table_ = false;
// The client shall report |srm_version| if available.
uint32_t srm_version_;
// A device may have SRM data, and report a version, but may not be capable
// of updating SRM data.
bool can_update_srm_ = false;
// A list of CertificateKeyTypes.
std::list<CertificateKeyType> supported_certificate_key_type_;
// Analog capabilities of the device.
AnalogOutputCapabilities analog_output_capabilities_ = ANALOG_OUTPUT_UNKNOWN;
// Indicates if the device can disable it's analog output.
bool can_disable_analog_output_ = false;
};
/**
* Represents the Client Identification information. In the License Proxy
* SDK, this structure is populated as a result of parsing the license
* request from the CDM. This struct is used by Proxy SDK.
*/
struct WvPLClientInfo {
WvPLClientInfo()
: max_hdcp_version_(HDCP_NONE),
oem_crypto_api_version_(0),
analog_output_capabilities_(ANALOG_OUTPUT_UNKNOWN),
can_disable_analog_output_(false) {}
// Accessors
void set_max_hdcp_version(HDCP max_hdcp_version) {
max_hdcp_version_ = max_hdcp_version;
}
HDCP max_hdcp_version() const { return max_hdcp_version_; }
void set_oem_crypto_api_version(uint32_t oem_crypto_api_version) {
oem_crypto_api_version_ = oem_crypto_api_version;
}
uint32_t oem_crypto_api_version() const { return oem_crypto_api_version_; }
void set_provider_client_token(const std::string& provider_client_token) {
provider_client_token_ = provider_client_token;
}
const std::string& provider_client_token() const {
return provider_client_token_;
}
void set_cdm_version(const std::string& cdm_version) {
cdm_version_ = cdm_version;
}
const std::string& cdm_version() const { return cdm_version_; }
void set_name_value(const std::string& name, const std::string& value) {
names_values_.insert(std::make_pair(name, value));
}
const std::map<std::string, std::string>& names_values() {
return names_values_;
}
void set_analog_output_capabilities(AnalogOutputCapabilities capability) {
analog_output_capabilities_ = capability;
}
const AnalogOutputCapabilities analog_output_capabilities() const {
return analog_output_capabilities_;
}
void set_can_disable_analog_output(bool can_disable) {
can_disable_analog_output_ = can_disable;
}
bool can_disable_analog_output() const { return can_disable_analog_output_; }
const WvPLClientCapabilities client_capabilities() const {
return client_capabilities_;
}
void set_client_capabilities(
const WvPLClientCapabilities& client_capabilities) {
client_capabilities_ = client_capabilities;
}
// Member variables
// The max "High-bandwidth Digital Content Protection" (HDCP) version
// supported by the device.
HDCP max_hdcp_version_;
// The OEM Crypto API version supported by the client.
uint32_t oem_crypto_api_version_;
// The client CDM version.
std::string cdm_version_;
// The client token generated by the content provider.
std::string provider_client_token_;
// Map of other fields specified as name-value pairs representing the
// client.
std::map<std::string, std::string> names_values_;
// Analog capabilities of the device.
AnalogOutputCapabilities analog_output_capabilities_;
// Indicates if the device can disable it's analog output.
bool can_disable_analog_output_;
// Capabilities which not all clients may support. Used for the license
// exchange protocol only.
WvPLClientCapabilities client_capabilities_;
};
struct WvPLEntitledKey {
WvPLEntitledKey() {}
// Accessors.
void set_entitlement_key_id(const std::string& entitlement_key_id) {
entitlement_key_id_ = entitlement_key_id;
}
const std::string& entitlement_key_id() const { return entitlement_key_id_; }
void set_key_id(const std::string& key_id) { key_id_ = key_id; }
const std::string& key_id() const { return key_id_; }
void set_key_bytes(const std::string& key_bytes) { key_bytes_ = key_bytes; }
const std::string& key_bytes() const { return key_bytes_; }
void set_entitlement_key_iv(const std::string& entitlement_key_iv) {
entitlement_key_iv_ = entitlement_key_iv;
}
const std::string& entitlement_key_iv() const { return entitlement_key_iv_; }
void set_entitlement_key_size_bytes(uint32_t entitlement_key_size_bytes) {
entitlement_key_size_bytes_ = entitlement_key_size_bytes;
}
uint32_t entitlement_key_size_bytes() const {
return entitlement_key_size_bytes_;
}
// Member variables.
// ID of entitlement key used for wrapping |key|.
std::string entitlement_key_id_;
// ID of the entitled key.
std::string key_id_;
// Wrapped key.
std::string key_bytes_;
// IV used for wrapping |key|.
std::string entitlement_key_iv_;
// Size of entitlement key used for wrapping |key|.
uint32_t entitlement_key_size_bytes_ = 32;
};
/*
* Defines the 'pssh' box for Common Encryption (CENC).
*/
struct WvPLWidevinePsshData {
WvPLWidevinePsshData() {}
// Accessors
void set_content_id(const std::string& content_id) {
content_id_ = content_id;
}
const std::string content_id() const { return content_id_; }
void set_key_id(const std::string& key_id) { key_ids_.push_back(key_id); }
const std::list<std::string>& key_ids() const { return key_ids_; }
void add_entitled_key(const WvPLEntitledKey& entitled_key) {
entitled_keys_.push_back(entitled_key);
}
const std::list<WvPLEntitledKey>& entitled_keys() const {
return entitled_keys_;
}
// Member variables
// A list of key identifiers, for entitlement keys or content keys.
std::list<std::string> key_ids_;
// The content identifier.
std::string content_id_;
// A list of wrapped keys.
std::list<WvPLEntitledKey> entitled_keys_;
};
} // namespace wv_pl_sdk
} // namespace widevine_server
#endif // SDK_EXTERNAL_COMMON_WVPL_WVPL_TYPES_H_