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(
name = "googletest_repo",
commit = "9816b96a6ddc0430671693df90192bbee57108b6", # 2017-08-11
commit = "b6cd405286ed8635ece71c72f118e659f4ade3fb", # 2019-01-04
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/strings",
"//common:aes_cbc_util",
"//common:random_util",
"//common:status",
"//common:string_util",
"//media_cas_packager_sdk/public:wv_cas_types",

58
media_cas_packager_sdk/internal/ecm.cc
View File

@@ -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,7 +111,7 @@ bool ConvertIvSizeParam(EcmIvSize param, size_t* size) {
} // namespace
Status CasEcm::Initialize(const std::string& content_id,
Status Ecm::Initialize(const std::string& content_id,
const std::string& content_provider,
const EcmInitParameters& ecm_init_parameters,
std::string* key_request_message) {
@@ -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,7 +172,7 @@ Status CasEcm::ProcessCasEncryptionResponse(const std::string& 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,
uint32_t* generation) {
if (!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<EntitledKeyInfo*>& keys,
const std::string& track_type,
std::string* serialized_ecm, uint32_t* generation) {
Status Ecm::GenerateEcmCommon(const std::vector<EntitledKeyInfo*>& 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,11 +257,11 @@ Status CasEcm::GenerateEcmCommon(const std::vector<EntitledKeyInfo*>& keys,
return OkStatus();
}
void CasEcm::IncrementGeneration() {
void Ecm::IncrementGeneration() {
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) {
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,7 +296,7 @@ Status CasEcm::WrapEntitledKeys(const std::string& track_type,
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) {
Status status = ValidateKeyValue(wrapping_key, kWrappingKeySizeBytes);
if (!status.ok()) {
@@ -328,7 +319,7 @@ Status CasEcm::WrapKey(const std::string& wrapping_key, const std::string& wrapp
return OkStatus();
}
Status CasEcm::ValidateKeys(const std::vector<EntitledKeyInfo*>& keys) {
Status Ecm::ValidateKeys(const std::vector<EntitledKeyInfo*>& keys) {
for (const auto& key : keys) {
Status status;
status = ValidateKeyId(key->key_id);
@@ -343,11 +334,15 @@ Status CasEcm::ValidateKeys(const std::vector<EntitledKeyInfo*>& 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<EntitledKeyInfo*>& keys) {
Status Ecm::ValidateWrappedKeys(const std::vector<EntitledKeyInfo*>& keys) {
for (const auto& key : keys) {
Status status;
status = ValidateKeyId(key->key_id);
@@ -371,15 +366,14 @@ Status CasEcm::ValidateWrappedKeys(const std::vector<EntitledKeyInfo*>& 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<EntitledKeyInfo*>& keys) {
std::string Ecm::SerializeEcm(const std::vector<EntitledKeyInfo*>& keys) {
// Five bytes (40 bits including padding)
std::bitset<kNumBitsCaSystemIdField> ca_system_id(kWvCasCaSystemId);
std::bitset<kNumBitsEcmVersionField> ecm_version(kEcmVersion);
@@ -435,7 +429,7 @@ std::string CasEcm::SerializeEcm(const std::vector<EntitledKeyInfo*>& 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.

17
media_cas_packager_sdk/internal/ecm.h
View File

@@ -9,7 +9,7 @@
#ifndef MEDIA_CAS_PACKAGER_SDK_INTERNAL_ECM_H_
#define MEDIA_CAS_PACKAGER_SDK_INTERNAL_ECM_H_
#include <stddef.h>
#include <cstddef>
#include <list>
#include <map>
#include <string>
@@ -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:

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 kMaxBytesKeyIdField = 16;
std::string CasEcmGenerator::GenerateEcm(const EcmParameters& params) {
std::string EcmGenerator::GenerateEcm(const EcmParameters& params) {
std::vector<EntitledKeyInfo> 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<EntitledKeyInfo>* keys) {
Status EcmGenerator::ProcessEcmParameters(const EcmParameters& ecm_params,
std::vector<EntitledKeyInfo>* 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;

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
// 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<CasEcm> ecm) { ecm_ = std::move(ecm); }
void set_ecm(std::unique_ptr<Ecm> ecm) { ecm_ = std::move(ecm); }
private:
friend class CasEcmGeneratorTest;
friend class EcmGeneratorTest;
Status ProcessEcmParameters(const EcmParameters& ecm_params,
std::vector<EntitledKeyInfo>* 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<CasEcm> ecm_;
std::unique_ptr<Ecm> ecm_;
};
} // 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
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<CasEcm>();
ecm_ = absl::make_unique<Ecm>();
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<CasEcm> ecm_;
std::unique_ptr<Ecm> 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<EntitledKeyInfo> 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);

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 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(&params_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(&params_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(&params_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(&params_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(&params_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(&params_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(&params_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(&params_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(&params_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(&params_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(&params_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(&params_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);

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.
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<CasEcm> ecm = absl::make_unique<CasEcm>();
// 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> ecm = absl::make_unique<Ecm>();
// 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;

12
media_cas_packager_sdk/public/wv_cas_ecm.cc
View File

@@ -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<CasEcm> cas_ecm = absl::make_unique<CasEcm>();
// Create an instance of Ecm in order to set the entitlement keys.
std::unique_ptr<Ecm> cas_ecm = absl::make_unique<Ecm>();
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<CasEcm> cas_ecm = absl::make_unique<CasEcm>();
// Create an instance of Ecm in order to set the entitlement keys.
std::unique_ptr<Ecm> cas_ecm = absl::make_unique<Ecm>();
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_;