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

Rename CasEcm and CasEcmGenerator classes to Ecm and EcmGenerator.

Browse Source 
-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=230929673
This commit is contained in:
Fang Yu
2019-01-25 10:48:48 -08:00
parent 6a1fcfa108
commit f23c6a1760
10 changed files with 141 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
WORKSPACE
View File

@@ -34,7 +34,7 @@ git_repository(
git_repository( git_repository(
name = "googletest_repo", name = "googletest_repo",
commit = "9816b96a6ddc0430671693df90192bbee57108b6", # 2017-08-11 commit = "b6cd405286ed8635ece71c72f118e659f4ade3fb", # 2019-01-04
remote = "https://github.com/google/googletest.git", remote = "https://github.com/google/googletest.git",
) )

1
media_cas_packager_sdk/internal/BUILD
View File

@@ -29,7 +29,6 @@ cc_library(
"@abseil_repo//absl/base:core_headers", "@abseil_repo//absl/base:core_headers",
"@abseil_repo//absl/strings", "@abseil_repo//absl/strings",
"//common:aes_cbc_util", "//common:aes_cbc_util",
"//common:random_util",
"//common:status", "//common:status",
"//common:string_util", "//common:string_util",
"//media_cas_packager_sdk/public:wv_cas_types", "//media_cas_packager_sdk/public:wv_cas_types",

72
media_cas_packager_sdk/internal/ecm.cc
View File

@@ -15,7 +15,6 @@
#include "glog/logging.h" #include "glog/logging.h"
#include "absl/strings/str_cat.h" #include "absl/strings/str_cat.h"
#include "common/aes_cbc_util.h" #include "common/aes_cbc_util.h"
#include "common/random_util.h"
#include "common/status.h" #include "common/status.h"
#include "common/string_util.h" #include "common/string_util.h"
#include "protos/public/media_cas_encryption.pb.h" #include "protos/public/media_cas_encryption.pb.h"
@@ -112,10 +111,10 @@ bool ConvertIvSizeParam(EcmIvSize param, size_t* size) {
} // namespace } // namespace
Status CasEcm::Initialize(const std::string& content_id, Status Ecm::Initialize(const std::string& content_id,
const std::string& content_provider, const std::string& content_provider,
const EcmInitParameters& ecm_init_parameters, const EcmInitParameters& ecm_init_parameters,
std::string* key_request_message) { std::string* key_request_message) {
if (initialized_) { if (initialized_) {
return {error::INTERNAL, "Already initialized."}; return {error::INTERNAL, "Already initialized."};
} }
@@ -163,7 +162,7 @@ Status CasEcm::Initialize(const std::string& content_id,
return OkStatus(); return OkStatus();
} }
Status CasEcm::ProcessCasEncryptionResponse(const std::string& response) { Status Ecm::ProcessCasEncryptionResponse(const std::string& response) {
if (!initialized_) { if (!initialized_) {
return {error::INTERNAL, "Not initialized."}; return {error::INTERNAL, "Not initialized."};
} }
@@ -173,9 +172,9 @@ Status CasEcm::ProcessCasEncryptionResponse(const std::string& response) {
return ParseEntitlementResponse(response); return ParseEntitlementResponse(response);
} }
Status CasEcm::GenerateEcm(EntitledKeyInfo* even_key, EntitledKeyInfo* odd_key, Status Ecm::GenerateEcm(EntitledKeyInfo* even_key, EntitledKeyInfo* odd_key,
const std::string& track_type, std::string* serialized_ecm, const std::string& track_type, std::string* serialized_ecm,
uint32_t* generation) { uint32_t* generation) {
if (!initialized_) { if (!initialized_) {
return {error::INTERNAL, "Not initialized."}; return {error::INTERNAL, "Not initialized."};
} }
@@ -194,10 +193,8 @@ Status CasEcm::GenerateEcm(EntitledKeyInfo* even_key, EntitledKeyInfo* odd_key,
return GenerateEcmCommon(keys, track_type, serialized_ecm, generation); return GenerateEcmCommon(keys, track_type, serialized_ecm, generation);
} }
Status CasEcm::GenerateSingleKeyEcm(EntitledKeyInfo* key, Status Ecm::GenerateSingleKeyEcm(EntitledKeyInfo* key, const std::string& track_type,
const std::string& track_type, std::string* serialized_ecm, uint32_t* generation) {
std::string* serialized_ecm,
uint32_t* generation) {
if (!initialized_) { if (!initialized_) {
return {error::INTERNAL, "Not initialized."}; return {error::INTERNAL, "Not initialized."};
} }
@@ -215,9 +212,9 @@ Status CasEcm::GenerateSingleKeyEcm(EntitledKeyInfo* key,
return GenerateEcmCommon(keys, track_type, serialized_ecm, generation); return GenerateEcmCommon(keys, track_type, serialized_ecm, generation);
} }
Status CasEcm::GenerateEcmCommon(const std::vector<EntitledKeyInfo*>& keys, Status Ecm::GenerateEcmCommon(const std::vector<EntitledKeyInfo*>& keys,
const std::string& track_type, const std::string& track_type, std::string* serialized_ecm,
std::string* serialized_ecm, uint32_t* generation) { uint32_t* generation) {
if (serialized_ecm == nullptr) { if (serialized_ecm == nullptr) {
return {error::INVALID_ARGUMENT, "No return ecm std::string pointer."}; return {error::INVALID_ARGUMENT, "No return ecm std::string pointer."};
} }
@@ -260,12 +257,12 @@ Status CasEcm::GenerateEcmCommon(const std::vector<EntitledKeyInfo*>& keys,
return OkStatus(); return OkStatus();
} }
void CasEcm::IncrementGeneration() { void Ecm::IncrementGeneration() {
generation_ = (generation_ >= kMaxGeneration) ? 0 : generation_ + 1; generation_ = (generation_ >= kMaxGeneration) ? 0 : generation_ + 1;
} }
Status CasEcm::WrapEntitledKeys(const std::string& track_type, Status Ecm::WrapEntitledKeys(const std::string& track_type,
const std::vector<EntitledKeyInfo*> keys) { const std::vector<EntitledKeyInfo*> keys) {
if (!initialized_) { if (!initialized_) {
return {error::INTERNAL, "Not initialized."}; return {error::INTERNAL, "Not initialized."};
} }
@@ -287,13 +284,7 @@ Status CasEcm::WrapEntitledKeys(const std::string& track_type,
auto entitlement_key = ekey_list.begin(); auto entitlement_key = ekey_list.begin();
for (auto entitled_key : keys) { for (auto entitled_key : keys) {
entitled_key->entitlement_key_id = entitlement_key->key_id; entitled_key->entitlement_key_id = entitlement_key->key_id;
// Wrap key using entitlement key. First generate new IV. // Wrap key using entitlement key.
// TODO(user): Do not randomly generate 'wrapped_key_iv' here ever,
// enforce the caller of 'ecm generator' to provide it.
// And check the provided 'wrapped_key_iv' has valid size.
if (entitled_key->wrapped_key_iv.empty()) {
CHECK(RandomBytes(kWrappedKeyIvSizeBytes, &entitled_key->wrapped_key_iv));
}
Status status = Status status =
WrapKey(entitlement_key->key_value, entitled_key->wrapped_key_iv, WrapKey(entitlement_key->key_value, entitled_key->wrapped_key_iv,
entitled_key->key_value, &entitled_key->wrapped_key_value); entitled_key->key_value, &entitled_key->wrapped_key_value);
@@ -305,8 +296,8 @@ Status CasEcm::WrapEntitledKeys(const std::string& track_type,
return OkStatus(); return OkStatus();
} }
Status CasEcm::WrapKey(const std::string& wrapping_key, const std::string& wrapping_iv, Status Ecm::WrapKey(const std::string& wrapping_key, const std::string& wrapping_iv,
const std::string& key_value, std::string* wrapped_key) { const std::string& key_value, std::string* wrapped_key) {
Status status = ValidateKeyValue(wrapping_key, kWrappingKeySizeBytes); Status status = ValidateKeyValue(wrapping_key, kWrappingKeySizeBytes);
if (!status.ok()) { if (!status.ok()) {
return status; return status;
@@ -328,7 +319,7 @@ Status CasEcm::WrapKey(const std::string& wrapping_key, const std::string& wrapp
return OkStatus(); return OkStatus();
} }
Status CasEcm::ValidateKeys(const std::vector<EntitledKeyInfo*>& keys) { Status Ecm::ValidateKeys(const std::vector<EntitledKeyInfo*>& keys) {
for (const auto& key : keys) { for (const auto& key : keys) {
Status status; Status status;
status = ValidateKeyId(key->key_id); status = ValidateKeyId(key->key_id);
@@ -343,11 +334,15 @@ Status CasEcm::ValidateKeys(const std::vector<EntitledKeyInfo*>& keys) {
if (!status.ok()) { if (!status.ok()) {
return status; return status;
} }
status = ValidateIv(key->wrapped_key_iv, kWrappedKeyIvSizeBytes);
if (!status.ok()) {
return status;
}
} }
return OkStatus(); return OkStatus();
} }
Status CasEcm::ValidateWrappedKeys(const std::vector<EntitledKeyInfo*>& keys) { Status Ecm::ValidateWrappedKeys(const std::vector<EntitledKeyInfo*>& keys) {
for (const auto& key : keys) { for (const auto& key : keys) {
Status status; Status status;
status = ValidateKeyId(key->key_id); status = ValidateKeyId(key->key_id);
@@ -371,15 +366,14 @@ Status CasEcm::ValidateWrappedKeys(const std::vector<EntitledKeyInfo*>& keys) {
return OkStatus(); return OkStatus();
} }
Status CasEcm::ValidateKeyId(const std::string& key_id) { Status Ecm::ValidateKeyId(const std::string& key_id) {
if (key_id.size() != kKeyIdSizeBytes) { if (key_id.size() != kKeyIdSizeBytes) {
return {error::INVALID_ARGUMENT, "Key ID must be 16 bytes."}; return {error::INVALID_ARGUMENT, "Key ID must be 16 bytes."};
} }
return OkStatus(); return OkStatus();
} }
Status CasEcm::ValidateKeyValue(const std::string& key_value, Status Ecm::ValidateKeyValue(const std::string& key_value, size_t key_value_size) {
size_t key_value_size) {
if (key_value.size() != key_value_size) { if (key_value.size() != key_value_size) {
return Status( return Status(
error::INVALID_ARGUMENT, error::INVALID_ARGUMENT,
@@ -388,14 +382,14 @@ Status CasEcm::ValidateKeyValue(const std::string& key_value,
return OkStatus(); return OkStatus();
} }
Status CasEcm::ValidateIv(const std::string& iv, size_t size) { Status Ecm::ValidateIv(const std::string& iv, size_t size) {
if (iv.size() != size) { if (iv.size() != size) {
return {error::INVALID_ARGUMENT, "IV is wrong size."}; return {error::INVALID_ARGUMENT, "IV is wrong size."};
} }
return OkStatus(); return OkStatus();
} }
std::string CasEcm::SerializeEcm(const std::vector<EntitledKeyInfo*>& keys) { std::string Ecm::SerializeEcm(const std::vector<EntitledKeyInfo*>& keys) {
// Five bytes (40 bits including padding) // Five bytes (40 bits including padding)
std::bitset<kNumBitsCaSystemIdField> ca_system_id(kWvCasCaSystemId); std::bitset<kNumBitsCaSystemIdField> ca_system_id(kWvCasCaSystemId);
std::bitset<kNumBitsEcmVersionField> ecm_version(kEcmVersion); std::bitset<kNumBitsEcmVersionField> ecm_version(kEcmVersion);
@@ -435,7 +429,7 @@ std::string CasEcm::SerializeEcm(const std::vector<EntitledKeyInfo*>& keys) {
return serialized_ecm; return serialized_ecm;
} }
Status CasEcm::CreateEntitlementRequest(std::string* request_string) { Status Ecm::CreateEntitlementRequest(std::string* request_string) {
CasEncryptionRequest request; CasEncryptionRequest request;
request.set_content_id(content_id_); request.set_content_id(content_id_);
@@ -453,7 +447,7 @@ Status CasEcm::CreateEntitlementRequest(std::string* request_string) {
return OkStatus(); return OkStatus();
} }
Status CasEcm::ParseEntitlementResponse(const std::string& response_string) { Status Ecm::ParseEntitlementResponse(const std::string& response_string) {
// TODO(user): parse valid response. NOT Implemented. // TODO(user): parse valid response. NOT Implemented.
ClearEntitlementKeys(); ClearEntitlementKeys();
@@ -532,7 +526,7 @@ Status CasEcm::ParseEntitlementResponse(const std::string& response_string) {
return OkStatus(); return OkStatus();
} }
size_t CasEcm::CountEntitlementKeys() const { size_t Ecm::CountEntitlementKeys() const {
size_t count = 0; size_t count = 0;
for (const auto& track : entitlement_keys_) { for (const auto& track : entitlement_keys_) {
count += track.second.size(); count += track.second.size();
@@ -540,7 +534,7 @@ size_t CasEcm::CountEntitlementKeys() const {
return count; return count;
} }
bool CasEcm::CheckEntitlementKeys() const { bool Ecm::CheckEntitlementKeys() const {
// TODO(user): Cross-check entitlement_keys_ track types with track_types_. // TODO(user): Cross-check entitlement_keys_ track types with track_types_.
if (track_types_.size() > CountEntitlementTracks()) { if (track_types_.size() > CountEntitlementTracks()) {
// One or more tracks are missing. // One or more tracks are missing.

17
media_cas_packager_sdk/internal/ecm.h
View File

@@ -9,7 +9,7 @@
#ifndef MEDIA_CAS_PACKAGER_SDK_INTERNAL_ECM_H_ #ifndef MEDIA_CAS_PACKAGER_SDK_INTERNAL_ECM_H_
#define MEDIA_CAS_PACKAGER_SDK_INTERNAL_ECM_H_ #define MEDIA_CAS_PACKAGER_SDK_INTERNAL_ECM_H_
#include <stddef.h> #include <cstddef>
#include <list> #include <list>
#include <map> #include <map>
#include <string> #include <string>
@@ -47,7 +47,7 @@ enum EcmIvSize { kIvSize8 = 0, kIvSize16 = 1 };
// Information needed to start a new ECM stream. // Information needed to start a new ECM stream.
// Fields: // Fields:
// |content_iv_size| size of all content key IVs in the ECM stream. // |content_iv_size| size of all content key IVs in the ECM stream.
// A constant of type CasEcmSize specifying 8 or 16. // A constant of type EcmIvSize specifying 8 or 16.
// |key_rotation_enabled| the encryption uses multiple keys in rotation. // |key_rotation_enabled| the encryption uses multiple keys in rotation.
// |crypto_mode| the encryption mode used for the content stream. // |crypto_mode| the encryption mode used for the content stream.
// A constant of type CryptoMode. // A constant of type CryptoMode.
@@ -71,14 +71,13 @@ struct EcmInitParameters {
// //
// TODO(user): Add usage example. // TODO(user): Add usage example.
// //
// Class CasEcm is not thread safe. // Class Ecm is not thread safe.
// TODO(user): Rename class to Ecm. class Ecm {
class CasEcm {
public: public:
CasEcm() = default; Ecm() = default;
CasEcm(const CasEcm&) = delete; Ecm(const Ecm&) = delete;
CasEcm& operator=(const CasEcm&) = delete; Ecm& operator=(const Ecm&) = delete;
virtual ~CasEcm() = default; virtual ~Ecm() = default;
// Perform initialization for a new ECM stream. // Perform initialization for a new ECM stream.
// Args: // Args:

20
media_cas_packager_sdk/internal/ecm_generator.cc
View File

@@ -18,7 +18,7 @@ static constexpr int kKeyIvSize8 = 8;
static constexpr int kKeyIvSize16 = 16; static constexpr int kKeyIvSize16 = 16;
static constexpr int kMaxBytesKeyIdField = 16; static constexpr int kMaxBytesKeyIdField = 16;
std::string CasEcmGenerator::GenerateEcm(const EcmParameters& params) { std::string EcmGenerator::GenerateEcm(const EcmParameters& params) {
std::vector<EntitledKeyInfo> keys; std::vector<EntitledKeyInfo> keys;
Status status = ProcessEcmParameters(params, &keys); Status status = ProcessEcmParameters(params, &keys);
if (!status.ok() || !initialized_) { if (!status.ok() || !initialized_) {
@@ -37,14 +37,14 @@ std::string CasEcmGenerator::GenerateEcm(const EcmParameters& params) {
&generation); &generation);
} }
if (!status.ok()) { if (!status.ok()) {
LOG(ERROR) << " Call to CasEcm's ECM Generator failed: " << status; LOG(ERROR) << " Generate ECM call failed: " << status;
return ""; return "";
} }
return serialized_ecm; return serialized_ecm;
} }
Status CasEcmGenerator::ProcessEcmParameters( Status EcmGenerator::ProcessEcmParameters(const EcmParameters& ecm_params,
const EcmParameters& ecm_params, std::vector<EntitledKeyInfo>* keys) { std::vector<EntitledKeyInfo>* keys) {
initialized_ = false; initialized_ = false;
rotation_enabled_ = ecm_params.rotation_enabled; rotation_enabled_ = ecm_params.rotation_enabled;
@@ -73,7 +73,7 @@ Status CasEcmGenerator::ProcessEcmParameters(
return OkStatus(); return OkStatus();
} }
Status CasEcmGenerator::ValidateKeyId(const std::string& id) { Status EcmGenerator::ValidateKeyId(const std::string& id) {
if (id.empty()) { if (id.empty()) {
return {error::INVALID_ARGUMENT, "Key id is empty."}; return {error::INVALID_ARGUMENT, "Key id is empty."};
} }
@@ -83,7 +83,7 @@ Status CasEcmGenerator::ValidateKeyId(const std::string& id) {
return OkStatus(); return OkStatus();
} }
Status CasEcmGenerator::ValidateKeyData(const std::string& key_data) { Status EcmGenerator::ValidateKeyData(const std::string& key_data) {
if (key_data.empty()) { if (key_data.empty()) {
return {error::INVALID_ARGUMENT, "Key data is empty."}; return {error::INVALID_ARGUMENT, "Key data is empty."};
} }
@@ -93,7 +93,7 @@ Status CasEcmGenerator::ValidateKeyData(const std::string& key_data) {
return OkStatus(); return OkStatus();
} }
Status CasEcmGenerator::ValidateIv(const std::string& iv, size_t required_size) { Status EcmGenerator::ValidateIv(const std::string& iv, size_t required_size) {
if (iv.empty()) { if (iv.empty()) {
return {error::INVALID_ARGUMENT, "IV is empty."}; return {error::INVALID_ARGUMENT, "IV is empty."};
} }
@@ -107,7 +107,7 @@ Status CasEcmGenerator::ValidateIv(const std::string& iv, size_t required_size)
return OkStatus(); return OkStatus();
} }
Status CasEcmGenerator::ValidateWrappedKeyIv(const std::string& iv) { Status EcmGenerator::ValidateWrappedKeyIv(const std::string& iv) {
// All wrapped key IVs must be 16 bytes. // All wrapped key IVs must be 16 bytes.
Status status = ValidateIv(iv, kIvSize16); Status status = ValidateIv(iv, kIvSize16);
if (!status.ok()) { if (!status.ok()) {
@@ -116,7 +116,7 @@ Status CasEcmGenerator::ValidateWrappedKeyIv(const std::string& iv) {
return status; return status;
} }
Status CasEcmGenerator::ValidateContentIv(const std::string& iv) { Status EcmGenerator::ValidateContentIv(const std::string& iv) {
// If content_iv_size_ is zero, use this IV as the size for all future IVs in // If content_iv_size_ is zero, use this IV as the size for all future IVs in
// this stream. // this stream.
if (content_iv_size_ == 0) { if (content_iv_size_ == 0) {
@@ -129,7 +129,7 @@ Status CasEcmGenerator::ValidateContentIv(const std::string& iv) {
return status; return status;
} }
Status CasEcmGenerator::ValidateKeyParameters(const KeyParameters& key_params) { Status EcmGenerator::ValidateKeyParameters(const KeyParameters& key_params) {
Status status; Status status;
status = ValidateKeyId(key_params.key_id); status = ValidateKeyId(key_params.key_id);
if (!status.ok()) return status; if (!status.ok()) return status;

18
media_cas_packager_sdk/internal/ecm_generator.h
View File

@@ -40,7 +40,6 @@ struct KeyParameters {
// EcmParameters holds information that is needed by the EcmGenerator. It is // EcmParameters holds information that is needed by the EcmGenerator. It is
// partially set up with data from a KeyGenerator (obtained via GenerateKey()). // partially set up with data from a KeyGenerator (obtained via GenerateKey()).
// IVs are added later. // IVs are added later.
// TODO(user): Consider rename to EcmGeneratorParameters.
struct EcmParameters { struct EcmParameters {
// TODO(user): entitlement_key_id does not seem to be used, but assumed // TODO(user): entitlement_key_id does not seem to be used, but assumed
// to exist by unit tests. // to exist by unit tests.
@@ -55,13 +54,12 @@ struct EcmParameters {
}; };
// ECM Generator for Widevine/MediaCAS entitled keys. // ECM Generator for Widevine/MediaCAS entitled keys.
// TODO(user): Rename class to EcmGenerator. class EcmGenerator {
class CasEcmGenerator {
public: public:
CasEcmGenerator() = default; EcmGenerator() = default;
CasEcmGenerator(const CasEcmGenerator&) = delete; EcmGenerator(const EcmGenerator&) = delete;
CasEcmGenerator& operator=(const CasEcmGenerator&) = delete; EcmGenerator& operator=(const EcmGenerator&) = delete;
virtual ~CasEcmGenerator() = default; virtual ~EcmGenerator() = default;
virtual std::string GenerateEcm(const EcmParameters& params); virtual std::string GenerateEcm(const EcmParameters& params);
@@ -69,10 +67,10 @@ class CasEcmGenerator {
bool initialized() { return initialized_; } bool initialized() { return initialized_; }
bool rotation_enabled() { return rotation_enabled_; } bool rotation_enabled() { return rotation_enabled_; }
void set_ecm(std::unique_ptr<CasEcm> ecm) { ecm_ = std::move(ecm); } void set_ecm(std::unique_ptr<Ecm> ecm) { ecm_ = std::move(ecm); }
private: private:
friend class CasEcmGeneratorTest; friend class EcmGeneratorTest;
Status ProcessEcmParameters(const EcmParameters& ecm_params, Status ProcessEcmParameters(const EcmParameters& ecm_params,
std::vector<EntitledKeyInfo>* keys); std::vector<EntitledKeyInfo>* keys);
@@ -91,7 +89,7 @@ class CasEcmGenerator {
uint32_t current_key_index_ = 0; uint32_t current_key_index_ = 0;
bool current_key_even_ = true; bool current_key_even_ = true;
uint32_t content_iv_size_ = 0; uint32_t content_iv_size_ = 0;
std::unique_ptr<CasEcm> ecm_; std::unique_ptr<Ecm> ecm_;
}; };
} // namespace cas } // namespace cas

20
media_cas_packager_sdk/internal/ecm_generator_test.cc
View File

@@ -94,7 +94,7 @@ Status HandleCasEncryptionRequest(const std::string& request_string,
} // namespace } // namespace
class CasEcmGeneratorTest : public testing::Test { class EcmGeneratorTest : public testing::Test {
protected: protected:
void SetUp() override { void SetUp() override {
} }
@@ -124,9 +124,9 @@ class CasEcmGeneratorTest : public testing::Test {
params->key_params.push_back(kKeyParamsOdd); params->key_params.push_back(kKeyParamsOdd);
} }
// Call this to setup the guts (CasEcm) of the ECM Generator. // Call this to setup the guts (Ecm) of the ECM Generator.
void PrepareEcmGenerator(bool key_rotation_enabled) { void PrepareEcmGenerator(bool key_rotation_enabled) {
ecm_ = absl::make_unique<CasEcm>(); ecm_ = absl::make_unique<Ecm>();
std::string entitlement_request; std::string entitlement_request;
std::string entitlement_response; std::string entitlement_response;
ecm_init_params_.key_rotation_enabled = key_rotation_enabled; ecm_init_params_.key_rotation_enabled = key_rotation_enabled;
@@ -155,12 +155,12 @@ class CasEcmGeneratorTest : public testing::Test {
kEcmWrappedKeyIvOdd, kEcmWrappedKeyIvOdd,
{kEcmContentIvOdd}}; {kEcmContentIvOdd}};
std::unique_ptr<CasEcm> ecm_; std::unique_ptr<Ecm> ecm_;
EcmInitParameters ecm_init_params_; EcmInitParameters ecm_init_params_;
CasEcmGenerator ecm_gen_; EcmGenerator ecm_gen_;
}; };
TEST_F(CasEcmGeneratorTest, InitializeNoRotation) { TEST_F(EcmGeneratorTest, InitializeNoRotation) {
EXPECT_FALSE(ecm_gen_.initialized()); EXPECT_FALSE(ecm_gen_.initialized());
PrepareEcmGenerator(false); PrepareEcmGenerator(false);
@@ -178,7 +178,7 @@ TEST_F(CasEcmGeneratorTest, InitializeNoRotation) {
EXPECT_FALSE(ecm_gen_.rotation_enabled()); EXPECT_FALSE(ecm_gen_.rotation_enabled());
} }
TEST_F(CasEcmGeneratorTest, GenerateNoRotation) { TEST_F(EcmGeneratorTest, GenerateNoRotation) {
PrepareEcmGenerator(false); PrepareEcmGenerator(false);
EcmParameters ecm_params; EcmParameters ecm_params;
@@ -214,7 +214,7 @@ TEST_F(CasEcmGeneratorTest, GenerateNoRotation) {
EXPECT_EQ(kEcmContentIvSingle, ecm_string.substr(69, 8)); EXPECT_EQ(kEcmContentIvSingle, ecm_string.substr(69, 8));
} }
TEST_F(CasEcmGeneratorTest, Generate2NoRotation) { TEST_F(EcmGeneratorTest, Generate2NoRotation) {
PrepareEcmGenerator(false); PrepareEcmGenerator(false);
EcmParameters ecm_params; EcmParameters ecm_params;
@@ -244,7 +244,7 @@ TEST_F(CasEcmGeneratorTest, Generate2NoRotation) {
EXPECT_EQ(kEcmContentIvSingle, ecm_string.substr(69, 8)); EXPECT_EQ(kEcmContentIvSingle, ecm_string.substr(69, 8));
} }
TEST_F(CasEcmGeneratorTest, InitializeSimpleRotation) { TEST_F(EcmGeneratorTest, InitializeSimpleRotation) {
EXPECT_FALSE(ecm_gen_.initialized()); EXPECT_FALSE(ecm_gen_.initialized());
EcmParameters ecm_params; EcmParameters ecm_params;
std::vector<EntitledKeyInfo> keys; std::vector<EntitledKeyInfo> keys;
@@ -261,7 +261,7 @@ TEST_F(CasEcmGeneratorTest, InitializeSimpleRotation) {
EXPECT_TRUE(ecm_gen_.rotation_enabled()); EXPECT_TRUE(ecm_gen_.rotation_enabled());
} }
TEST_F(CasEcmGeneratorTest, GenerateSimpleRotation) { TEST_F(EcmGeneratorTest, GenerateSimpleRotation) {
EcmParameters ecm_params; EcmParameters ecm_params;
PrepareEcmGenerator(true); PrepareEcmGenerator(true);

116
media_cas_packager_sdk/internal/ecm_test.cc
View File

@@ -31,6 +31,7 @@ constexpr char kTrackTypeSD[] = "SD";
constexpr char kTrackTypeHD[] = "HD"; constexpr char kTrackTypeHD[] = "HD";
constexpr char kTrackTypeAUDIO[] = "AUDIO"; constexpr char kTrackTypeAUDIO[] = "AUDIO";
constexpr char kTrackTypeBAD[] = "BAD"; constexpr char kTrackTypeBAD[] = "BAD";
constexpr char kWrappedKeyIv[] = "wrapped_key_iv..";
constexpr size_t kEcmHeaderSize = 5; constexpr size_t kEcmHeaderSize = 5;
constexpr size_t kEcmKeyIdSize = 16; constexpr size_t kEcmKeyIdSize = 16;
@@ -50,14 +51,15 @@ void InitEntitledKey(EntitledKeyInfo* key, const std::string& id,
key->key_id = id; key->key_id = id;
key->key_value = value; key->key_value = value;
key->content_iv = iv; key->content_iv = iv;
key->wrapped_key_iv = kWrappedKeyIv;
} }
} // namespace } // namespace
class MockCasEcm : public CasEcm { class MockEcm : public Ecm {
public: public:
MockCasEcm() = default; MockEcm() = default;
~MockCasEcm() override = default; ~MockEcm() override = default;
MOCK_CONST_METHOD0(generation, uint32_t()); MOCK_CONST_METHOD0(generation, uint32_t());
MOCK_CONST_METHOD0(crypto_mode, CryptoMode()); MOCK_CONST_METHOD0(crypto_mode, CryptoMode());
@@ -87,7 +89,7 @@ class MockCasEcm : public CasEcm {
} }
}; };
class CasEcmTest : public testing::Test { class EcmTest : public testing::Test {
protected: protected:
void SetUp() override { void SetUp() override {
InitEntitledKey(&valid1_iv_16_8_, "keyid_16b......1", "keyvalue_16b...1", InitEntitledKey(&valid1_iv_16_8_, "keyid_16b......1", "keyvalue_16b...1",
@@ -185,7 +187,7 @@ class CasEcmTest : public testing::Test {
EntitledKeyInfo invalid1_key_id_iv_16_8_; EntitledKeyInfo invalid1_key_id_iv_16_8_;
}; };
class CasEcmSerializeEcmTest : public CasEcmTest { class EcmSerializeEcmTest : public EcmTest {
public: public:
void ValidateEcmHeaderFields(const std::string& ecm_string, bool rotation_enabled, void ValidateEcmHeaderFields(const std::string& ecm_string, bool rotation_enabled,
int gen, CryptoMode crypto_mode, int gen, CryptoMode crypto_mode,
@@ -221,8 +223,8 @@ class CasEcmSerializeEcmTest : public CasEcmTest {
} }
}; };
TEST_F(CasEcmTest, GenerateEcmNotInitialized) { TEST_F(EcmTest, GenerateEcmNotInitialized) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1; EntitledKeyInfo key1;
std::string ecm_data; std::string ecm_data;
uint32_t gen; uint32_t gen;
@@ -231,8 +233,8 @@ TEST_F(CasEcmTest, GenerateEcmNotInitialized) {
.error_code()); .error_code());
} }
TEST_F(CasEcmTest, GenerateEcm2NotInitialized) { TEST_F(EcmTest, GenerateEcm2NotInitialized) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1; EntitledKeyInfo key1;
EntitledKeyInfo key2; EntitledKeyInfo key2;
std::string ecm_data; std::string ecm_data;
@@ -242,15 +244,15 @@ TEST_F(CasEcmTest, GenerateEcm2NotInitialized) {
.error_code()); .error_code());
} }
TEST_F(CasEcmTest, SetResponseNotInitialized) { TEST_F(EcmTest, SetResponseNotInitialized) {
CasEcm ecm_gen; Ecm ecm_gen;
const std::string response("anything"); const std::string response("anything");
EXPECT_EQ(error::INTERNAL, EXPECT_EQ(error::INTERNAL,
ecm_gen.ProcessCasEncryptionResponse(response).error_code()); ecm_gen.ProcessCasEncryptionResponse(response).error_code());
} }
TEST_F(CasEcmTest, InitNoTracksFail) { TEST_F(EcmTest, InitNoTracksFail) {
CasEcm ecm_gen; Ecm ecm_gen;
std::string request; std::string request;
EXPECT_EQ( EXPECT_EQ(
error::INVALID_ARGUMENT, error::INVALID_ARGUMENT,
@@ -258,15 +260,15 @@ TEST_F(CasEcmTest, InitNoTracksFail) {
.error_code()); .error_code());
} }
TEST_F(CasEcmTest, InitSucceed) { TEST_F(EcmTest, InitSucceed) {
CasEcm ecm_gen; Ecm ecm_gen;
std::string request; std::string request;
ASSERT_OK( ASSERT_OK(
ecm_gen.Initialize(content_id_, provider_, params_simple_, &request)); ecm_gen.Initialize(content_id_, provider_, params_simple_, &request));
} }
TEST_F(CasEcmTest, SecondInitFail) { TEST_F(EcmTest, SecondInitFail) {
CasEcm ecm_gen; Ecm ecm_gen;
std::string request; std::string request;
ASSERT_OK( ASSERT_OK(
ecm_gen.Initialize(content_id_, provider_, params_simple_, &request)); ecm_gen.Initialize(content_id_, provider_, params_simple_, &request));
@@ -275,8 +277,8 @@ TEST_F(CasEcmTest, SecondInitFail) {
.error_code()); .error_code());
} }
TEST_F(CasEcmTest, InitEmptyContentIdFail) { TEST_F(EcmTest, InitEmptyContentIdFail) {
CasEcm ecm_gen; Ecm ecm_gen;
const std::string empty_content_id; const std::string empty_content_id;
std::string request; std::string request;
EXPECT_EQ( EXPECT_EQ(
@@ -285,8 +287,8 @@ TEST_F(CasEcmTest, InitEmptyContentIdFail) {
.error_code()); .error_code());
} }
TEST_F(CasEcmTest, InitEmptyProviderFail) { TEST_F(EcmTest, InitEmptyProviderFail) {
CasEcm ecm_gen; Ecm ecm_gen;
const std::string empty_provider; const std::string empty_provider;
std::string request; std::string request;
EXPECT_EQ( EXPECT_EQ(
@@ -295,16 +297,16 @@ TEST_F(CasEcmTest, InitEmptyProviderFail) {
.error_code()); .error_code());
} }
TEST_F(CasEcmTest, InitIvSize16x16OK) { TEST_F(EcmTest, InitIvSize16x16OK) {
CasEcm ecm_gen; Ecm ecm_gen;
InitParams(&params_one_key_, kTrackTypeSD, kIvSize16); InitParams(&params_one_key_, kTrackTypeSD, kIvSize16);
std::string request; std::string request;
ASSERT_OK( ASSERT_OK(
ecm_gen.Initialize(content_id_, provider_, params_one_key_, &request)); ecm_gen.Initialize(content_id_, provider_, params_one_key_, &request));
} }
TEST_F(CasEcmTest, GenerateWithNoEntitlementOneKeyFail) { TEST_F(EcmTest, GenerateWithNoEntitlementOneKeyFail) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1; EntitledKeyInfo key1;
InitParams(&params_one_key_, kTrackTypeSD); InitParams(&params_one_key_, kTrackTypeSD);
std::string request; std::string request;
@@ -320,8 +322,8 @@ TEST_F(CasEcmTest, GenerateWithNoEntitlementOneKeyFail) {
.error_code()); .error_code());
} }
TEST_F(CasEcmTest, GenerateWithNoEntitlementTwoKeysFail) { TEST_F(EcmTest, GenerateWithNoEntitlementTwoKeysFail) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1; EntitledKeyInfo key1;
EntitledKeyInfo key2; EntitledKeyInfo key2;
InitParams(&params_two_keys_, kTrackTypeSD); InitParams(&params_two_keys_, kTrackTypeSD);
@@ -338,15 +340,15 @@ TEST_F(CasEcmTest, GenerateWithNoEntitlementTwoKeysFail) {
ecm_gen.GenerateEcm(&key1, &key2, kTrackTypeSD, &ecm, &gen).error_code()); ecm_gen.GenerateEcm(&key1, &key2, kTrackTypeSD, &ecm, &gen).error_code());
} }
TEST_F(CasEcmTest, RequestNullFail) { TEST_F(EcmTest, RequestNullFail) {
CasEcm ecm_gen; Ecm ecm_gen;
EXPECT_EQ(error::INVALID_ARGUMENT, EXPECT_EQ(error::INVALID_ARGUMENT,
ecm_gen.Initialize(content_id_, provider_, params_simple_, nullptr) ecm_gen.Initialize(content_id_, provider_, params_simple_, nullptr)
.error_code()); .error_code());
} }
TEST_F(CasEcmTest, GenerateOneKeyOK) { TEST_F(EcmTest, GenerateOneKeyOK) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1 = valid1_iv_16_8_; EntitledKeyInfo key1 = valid1_iv_16_8_;
InitParams(&params_one_key_, kTrackTypeSD, kIvSize8); InitParams(&params_one_key_, kTrackTypeSD, kIvSize8);
std::string request; std::string request;
@@ -363,8 +365,8 @@ TEST_F(CasEcmTest, GenerateOneKeyOK) {
ASSERT_OK(ecm_gen.GenerateSingleKeyEcm(&key1, kTrackTypeSD, &ecm, &gen)); ASSERT_OK(ecm_gen.GenerateSingleKeyEcm(&key1, kTrackTypeSD, &ecm, &gen));
} }
TEST_F(CasEcmTest, BadResponseFail) { TEST_F(EcmTest, BadResponseFail) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1 = valid1_iv_16_8_; EntitledKeyInfo key1 = valid1_iv_16_8_;
InitParams(&params_one_key_, kTrackTypeSD, kIvSize8); InitParams(&params_one_key_, kTrackTypeSD, kIvSize8);
std::string request; std::string request;
@@ -378,8 +380,8 @@ TEST_F(CasEcmTest, BadResponseFail) {
ecm_gen.ProcessCasEncryptionResponse(response).error_code()); ecm_gen.ProcessCasEncryptionResponse(response).error_code());
} }
TEST_F(CasEcmTest, GenerateTwoKeysOK) { TEST_F(EcmTest, GenerateTwoKeysOK) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1 = valid1_iv_16_8_; EntitledKeyInfo key1 = valid1_iv_16_8_;
EntitledKeyInfo key2 = valid2_iv_16_8_; EntitledKeyInfo key2 = valid2_iv_16_8_;
InitParams(&params_two_keys_, kTrackTypeSD, kIvSize8); InitParams(&params_two_keys_, kTrackTypeSD, kIvSize8);
@@ -397,8 +399,8 @@ TEST_F(CasEcmTest, GenerateTwoKeysOK) {
ASSERT_OK(ecm_gen.GenerateEcm(&key1, &key2, kTrackTypeSD, &ecm, &gen)); ASSERT_OK(ecm_gen.GenerateEcm(&key1, &key2, kTrackTypeSD, &ecm, &gen));
} }
TEST_F(CasEcmTest, GenerateOneKeyNoGenFail) { TEST_F(EcmTest, GenerateOneKeyNoGenFail) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1 = valid1_iv_16_8_; EntitledKeyInfo key1 = valid1_iv_16_8_;
InitParams(&params_one_key_, kTrackTypeSD, kIvSize8); InitParams(&params_one_key_, kTrackTypeSD, kIvSize8);
std::string request; std::string request;
@@ -416,8 +418,8 @@ TEST_F(CasEcmTest, GenerateOneKeyNoGenFail) {
.error_code()); .error_code());
} }
TEST_F(CasEcmTest, GenerateOneKeyBadKeyIdFail) { TEST_F(EcmTest, GenerateOneKeyBadKeyIdFail) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1 = invalid1_key_id_iv_16_8_; EntitledKeyInfo key1 = invalid1_key_id_iv_16_8_;
InitParams(&params_one_key_, kTrackTypeSD, kIvSize8); InitParams(&params_one_key_, kTrackTypeSD, kIvSize8);
std::string request; std::string request;
@@ -436,8 +438,8 @@ TEST_F(CasEcmTest, GenerateOneKeyBadKeyIdFail) {
.error_code()); .error_code());
} }
TEST_F(CasEcmTest, GenerateOneKeyWrong) { TEST_F(EcmTest, GenerateOneKeyWrong) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1 = valid1_iv_16_8_; EntitledKeyInfo key1 = valid1_iv_16_8_;
InitParams(&params_one_key_, kTrackTypeSD, kIvSize8); InitParams(&params_one_key_, kTrackTypeSD, kIvSize8);
std::string request; std::string request;
@@ -459,8 +461,8 @@ TEST_F(CasEcmTest, GenerateOneKeyWrong) {
ecm_gen.GenerateEcm(&key1, &key1, kTrackTypeSD, &ecm, &gen).error_code()); ecm_gen.GenerateEcm(&key1, &key1, kTrackTypeSD, &ecm, &gen).error_code());
} }
TEST_F(CasEcmTest, GenerateTwoKeysIvSizeFail) { TEST_F(EcmTest, GenerateTwoKeysIvSizeFail) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1 = valid1_iv_16_8_; EntitledKeyInfo key1 = valid1_iv_16_8_;
EntitledKeyInfo key2 = valid2_iv_16_8_; EntitledKeyInfo key2 = valid2_iv_16_8_;
// IV size mismatch. // IV size mismatch.
@@ -481,8 +483,8 @@ TEST_F(CasEcmTest, GenerateTwoKeysIvSizeFail) {
ecm_gen.GenerateEcm(&key1, &key2, kTrackTypeSD, &ecm, &gen).error_code()); ecm_gen.GenerateEcm(&key1, &key2, kTrackTypeSD, &ecm, &gen).error_code());
} }
TEST_F(CasEcmTest, GenerateTwoKeysIvSize16x8OK) { TEST_F(EcmTest, GenerateTwoKeysIvSize16x8OK) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1 = valid1_iv_16_8_; EntitledKeyInfo key1 = valid1_iv_16_8_;
EntitledKeyInfo key2 = valid2_iv_16_8_; EntitledKeyInfo key2 = valid2_iv_16_8_;
InitParams(&params_two_keys_, kTrackTypeSD, kIvSize8); InitParams(&params_two_keys_, kTrackTypeSD, kIvSize8);
@@ -505,8 +507,8 @@ TEST_F(CasEcmTest, GenerateTwoKeysIvSize16x8OK) {
EXPECT_THAT(149, ecm.size()); EXPECT_THAT(149, ecm.size());
} }
TEST_F(CasEcmTest, GenerateTwoKeysIvSize16x16OK) { TEST_F(EcmTest, GenerateTwoKeysIvSize16x16OK) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1 = valid3_iv_16_16_; EntitledKeyInfo key1 = valid3_iv_16_16_;
EntitledKeyInfo key2 = valid4_iv_16_16_; EntitledKeyInfo key2 = valid4_iv_16_16_;
InitParams(&params_two_keys_, kTrackTypeSD, kIvSize16); InitParams(&params_two_keys_, kTrackTypeSD, kIvSize16);
@@ -530,8 +532,8 @@ TEST_F(CasEcmTest, GenerateTwoKeysIvSize16x16OK) {
EXPECT_THAT(165, ecm.size()); EXPECT_THAT(165, ecm.size());
} }
TEST_F(CasEcmTest, GenerateThreeKeysIvSize16x16Fail) { TEST_F(EcmTest, GenerateThreeKeysIvSize16x16Fail) {
CasEcm ecm_gen; Ecm ecm_gen;
EntitledKeyInfo key1 = valid3_iv_16_16_; EntitledKeyInfo key1 = valid3_iv_16_16_;
EntitledKeyInfo key2 = valid4_iv_16_16_; EntitledKeyInfo key2 = valid4_iv_16_16_;
InitParams(&params_two_keys_, kTrackTypeSD, kIvSize16); InitParams(&params_two_keys_, kTrackTypeSD, kIvSize16);
@@ -553,8 +555,8 @@ TEST_F(CasEcmTest, GenerateThreeKeysIvSize16x16Fail) {
} }
// TODO(user): Add more unit tests for error paths around SerializeEcm. // TODO(user): Add more unit tests for error paths around SerializeEcm.
TEST_F(CasEcmSerializeEcmTest, SerializeEcmDoubleKey16ByteIvs) { TEST_F(EcmSerializeEcmTest, SerializeEcmDoubleKey16ByteIvs) {
MockCasEcm ecm_gen; MockEcm ecm_gen;
EntitledKeyInfo key1 = valid3_iv_16_16_; EntitledKeyInfo key1 = valid3_iv_16_16_;
EntitledKeyInfo key2 = valid4_iv_16_16_; EntitledKeyInfo key2 = valid4_iv_16_16_;
@@ -576,8 +578,8 @@ TEST_F(CasEcmSerializeEcmTest, SerializeEcmDoubleKey16ByteIvs) {
ValidateEcmFieldsTwoKeys(buf_string, 1, CryptoMode::kAesCtr, kIvSize16); ValidateEcmFieldsTwoKeys(buf_string, 1, CryptoMode::kAesCtr, kIvSize16);
} }
TEST_F(CasEcmSerializeEcmTest, SerializeEcmSingleKey16ByteIvs) { TEST_F(EcmSerializeEcmTest, SerializeEcmSingleKey16ByteIvs) {
MockCasEcm ecm_gen; MockEcm ecm_gen;
EntitledKeyInfo key1 = valid3_iv_16_16_; EntitledKeyInfo key1 = valid3_iv_16_16_;
ecm_gen.MockSetup(false, kTrackTypeSD, 0, CryptoMode::kAesCtr, 16); ecm_gen.MockSetup(false, kTrackTypeSD, 0, CryptoMode::kAesCtr, 16);
@@ -597,8 +599,8 @@ TEST_F(CasEcmSerializeEcmTest, SerializeEcmSingleKey16ByteIvs) {
ValidateEcmFieldsOneKey(buf_string, 1, CryptoMode::kAesCtr, kIvSize16); ValidateEcmFieldsOneKey(buf_string, 1, CryptoMode::kAesCtr, kIvSize16);
} }
TEST_F(CasEcmSerializeEcmTest, SerializeEcmDoubleKey16x8ByteIvs) { TEST_F(EcmSerializeEcmTest, SerializeEcmDoubleKey16x8ByteIvs) {
MockCasEcm ecm_gen; MockEcm ecm_gen;
EntitledKeyInfo key1 = valid1_iv_16_8_; EntitledKeyInfo key1 = valid1_iv_16_8_;
EntitledKeyInfo key2 = valid2_iv_16_8_; EntitledKeyInfo key2 = valid2_iv_16_8_;
@@ -620,8 +622,8 @@ TEST_F(CasEcmSerializeEcmTest, SerializeEcmDoubleKey16x8ByteIvs) {
ValidateEcmFieldsTwoKeys(buf_string, 1, CryptoMode::kAesCtr, kIvSize8); ValidateEcmFieldsTwoKeys(buf_string, 1, CryptoMode::kAesCtr, kIvSize8);
} }
TEST_F(CasEcmSerializeEcmTest, SerializeEcmSingleKey16x8ByteIvs) { TEST_F(EcmSerializeEcmTest, SerializeEcmSingleKey16x8ByteIvs) {
MockCasEcm ecm_gen; MockEcm ecm_gen;
EntitledKeyInfo key1 = valid1_iv_16_8_; EntitledKeyInfo key1 = valid1_iv_16_8_;
ecm_gen.MockSetup(false, kTrackTypeSD, 0, CryptoMode::kAesCtr, 8); ecm_gen.MockSetup(false, kTrackTypeSD, 0, CryptoMode::kAesCtr, 8);

12
media_cas_packager_sdk/internal/ecmg_client_handler.cc
View File

@@ -500,11 +500,11 @@ void EcmgClientHandler::BuildEcmDatagram(const EcmgParameters& params,
// Step 1: Generate entitlement keys. // Step 1: Generate entitlement keys.
bool key_rotation_enabled = params.cw_per_msg > 1; bool key_rotation_enabled = params.cw_per_msg > 1;
// Create an instance of CasEcm in order to set the entitlement keys. // Create an instance of Ecm in order to set the entitlement keys.
// TODO(user): The section of code below for constructing CasEcm should // TODO(user): The section of code below for constructing Ecm should
// be optimized. There should be a single instance of CasEcm for each stream. // be optimized. There should be a single instance of Ecm for each stream.
// Right now, this is hard to do because CasEcmGenerator contains the CasEcm. // Right now, this is hard to do because EcmGenerator contains the Ecm.
std::unique_ptr<CasEcm> ecm = absl::make_unique<CasEcm>(); std::unique_ptr<Ecm> ecm = absl::make_unique<Ecm>();
// TODO(user): Revisit this hardcoded ecm_init_params. // TODO(user): Revisit this hardcoded ecm_init_params.
EcmInitParameters ecm_init_params; EcmInitParameters ecm_init_params;
ecm_init_params.content_iv_size = kIvSize8; ecm_init_params.content_iv_size = kIvSize8;
@@ -543,7 +543,7 @@ void EcmgClientHandler::BuildEcmDatagram(const EcmgParameters& params,
} }
// Step 2: Generate serialized ECM. // Step 2: Generate serialized ECM.
CasEcmGenerator ecm_generator; EcmGenerator ecm_generator;
ecm_generator.set_ecm(std::move(ecm)); ecm_generator.set_ecm(std::move(ecm));
EcmParameters ecm_param; EcmParameters ecm_param;
ecm_param.rotation_enabled = key_rotation_enabled; ecm_param.rotation_enabled = key_rotation_enabled;

12
media_cas_packager_sdk/public/wv_cas_ecm.cc
View File

@@ -142,8 +142,8 @@ WvCasStatus WvCasEcm::GenerateEcm(
return INVALID_ARGUMENT; return INVALID_ARGUMENT;
} }
// Create an instance of CasEcm in order to set the entitlement keys. // Create an instance of Ecm in order to set the entitlement keys.
std::unique_ptr<CasEcm> cas_ecm = absl::make_unique<CasEcm>(); std::unique_ptr<Ecm> cas_ecm = absl::make_unique<Ecm>();
std::string entitlement_request; std::string entitlement_request;
std::string entitlement_response; std::string entitlement_response;
EcmInitParameters ecm_init_params = CreateEcmInitParameters( EcmInitParameters ecm_init_params = CreateEcmInitParameters(
@@ -179,7 +179,7 @@ WvCasStatus WvCasEcm::GenerateEcm(
} }
// Generate ECM. // Generate ECM.
CasEcmGenerator ecm_generator; EcmGenerator ecm_generator;
ecm_generator.set_ecm(std::move(cas_ecm)); ecm_generator.set_ecm(std::move(cas_ecm));
EcmParameters ecm_param; EcmParameters ecm_param;
ecm_param.rotation_enabled = key_rotation_enabled_; ecm_param.rotation_enabled = key_rotation_enabled_;
@@ -253,8 +253,8 @@ WvCasStatus WvCasEcm::GenerateSingleKeyEcm(
return INVALID_ARGUMENT; return INVALID_ARGUMENT;
} }
// Create an instance of CasEcm in order to set the entitlement keys. // Create an instance of Ecm in order to set the entitlement keys.
std::unique_ptr<CasEcm> cas_ecm = absl::make_unique<CasEcm>(); std::unique_ptr<Ecm> cas_ecm = absl::make_unique<Ecm>();
std::string entitlement_request; std::string entitlement_request;
std::string entitlement_response; std::string entitlement_response;
EcmInitParameters ecm_init_params = CreateEcmInitParameters( EcmInitParameters ecm_init_params = CreateEcmInitParameters(
@@ -290,7 +290,7 @@ WvCasStatus WvCasEcm::GenerateSingleKeyEcm(
} }
// Generate ECM. // Generate ECM.
CasEcmGenerator ecm_generator; EcmGenerator ecm_generator;
ecm_generator.set_ecm(std::move(cas_ecm)); ecm_generator.set_ecm(std::move(cas_ecm));
EcmParameters ecm_param; EcmParameters ecm_param;
ecm_param.rotation_enabled = key_rotation_enabled_; ecm_param.rotation_enabled = key_rotation_enabled_;