From f23c6a17603d43d0191ace1d919a43e6614195aa Mon Sep 17 00:00:00 2001 From: Fang Yu Date: Fri, 25 Jan 2019 10:48:48 -0800 Subject: [PATCH] Rename CasEcm and CasEcmGenerator classes to Ecm and EcmGenerator. ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=230929673 --- WORKSPACE | 2 +- media_cas_packager_sdk/internal/BUILD | 1 - media_cas_packager_sdk/internal/ecm.cc | 72 +++++------ media_cas_packager_sdk/internal/ecm.h | 17 ++- .../internal/ecm_generator.cc | 20 +-- .../internal/ecm_generator.h | 18 ++- .../internal/ecm_generator_test.cc | 20 +-- media_cas_packager_sdk/internal/ecm_test.cc | 116 +++++++++--------- .../internal/ecmg_client_handler.cc | 12 +- media_cas_packager_sdk/public/wv_cas_ecm.cc | 12 +- 10 files changed, 141 insertions(+), 149 deletions(-) diff --git a/WORKSPACE b/WORKSPACE index 75f3c51..1dfdd67 100644 --- a/WORKSPACE +++ b/WORKSPACE @@ -34,7 +34,7 @@ git_repository( git_repository( name = "googletest_repo", - commit = "9816b96a6ddc0430671693df90192bbee57108b6", # 2017-08-11 + commit = "b6cd405286ed8635ece71c72f118e659f4ade3fb", # 2019-01-04 remote = "https://github.com/google/googletest.git", ) diff --git a/media_cas_packager_sdk/internal/BUILD b/media_cas_packager_sdk/internal/BUILD index 1960c90..9ee1a9a 100644 --- a/media_cas_packager_sdk/internal/BUILD +++ b/media_cas_packager_sdk/internal/BUILD @@ -29,7 +29,6 @@ cc_library( "@abseil_repo//absl/base:core_headers", "@abseil_repo//absl/strings", "//common:aes_cbc_util", - "//common:random_util", "//common:status", "//common:string_util", "//media_cas_packager_sdk/public:wv_cas_types", diff --git a/media_cas_packager_sdk/internal/ecm.cc b/media_cas_packager_sdk/internal/ecm.cc index 2d928d3..50b910f 100644 --- a/media_cas_packager_sdk/internal/ecm.cc +++ b/media_cas_packager_sdk/internal/ecm.cc @@ -15,7 +15,6 @@ #include "glog/logging.h" #include "absl/strings/str_cat.h" #include "common/aes_cbc_util.h" -#include "common/random_util.h" #include "common/status.h" #include "common/string_util.h" #include "protos/public/media_cas_encryption.pb.h" @@ -112,10 +111,10 @@ bool ConvertIvSizeParam(EcmIvSize param, size_t* size) { } // namespace -Status CasEcm::Initialize(const std::string& content_id, - const std::string& content_provider, - const EcmInitParameters& ecm_init_parameters, - std::string* key_request_message) { +Status Ecm::Initialize(const std::string& content_id, + const std::string& content_provider, + const EcmInitParameters& ecm_init_parameters, + std::string* key_request_message) { if (initialized_) { return {error::INTERNAL, "Already initialized."}; } @@ -163,7 +162,7 @@ Status CasEcm::Initialize(const std::string& content_id, return OkStatus(); } -Status CasEcm::ProcessCasEncryptionResponse(const std::string& response) { +Status Ecm::ProcessCasEncryptionResponse(const std::string& response) { if (!initialized_) { return {error::INTERNAL, "Not initialized."}; } @@ -173,9 +172,9 @@ Status CasEcm::ProcessCasEncryptionResponse(const std::string& response) { return ParseEntitlementResponse(response); } -Status CasEcm::GenerateEcm(EntitledKeyInfo* even_key, EntitledKeyInfo* odd_key, - const std::string& track_type, std::string* serialized_ecm, - uint32_t* generation) { +Status Ecm::GenerateEcm(EntitledKeyInfo* even_key, EntitledKeyInfo* odd_key, + const std::string& track_type, std::string* serialized_ecm, + uint32_t* generation) { if (!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); } -Status CasEcm::GenerateSingleKeyEcm(EntitledKeyInfo* key, - const std::string& track_type, - std::string* serialized_ecm, - uint32_t* generation) { +Status Ecm::GenerateSingleKeyEcm(EntitledKeyInfo* key, const std::string& track_type, + std::string* serialized_ecm, uint32_t* generation) { if (!initialized_) { return {error::INTERNAL, "Not initialized."}; } @@ -215,9 +212,9 @@ Status CasEcm::GenerateSingleKeyEcm(EntitledKeyInfo* key, return GenerateEcmCommon(keys, track_type, serialized_ecm, generation); } -Status CasEcm::GenerateEcmCommon(const std::vector& keys, - const std::string& track_type, - std::string* serialized_ecm, uint32_t* generation) { +Status Ecm::GenerateEcmCommon(const std::vector& keys, + const std::string& track_type, std::string* serialized_ecm, + uint32_t* generation) { if (serialized_ecm == nullptr) { return {error::INVALID_ARGUMENT, "No return ecm std::string pointer."}; } @@ -260,12 +257,12 @@ Status CasEcm::GenerateEcmCommon(const std::vector& keys, return OkStatus(); } -void CasEcm::IncrementGeneration() { +void Ecm::IncrementGeneration() { generation_ = (generation_ >= kMaxGeneration) ? 0 : generation_ + 1; } -Status CasEcm::WrapEntitledKeys(const std::string& track_type, - const std::vector keys) { +Status Ecm::WrapEntitledKeys(const std::string& track_type, + const std::vector keys) { if (!initialized_) { return {error::INTERNAL, "Not initialized."}; } @@ -287,13 +284,7 @@ Status CasEcm::WrapEntitledKeys(const std::string& track_type, auto entitlement_key = ekey_list.begin(); for (auto entitled_key : keys) { entitled_key->entitlement_key_id = entitlement_key->key_id; - // Wrap key using entitlement key. First generate new IV. - // 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)); - } + // Wrap key using entitlement key. Status status = WrapKey(entitlement_key->key_value, entitled_key->wrapped_key_iv, entitled_key->key_value, &entitled_key->wrapped_key_value); @@ -305,8 +296,8 @@ Status CasEcm::WrapEntitledKeys(const std::string& track_type, return OkStatus(); } -Status CasEcm::WrapKey(const std::string& wrapping_key, const std::string& wrapping_iv, - const std::string& key_value, std::string* wrapped_key) { +Status Ecm::WrapKey(const std::string& wrapping_key, const std::string& wrapping_iv, + const std::string& key_value, std::string* wrapped_key) { Status status = ValidateKeyValue(wrapping_key, kWrappingKeySizeBytes); if (!status.ok()) { return status; @@ -328,7 +319,7 @@ Status CasEcm::WrapKey(const std::string& wrapping_key, const std::string& wrapp return OkStatus(); } -Status CasEcm::ValidateKeys(const std::vector& keys) { +Status Ecm::ValidateKeys(const std::vector& keys) { for (const auto& key : keys) { Status status; status = ValidateKeyId(key->key_id); @@ -343,11 +334,15 @@ Status CasEcm::ValidateKeys(const std::vector& keys) { if (!status.ok()) { return status; } + status = ValidateIv(key->wrapped_key_iv, kWrappedKeyIvSizeBytes); + if (!status.ok()) { + return status; + } } return OkStatus(); } -Status CasEcm::ValidateWrappedKeys(const std::vector& keys) { +Status Ecm::ValidateWrappedKeys(const std::vector& keys) { for (const auto& key : keys) { Status status; status = ValidateKeyId(key->key_id); @@ -371,15 +366,14 @@ Status CasEcm::ValidateWrappedKeys(const std::vector& keys) { return OkStatus(); } -Status CasEcm::ValidateKeyId(const std::string& key_id) { +Status Ecm::ValidateKeyId(const std::string& key_id) { if (key_id.size() != kKeyIdSizeBytes) { return {error::INVALID_ARGUMENT, "Key ID must be 16 bytes."}; } return OkStatus(); } -Status CasEcm::ValidateKeyValue(const std::string& key_value, - size_t key_value_size) { +Status Ecm::ValidateKeyValue(const std::string& key_value, size_t key_value_size) { if (key_value.size() != key_value_size) { return Status( error::INVALID_ARGUMENT, @@ -388,14 +382,14 @@ Status CasEcm::ValidateKeyValue(const std::string& key_value, 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) { return {error::INVALID_ARGUMENT, "IV is wrong size."}; } return OkStatus(); } -std::string CasEcm::SerializeEcm(const std::vector& keys) { +std::string Ecm::SerializeEcm(const std::vector& keys) { // Five bytes (40 bits including padding) std::bitset ca_system_id(kWvCasCaSystemId); std::bitset ecm_version(kEcmVersion); @@ -435,7 +429,7 @@ std::string CasEcm::SerializeEcm(const std::vector& keys) { return serialized_ecm; } -Status CasEcm::CreateEntitlementRequest(std::string* request_string) { +Status Ecm::CreateEntitlementRequest(std::string* request_string) { CasEncryptionRequest request; request.set_content_id(content_id_); @@ -453,7 +447,7 @@ Status CasEcm::CreateEntitlementRequest(std::string* request_string) { 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. ClearEntitlementKeys(); @@ -532,7 +526,7 @@ Status CasEcm::ParseEntitlementResponse(const std::string& response_string) { return OkStatus(); } -size_t CasEcm::CountEntitlementKeys() const { +size_t Ecm::CountEntitlementKeys() const { size_t count = 0; for (const auto& track : entitlement_keys_) { count += track.second.size(); @@ -540,7 +534,7 @@ size_t CasEcm::CountEntitlementKeys() const { return count; } -bool CasEcm::CheckEntitlementKeys() const { +bool Ecm::CheckEntitlementKeys() const { // TODO(user): Cross-check entitlement_keys_ track types with track_types_. if (track_types_.size() > CountEntitlementTracks()) { // One or more tracks are missing. diff --git a/media_cas_packager_sdk/internal/ecm.h b/media_cas_packager_sdk/internal/ecm.h index 8bb27cf..aadd25d 100644 --- a/media_cas_packager_sdk/internal/ecm.h +++ b/media_cas_packager_sdk/internal/ecm.h @@ -9,7 +9,7 @@ #ifndef MEDIA_CAS_PACKAGER_SDK_INTERNAL_ECM_H_ #define MEDIA_CAS_PACKAGER_SDK_INTERNAL_ECM_H_ -#include +#include #include #include #include @@ -47,7 +47,7 @@ enum EcmIvSize { kIvSize8 = 0, kIvSize16 = 1 }; // Information needed to start a new ECM stream. // Fields: // |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. // |crypto_mode| the encryption mode used for the content stream. // A constant of type CryptoMode. @@ -71,14 +71,13 @@ struct EcmInitParameters { // // TODO(user): Add usage example. // -// Class CasEcm is not thread safe. -// TODO(user): Rename class to Ecm. -class CasEcm { +// Class Ecm is not thread safe. +class Ecm { public: - CasEcm() = default; - CasEcm(const CasEcm&) = delete; - CasEcm& operator=(const CasEcm&) = delete; - virtual ~CasEcm() = default; + Ecm() = default; + Ecm(const Ecm&) = delete; + Ecm& operator=(const Ecm&) = delete; + virtual ~Ecm() = default; // Perform initialization for a new ECM stream. // Args: diff --git a/media_cas_packager_sdk/internal/ecm_generator.cc b/media_cas_packager_sdk/internal/ecm_generator.cc index 7bbe11c..c22708f 100644 --- a/media_cas_packager_sdk/internal/ecm_generator.cc +++ b/media_cas_packager_sdk/internal/ecm_generator.cc @@ -18,7 +18,7 @@ static constexpr int kKeyIvSize8 = 8; static constexpr int kKeyIvSize16 = 16; static constexpr int kMaxBytesKeyIdField = 16; -std::string CasEcmGenerator::GenerateEcm(const EcmParameters& params) { +std::string EcmGenerator::GenerateEcm(const EcmParameters& params) { std::vector keys; Status status = ProcessEcmParameters(params, &keys); if (!status.ok() || !initialized_) { @@ -37,14 +37,14 @@ std::string CasEcmGenerator::GenerateEcm(const EcmParameters& params) { &generation); } if (!status.ok()) { - LOG(ERROR) << " Call to CasEcm's ECM Generator failed: " << status; + LOG(ERROR) << " Generate ECM call failed: " << status; return ""; } return serialized_ecm; } -Status CasEcmGenerator::ProcessEcmParameters( - const EcmParameters& ecm_params, std::vector* keys) { +Status EcmGenerator::ProcessEcmParameters(const EcmParameters& ecm_params, + std::vector* keys) { initialized_ = false; rotation_enabled_ = ecm_params.rotation_enabled; @@ -73,7 +73,7 @@ Status CasEcmGenerator::ProcessEcmParameters( return OkStatus(); } -Status CasEcmGenerator::ValidateKeyId(const std::string& id) { +Status EcmGenerator::ValidateKeyId(const std::string& id) { if (id.empty()) { return {error::INVALID_ARGUMENT, "Key id is empty."}; } @@ -83,7 +83,7 @@ Status CasEcmGenerator::ValidateKeyId(const std::string& id) { return OkStatus(); } -Status CasEcmGenerator::ValidateKeyData(const std::string& key_data) { +Status EcmGenerator::ValidateKeyData(const std::string& key_data) { if (key_data.empty()) { return {error::INVALID_ARGUMENT, "Key data is empty."}; } @@ -93,7 +93,7 @@ Status CasEcmGenerator::ValidateKeyData(const std::string& key_data) { 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()) { return {error::INVALID_ARGUMENT, "IV is empty."}; } @@ -107,7 +107,7 @@ Status CasEcmGenerator::ValidateIv(const std::string& iv, size_t required_size) return OkStatus(); } -Status CasEcmGenerator::ValidateWrappedKeyIv(const std::string& iv) { +Status EcmGenerator::ValidateWrappedKeyIv(const std::string& iv) { // All wrapped key IVs must be 16 bytes. Status status = ValidateIv(iv, kIvSize16); if (!status.ok()) { @@ -116,7 +116,7 @@ Status CasEcmGenerator::ValidateWrappedKeyIv(const std::string& iv) { 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 // this stream. if (content_iv_size_ == 0) { @@ -129,7 +129,7 @@ Status CasEcmGenerator::ValidateContentIv(const std::string& iv) { return status; } -Status CasEcmGenerator::ValidateKeyParameters(const KeyParameters& key_params) { +Status EcmGenerator::ValidateKeyParameters(const KeyParameters& key_params) { Status status; status = ValidateKeyId(key_params.key_id); if (!status.ok()) return status; diff --git a/media_cas_packager_sdk/internal/ecm_generator.h b/media_cas_packager_sdk/internal/ecm_generator.h index 9b24057..91a60e3 100644 --- a/media_cas_packager_sdk/internal/ecm_generator.h +++ b/media_cas_packager_sdk/internal/ecm_generator.h @@ -40,7 +40,6 @@ struct KeyParameters { // EcmParameters holds information that is needed by the EcmGenerator. It is // partially set up with data from a KeyGenerator (obtained via GenerateKey()). // IVs are added later. -// TODO(user): Consider rename to EcmGeneratorParameters. struct EcmParameters { // TODO(user): entitlement_key_id does not seem to be used, but assumed // to exist by unit tests. @@ -55,13 +54,12 @@ struct EcmParameters { }; // ECM Generator for Widevine/MediaCAS entitled keys. -// TODO(user): Rename class to EcmGenerator. -class CasEcmGenerator { +class EcmGenerator { public: - CasEcmGenerator() = default; - CasEcmGenerator(const CasEcmGenerator&) = delete; - CasEcmGenerator& operator=(const CasEcmGenerator&) = delete; - virtual ~CasEcmGenerator() = default; + EcmGenerator() = default; + EcmGenerator(const EcmGenerator&) = delete; + EcmGenerator& operator=(const EcmGenerator&) = delete; + virtual ~EcmGenerator() = default; virtual std::string GenerateEcm(const EcmParameters& params); @@ -69,10 +67,10 @@ class CasEcmGenerator { bool initialized() { return initialized_; } bool rotation_enabled() { return rotation_enabled_; } - void set_ecm(std::unique_ptr ecm) { ecm_ = std::move(ecm); } + void set_ecm(std::unique_ptr ecm) { ecm_ = std::move(ecm); } private: - friend class CasEcmGeneratorTest; + friend class EcmGeneratorTest; Status ProcessEcmParameters(const EcmParameters& ecm_params, std::vector* keys); @@ -91,7 +89,7 @@ class CasEcmGenerator { uint32_t current_key_index_ = 0; bool current_key_even_ = true; uint32_t content_iv_size_ = 0; - std::unique_ptr ecm_; + std::unique_ptr ecm_; }; } // namespace cas diff --git a/media_cas_packager_sdk/internal/ecm_generator_test.cc b/media_cas_packager_sdk/internal/ecm_generator_test.cc index a8d8dd4..0c999e4 100644 --- a/media_cas_packager_sdk/internal/ecm_generator_test.cc +++ b/media_cas_packager_sdk/internal/ecm_generator_test.cc @@ -94,7 +94,7 @@ Status HandleCasEncryptionRequest(const std::string& request_string, } // namespace -class CasEcmGeneratorTest : public testing::Test { +class EcmGeneratorTest : public testing::Test { protected: void SetUp() override { } @@ -124,9 +124,9 @@ class CasEcmGeneratorTest : public testing::Test { 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) { - ecm_ = absl::make_unique(); + ecm_ = absl::make_unique(); std::string entitlement_request; std::string entitlement_response; ecm_init_params_.key_rotation_enabled = key_rotation_enabled; @@ -155,12 +155,12 @@ class CasEcmGeneratorTest : public testing::Test { kEcmWrappedKeyIvOdd, {kEcmContentIvOdd}}; - std::unique_ptr ecm_; + std::unique_ptr ecm_; EcmInitParameters ecm_init_params_; - CasEcmGenerator ecm_gen_; + EcmGenerator ecm_gen_; }; -TEST_F(CasEcmGeneratorTest, InitializeNoRotation) { +TEST_F(EcmGeneratorTest, InitializeNoRotation) { EXPECT_FALSE(ecm_gen_.initialized()); PrepareEcmGenerator(false); @@ -178,7 +178,7 @@ TEST_F(CasEcmGeneratorTest, InitializeNoRotation) { EXPECT_FALSE(ecm_gen_.rotation_enabled()); } -TEST_F(CasEcmGeneratorTest, GenerateNoRotation) { +TEST_F(EcmGeneratorTest, GenerateNoRotation) { PrepareEcmGenerator(false); EcmParameters ecm_params; @@ -214,7 +214,7 @@ TEST_F(CasEcmGeneratorTest, GenerateNoRotation) { EXPECT_EQ(kEcmContentIvSingle, ecm_string.substr(69, 8)); } -TEST_F(CasEcmGeneratorTest, Generate2NoRotation) { +TEST_F(EcmGeneratorTest, Generate2NoRotation) { PrepareEcmGenerator(false); EcmParameters ecm_params; @@ -244,7 +244,7 @@ TEST_F(CasEcmGeneratorTest, Generate2NoRotation) { EXPECT_EQ(kEcmContentIvSingle, ecm_string.substr(69, 8)); } -TEST_F(CasEcmGeneratorTest, InitializeSimpleRotation) { +TEST_F(EcmGeneratorTest, InitializeSimpleRotation) { EXPECT_FALSE(ecm_gen_.initialized()); EcmParameters ecm_params; std::vector keys; @@ -261,7 +261,7 @@ TEST_F(CasEcmGeneratorTest, InitializeSimpleRotation) { EXPECT_TRUE(ecm_gen_.rotation_enabled()); } -TEST_F(CasEcmGeneratorTest, GenerateSimpleRotation) { +TEST_F(EcmGeneratorTest, GenerateSimpleRotation) { EcmParameters ecm_params; PrepareEcmGenerator(true); diff --git a/media_cas_packager_sdk/internal/ecm_test.cc b/media_cas_packager_sdk/internal/ecm_test.cc index 86585b7..712a5f7 100644 --- a/media_cas_packager_sdk/internal/ecm_test.cc +++ b/media_cas_packager_sdk/internal/ecm_test.cc @@ -31,6 +31,7 @@ constexpr char kTrackTypeSD[] = "SD"; constexpr char kTrackTypeHD[] = "HD"; constexpr char kTrackTypeAUDIO[] = "AUDIO"; constexpr char kTrackTypeBAD[] = "BAD"; +constexpr char kWrappedKeyIv[] = "wrapped_key_iv.."; constexpr size_t kEcmHeaderSize = 5; constexpr size_t kEcmKeyIdSize = 16; @@ -50,14 +51,15 @@ void InitEntitledKey(EntitledKeyInfo* key, const std::string& id, key->key_id = id; key->key_value = value; key->content_iv = iv; + key->wrapped_key_iv = kWrappedKeyIv; } } // namespace -class MockCasEcm : public CasEcm { +class MockEcm : public Ecm { public: - MockCasEcm() = default; - ~MockCasEcm() override = default; + MockEcm() = default; + ~MockEcm() override = default; MOCK_CONST_METHOD0(generation, uint32_t()); 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: void SetUp() override { 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_; }; -class CasEcmSerializeEcmTest : public CasEcmTest { +class EcmSerializeEcmTest : public EcmTest { public: void ValidateEcmHeaderFields(const std::string& ecm_string, bool rotation_enabled, int gen, CryptoMode crypto_mode, @@ -221,8 +223,8 @@ class CasEcmSerializeEcmTest : public CasEcmTest { } }; -TEST_F(CasEcmTest, GenerateEcmNotInitialized) { - CasEcm ecm_gen; +TEST_F(EcmTest, GenerateEcmNotInitialized) { + Ecm ecm_gen; EntitledKeyInfo key1; std::string ecm_data; uint32_t gen; @@ -231,8 +233,8 @@ TEST_F(CasEcmTest, GenerateEcmNotInitialized) { .error_code()); } -TEST_F(CasEcmTest, GenerateEcm2NotInitialized) { - CasEcm ecm_gen; +TEST_F(EcmTest, GenerateEcm2NotInitialized) { + Ecm ecm_gen; EntitledKeyInfo key1; EntitledKeyInfo key2; std::string ecm_data; @@ -242,15 +244,15 @@ TEST_F(CasEcmTest, GenerateEcm2NotInitialized) { .error_code()); } -TEST_F(CasEcmTest, SetResponseNotInitialized) { - CasEcm ecm_gen; +TEST_F(EcmTest, SetResponseNotInitialized) { + Ecm ecm_gen; const std::string response("anything"); EXPECT_EQ(error::INTERNAL, ecm_gen.ProcessCasEncryptionResponse(response).error_code()); } -TEST_F(CasEcmTest, InitNoTracksFail) { - CasEcm ecm_gen; +TEST_F(EcmTest, InitNoTracksFail) { + Ecm ecm_gen; std::string request; EXPECT_EQ( error::INVALID_ARGUMENT, @@ -258,15 +260,15 @@ TEST_F(CasEcmTest, InitNoTracksFail) { .error_code()); } -TEST_F(CasEcmTest, InitSucceed) { - CasEcm ecm_gen; +TEST_F(EcmTest, InitSucceed) { + Ecm ecm_gen; std::string request; ASSERT_OK( ecm_gen.Initialize(content_id_, provider_, params_simple_, &request)); } -TEST_F(CasEcmTest, SecondInitFail) { - CasEcm ecm_gen; +TEST_F(EcmTest, SecondInitFail) { + Ecm ecm_gen; std::string request; ASSERT_OK( ecm_gen.Initialize(content_id_, provider_, params_simple_, &request)); @@ -275,8 +277,8 @@ TEST_F(CasEcmTest, SecondInitFail) { .error_code()); } -TEST_F(CasEcmTest, InitEmptyContentIdFail) { - CasEcm ecm_gen; +TEST_F(EcmTest, InitEmptyContentIdFail) { + Ecm ecm_gen; const std::string empty_content_id; std::string request; EXPECT_EQ( @@ -285,8 +287,8 @@ TEST_F(CasEcmTest, InitEmptyContentIdFail) { .error_code()); } -TEST_F(CasEcmTest, InitEmptyProviderFail) { - CasEcm ecm_gen; +TEST_F(EcmTest, InitEmptyProviderFail) { + Ecm ecm_gen; const std::string empty_provider; std::string request; EXPECT_EQ( @@ -295,16 +297,16 @@ TEST_F(CasEcmTest, InitEmptyProviderFail) { .error_code()); } -TEST_F(CasEcmTest, InitIvSize16x16OK) { - CasEcm ecm_gen; +TEST_F(EcmTest, InitIvSize16x16OK) { + Ecm ecm_gen; InitParams(¶ms_one_key_, kTrackTypeSD, kIvSize16); std::string request; ASSERT_OK( ecm_gen.Initialize(content_id_, provider_, params_one_key_, &request)); } -TEST_F(CasEcmTest, GenerateWithNoEntitlementOneKeyFail) { - CasEcm ecm_gen; +TEST_F(EcmTest, GenerateWithNoEntitlementOneKeyFail) { + Ecm ecm_gen; EntitledKeyInfo key1; InitParams(¶ms_one_key_, kTrackTypeSD); std::string request; @@ -320,8 +322,8 @@ TEST_F(CasEcmTest, GenerateWithNoEntitlementOneKeyFail) { .error_code()); } -TEST_F(CasEcmTest, GenerateWithNoEntitlementTwoKeysFail) { - CasEcm ecm_gen; +TEST_F(EcmTest, GenerateWithNoEntitlementTwoKeysFail) { + Ecm ecm_gen; EntitledKeyInfo key1; EntitledKeyInfo key2; InitParams(¶ms_two_keys_, kTrackTypeSD); @@ -338,15 +340,15 @@ TEST_F(CasEcmTest, GenerateWithNoEntitlementTwoKeysFail) { ecm_gen.GenerateEcm(&key1, &key2, kTrackTypeSD, &ecm, &gen).error_code()); } -TEST_F(CasEcmTest, RequestNullFail) { - CasEcm ecm_gen; +TEST_F(EcmTest, RequestNullFail) { + Ecm ecm_gen; EXPECT_EQ(error::INVALID_ARGUMENT, ecm_gen.Initialize(content_id_, provider_, params_simple_, nullptr) .error_code()); } -TEST_F(CasEcmTest, GenerateOneKeyOK) { - CasEcm ecm_gen; +TEST_F(EcmTest, GenerateOneKeyOK) { + Ecm ecm_gen; EntitledKeyInfo key1 = valid1_iv_16_8_; InitParams(¶ms_one_key_, kTrackTypeSD, kIvSize8); std::string request; @@ -363,8 +365,8 @@ TEST_F(CasEcmTest, GenerateOneKeyOK) { ASSERT_OK(ecm_gen.GenerateSingleKeyEcm(&key1, kTrackTypeSD, &ecm, &gen)); } -TEST_F(CasEcmTest, BadResponseFail) { - CasEcm ecm_gen; +TEST_F(EcmTest, BadResponseFail) { + Ecm ecm_gen; EntitledKeyInfo key1 = valid1_iv_16_8_; InitParams(¶ms_one_key_, kTrackTypeSD, kIvSize8); std::string request; @@ -378,8 +380,8 @@ TEST_F(CasEcmTest, BadResponseFail) { ecm_gen.ProcessCasEncryptionResponse(response).error_code()); } -TEST_F(CasEcmTest, GenerateTwoKeysOK) { - CasEcm ecm_gen; +TEST_F(EcmTest, GenerateTwoKeysOK) { + Ecm ecm_gen; EntitledKeyInfo key1 = valid1_iv_16_8_; EntitledKeyInfo key2 = valid2_iv_16_8_; InitParams(¶ms_two_keys_, kTrackTypeSD, kIvSize8); @@ -397,8 +399,8 @@ TEST_F(CasEcmTest, GenerateTwoKeysOK) { ASSERT_OK(ecm_gen.GenerateEcm(&key1, &key2, kTrackTypeSD, &ecm, &gen)); } -TEST_F(CasEcmTest, GenerateOneKeyNoGenFail) { - CasEcm ecm_gen; +TEST_F(EcmTest, GenerateOneKeyNoGenFail) { + Ecm ecm_gen; EntitledKeyInfo key1 = valid1_iv_16_8_; InitParams(¶ms_one_key_, kTrackTypeSD, kIvSize8); std::string request; @@ -416,8 +418,8 @@ TEST_F(CasEcmTest, GenerateOneKeyNoGenFail) { .error_code()); } -TEST_F(CasEcmTest, GenerateOneKeyBadKeyIdFail) { - CasEcm ecm_gen; +TEST_F(EcmTest, GenerateOneKeyBadKeyIdFail) { + Ecm ecm_gen; EntitledKeyInfo key1 = invalid1_key_id_iv_16_8_; InitParams(¶ms_one_key_, kTrackTypeSD, kIvSize8); std::string request; @@ -436,8 +438,8 @@ TEST_F(CasEcmTest, GenerateOneKeyBadKeyIdFail) { .error_code()); } -TEST_F(CasEcmTest, GenerateOneKeyWrong) { - CasEcm ecm_gen; +TEST_F(EcmTest, GenerateOneKeyWrong) { + Ecm ecm_gen; EntitledKeyInfo key1 = valid1_iv_16_8_; InitParams(¶ms_one_key_, kTrackTypeSD, kIvSize8); std::string request; @@ -459,8 +461,8 @@ TEST_F(CasEcmTest, GenerateOneKeyWrong) { ecm_gen.GenerateEcm(&key1, &key1, kTrackTypeSD, &ecm, &gen).error_code()); } -TEST_F(CasEcmTest, GenerateTwoKeysIvSizeFail) { - CasEcm ecm_gen; +TEST_F(EcmTest, GenerateTwoKeysIvSizeFail) { + Ecm ecm_gen; EntitledKeyInfo key1 = valid1_iv_16_8_; EntitledKeyInfo key2 = valid2_iv_16_8_; // IV size mismatch. @@ -481,8 +483,8 @@ TEST_F(CasEcmTest, GenerateTwoKeysIvSizeFail) { ecm_gen.GenerateEcm(&key1, &key2, kTrackTypeSD, &ecm, &gen).error_code()); } -TEST_F(CasEcmTest, GenerateTwoKeysIvSize16x8OK) { - CasEcm ecm_gen; +TEST_F(EcmTest, GenerateTwoKeysIvSize16x8OK) { + Ecm ecm_gen; EntitledKeyInfo key1 = valid1_iv_16_8_; EntitledKeyInfo key2 = valid2_iv_16_8_; InitParams(¶ms_two_keys_, kTrackTypeSD, kIvSize8); @@ -505,8 +507,8 @@ TEST_F(CasEcmTest, GenerateTwoKeysIvSize16x8OK) { EXPECT_THAT(149, ecm.size()); } -TEST_F(CasEcmTest, GenerateTwoKeysIvSize16x16OK) { - CasEcm ecm_gen; +TEST_F(EcmTest, GenerateTwoKeysIvSize16x16OK) { + Ecm ecm_gen; EntitledKeyInfo key1 = valid3_iv_16_16_; EntitledKeyInfo key2 = valid4_iv_16_16_; InitParams(¶ms_two_keys_, kTrackTypeSD, kIvSize16); @@ -530,8 +532,8 @@ TEST_F(CasEcmTest, GenerateTwoKeysIvSize16x16OK) { EXPECT_THAT(165, ecm.size()); } -TEST_F(CasEcmTest, GenerateThreeKeysIvSize16x16Fail) { - CasEcm ecm_gen; +TEST_F(EcmTest, GenerateThreeKeysIvSize16x16Fail) { + Ecm ecm_gen; EntitledKeyInfo key1 = valid3_iv_16_16_; EntitledKeyInfo key2 = valid4_iv_16_16_; InitParams(¶ms_two_keys_, kTrackTypeSD, kIvSize16); @@ -553,8 +555,8 @@ TEST_F(CasEcmTest, GenerateThreeKeysIvSize16x16Fail) { } // TODO(user): Add more unit tests for error paths around SerializeEcm. -TEST_F(CasEcmSerializeEcmTest, SerializeEcmDoubleKey16ByteIvs) { - MockCasEcm ecm_gen; +TEST_F(EcmSerializeEcmTest, SerializeEcmDoubleKey16ByteIvs) { + MockEcm ecm_gen; EntitledKeyInfo key1 = valid3_iv_16_16_; EntitledKeyInfo key2 = valid4_iv_16_16_; @@ -576,8 +578,8 @@ TEST_F(CasEcmSerializeEcmTest, SerializeEcmDoubleKey16ByteIvs) { ValidateEcmFieldsTwoKeys(buf_string, 1, CryptoMode::kAesCtr, kIvSize16); } -TEST_F(CasEcmSerializeEcmTest, SerializeEcmSingleKey16ByteIvs) { - MockCasEcm ecm_gen; +TEST_F(EcmSerializeEcmTest, SerializeEcmSingleKey16ByteIvs) { + MockEcm ecm_gen; EntitledKeyInfo key1 = valid3_iv_16_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); } -TEST_F(CasEcmSerializeEcmTest, SerializeEcmDoubleKey16x8ByteIvs) { - MockCasEcm ecm_gen; +TEST_F(EcmSerializeEcmTest, SerializeEcmDoubleKey16x8ByteIvs) { + MockEcm ecm_gen; EntitledKeyInfo key1 = valid1_iv_16_8_; EntitledKeyInfo key2 = valid2_iv_16_8_; @@ -620,8 +622,8 @@ TEST_F(CasEcmSerializeEcmTest, SerializeEcmDoubleKey16x8ByteIvs) { ValidateEcmFieldsTwoKeys(buf_string, 1, CryptoMode::kAesCtr, kIvSize8); } -TEST_F(CasEcmSerializeEcmTest, SerializeEcmSingleKey16x8ByteIvs) { - MockCasEcm ecm_gen; +TEST_F(EcmSerializeEcmTest, SerializeEcmSingleKey16x8ByteIvs) { + MockEcm ecm_gen; EntitledKeyInfo key1 = valid1_iv_16_8_; ecm_gen.MockSetup(false, kTrackTypeSD, 0, CryptoMode::kAesCtr, 8); diff --git a/media_cas_packager_sdk/internal/ecmg_client_handler.cc b/media_cas_packager_sdk/internal/ecmg_client_handler.cc index 797906d..5d10e06 100644 --- a/media_cas_packager_sdk/internal/ecmg_client_handler.cc +++ b/media_cas_packager_sdk/internal/ecmg_client_handler.cc @@ -500,11 +500,11 @@ void EcmgClientHandler::BuildEcmDatagram(const EcmgParameters& params, // Step 1: Generate entitlement keys. bool key_rotation_enabled = params.cw_per_msg > 1; - // Create an instance of CasEcm in order to set the entitlement keys. - // TODO(user): The section of code below for constructing CasEcm should - // be optimized. There should be a single instance of CasEcm for each stream. - // Right now, this is hard to do because CasEcmGenerator contains the CasEcm. - std::unique_ptr ecm = absl::make_unique(); + // Create an instance of Ecm in order to set the entitlement keys. + // TODO(user): The section of code below for constructing Ecm should + // be optimized. There should be a single instance of Ecm for each stream. + // Right now, this is hard to do because EcmGenerator contains the Ecm. + std::unique_ptr ecm = absl::make_unique(); // TODO(user): Revisit this hardcoded ecm_init_params. EcmInitParameters ecm_init_params; ecm_init_params.content_iv_size = kIvSize8; @@ -543,7 +543,7 @@ void EcmgClientHandler::BuildEcmDatagram(const EcmgParameters& params, } // Step 2: Generate serialized ECM. - CasEcmGenerator ecm_generator; + EcmGenerator ecm_generator; ecm_generator.set_ecm(std::move(ecm)); EcmParameters ecm_param; ecm_param.rotation_enabled = key_rotation_enabled; diff --git a/media_cas_packager_sdk/public/wv_cas_ecm.cc b/media_cas_packager_sdk/public/wv_cas_ecm.cc index 4bad37a..cba6949 100644 --- a/media_cas_packager_sdk/public/wv_cas_ecm.cc +++ b/media_cas_packager_sdk/public/wv_cas_ecm.cc @@ -142,8 +142,8 @@ WvCasStatus WvCasEcm::GenerateEcm( return INVALID_ARGUMENT; } - // Create an instance of CasEcm in order to set the entitlement keys. - std::unique_ptr cas_ecm = absl::make_unique(); + // Create an instance of Ecm in order to set the entitlement keys. + std::unique_ptr cas_ecm = absl::make_unique(); std::string entitlement_request; std::string entitlement_response; EcmInitParameters ecm_init_params = CreateEcmInitParameters( @@ -179,7 +179,7 @@ WvCasStatus WvCasEcm::GenerateEcm( } // Generate ECM. - CasEcmGenerator ecm_generator; + EcmGenerator ecm_generator; ecm_generator.set_ecm(std::move(cas_ecm)); EcmParameters ecm_param; ecm_param.rotation_enabled = key_rotation_enabled_; @@ -253,8 +253,8 @@ WvCasStatus WvCasEcm::GenerateSingleKeyEcm( return INVALID_ARGUMENT; } - // Create an instance of CasEcm in order to set the entitlement keys. - std::unique_ptr cas_ecm = absl::make_unique(); + // Create an instance of Ecm in order to set the entitlement keys. + std::unique_ptr cas_ecm = absl::make_unique(); std::string entitlement_request; std::string entitlement_response; EcmInitParameters ecm_init_params = CreateEcmInitParameters( @@ -290,7 +290,7 @@ WvCasStatus WvCasEcm::GenerateSingleKeyEcm( } // Generate ECM. - CasEcmGenerator ecm_generator; + EcmGenerator ecm_generator; ecm_generator.set_ecm(std::move(cas_ecm)); EcmParameters ecm_param; ecm_param.rotation_enabled = key_rotation_enabled_;