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

Print uint16 as \x01 not \x1

Browse Source 
-------------
Allow the usage of different entitlement keys to wrap even vs. odd key.

-------------
(1) Change parameter type from 'string' to 'const char* const' to handle possible '\x00' (Nul char) byte in the input.
(2) Check size of generated ECM string, return error if the size is not as expected.

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=220172089
This commit is contained in:
Fang Yu
2018-11-05 14:23:16 -08:00
parent 581ae9080d
commit fb96918196
4 changed files with 371 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
example/wv_cas_ecm_example.cc
View File

@@ -14,22 +14,21 @@
#include "media_cas_packager_sdk/public/wv_cas_ecm.h"
#include "media_cas_packager_sdk/public/wv_cas_types.h"
const bool kKeyRotationEnabled = true;
const char kEvenKey[] = "even_content_key"; // 16 bytes
const char kCsaEvenKey[] = "12345678"; // 8 bytes
const char kEvenContentIv8Bytes[] = "evencont"; // 8 bytes
const char kEvenContentIv16Bytes[] = "evencontevencont"; // 16 bytes
const char kOddKey[] = "odd_content_key."; // 16 bytes
const char kCsaOddKey[] = "87654321"; // 8 bytes
const char kOddContentIv8Bytes[] = "oddcont."; // 8 bytes
const char kOddContentIv16Bytes[] = "oddcont.oddcont."; // 16 bytes
const char kEntitlementKeyId[] = "ent_key_id......"; // 16 bytes
const char kEntitlementKey[] = "entitlement_key................."; // 32 bytes
const char kCsaEvenKey[] = "even_key"; // 8 bytes
const char kEvenContentIv8Bytes[] = "even_iv."; // 8 bytes
const char kEvenEntitlementKeyId[] = "fake_key_id1...."; // 16 bytes
const char kEvenEntitlementKey[] =
"fakefakefakefakefakefakefake1..."; // 32 bytes
const char kCsaOddKey[] = "odd_key."; // 8 bytes
const char kOddContentIv8Bytes[] = "odd_iv.."; // 8 bytes
const char kOddEntitlementKeyId[] = "fake_key_id2...."; // 16 bytes
const char kOddEntitlementKey[] =
"fakefakefakefakefakefakefake2..."; // 32 bytes
int main(int argc, char **argv) {
widevine::cas::WvCasEcm wv_cas_ecm;
widevine::cas::WvCasStatus status =
wv_cas_ecm.Initialize(/* content_iv_size= */ 8, kKeyRotationEnabled,
widevine::cas::WvCasStatus status = wv_cas_ecm.Initialize(
/* content_iv_size= */ 8, /* key_rotation_enabled= */ true,
widevine::cas::CryptoMode::kDvbCsa2);
if (status != widevine::cas::OK) {
std::cerr << "Failed to initialize WV CAS ECM, error: "
@@ -37,9 +36,10 @@ int main(int argc, char **argv) {
<< std::endl;
}
std::string ecm;
status = wv_cas_ecm.GenerateEcm(kCsaEvenKey, kEvenContentIv8Bytes, kCsaOddKey,
kOddContentIv8Bytes, kEntitlementKeyId,
kEntitlementKey, &ecm);
status = wv_cas_ecm.GenerateEcm(
kCsaEvenKey, kEvenContentIv8Bytes, kEvenEntitlementKeyId,
kEvenEntitlementKey, kCsaOddKey, kOddContentIv8Bytes,
kOddEntitlementKeyId, kOddEntitlementKey, &ecm);
if (status != widevine::cas::OK) {
std::cerr << "Failed to generate WV CAS ECM, error: "
<< widevine::cas::GetWvCasStatusMessage(status)
@@ -48,7 +48,7 @@ int main(int argc, char **argv) {
std::cout << "ECM size: " << ecm.size() << std::endl;
std::cout << "ECM bytes: ";
for (size_t i = 0; i < ecm.size(); i++) {
printf("'\\x%x', ", static_cast<uint16_t>(ecm.at(i)));
printf("'\\x%02x', ", static_cast<uint16_t>(ecm.at(i)));
}
std::cout << std::endl;
}

165
media_cas_packager_sdk/public/wv_cas_ecm.cc
View File

@@ -30,6 +30,13 @@ namespace {
static constexpr size_t kContentKeySizeBytes = 16;
static constexpr size_t kCsaContentKeySizeBytes = 8;
static constexpr size_t kEntitlementKeyIdSizeBytes = 16;
static constexpr size_t kEntitlementKeySizeBytes = 32;
static constexpr size_t kEcmWith8BytesContentIvSizeBytes = 149;
static constexpr size_t kEcmWith16BytesContentIvSizeBytes = 149 + (8 * 2);
static constexpr size_t kSingleKeyEcmWith8BytesContentIvSizeBytes = 77;
static constexpr size_t kSingleKeyEcmWith16BytesContentIvSizeBytes =
kSingleKeyEcmWith8BytesContentIvSizeBytes + 8;
EcmInitParameters CreateEcmInitParameters(int content_iv_size,
bool key_rotation_enabled,
@@ -70,21 +77,22 @@ WvCasStatus WvCasEcm::Initialize(int content_iv_size, bool key_rotation_enabled,
return OK;
}
WvCasStatus WvCasEcm::GenerateEcm(const std::string& even_key,
const std::string& even_content_iv,
const std::string& odd_key,
const std::string& odd_content_iv,
const std::string& entitlement_key_id,
const std::string& entitlement_key,
std::string* ecm) const {
WvCasStatus WvCasEcm::GenerateEcm(
const char* const even_key, const char* const even_content_iv,
const char* const even_entitlement_key_id,
const char* const even_entitlement_key, const char* const odd_key,
const char* const odd_content_iv, const char* const odd_entitlement_key_id,
const char* const odd_entitlement_key, std::string* ecm) const {
DCHECK(even_key);
DCHECK(even_content_iv);
DCHECK(even_entitlement_key_id);
DCHECK(even_entitlement_key);
DCHECK(odd_key);
DCHECK(odd_content_iv);
DCHECK(odd_entitlement_key_id);
DCHECK(odd_entitlement_key);
DCHECK(ecm);
if (crypto_mode_ == CryptoMode::kDvbCsa2 &&
even_key.length() == kCsaContentKeySizeBytes &&
odd_key.length() == kCsaContentKeySizeBytes) {
return GenerateEcm(absl::StrCat(even_key, even_key), even_content_iv,
absl::StrCat(odd_key, odd_key), odd_content_iv,
entitlement_key_id, entitlement_key, ecm);
}
if (!initialized_) {
LOG(ERROR) << "WvCasEcm has not been properly initialized";
return UNAVAILABLE;
@@ -94,13 +102,40 @@ WvCasStatus WvCasEcm::GenerateEcm(const std::string& even_key,
"rotation is disabled";
return UNAVAILABLE;
}
if (even_key.size() != kContentKeySizeBytes ||
odd_key.size() != kContentKeySizeBytes) {
// Create strings in such way to handle possible '\x00' bytes in the input.
std::string even_key_str;
if (crypto_mode_ == CryptoMode::kDvbCsa2) {
even_key_str = std::string(even_key, kCsaContentKeySizeBytes);
even_key_str = even_key_str + even_key_str; // Make it 16 bytes.
} else {
even_key_str = std::string(even_key, kContentKeySizeBytes);
}
std::string even_content_iv_str(even_content_iv, content_iv_size_);
std::string even_entitlement_key_id_str(even_entitlement_key_id,
kEntitlementKeyIdSizeBytes);
std::string even_entitlement_key_str(even_entitlement_key,
kEntitlementKeySizeBytes);
std::string odd_key_str;
if (crypto_mode_ == CryptoMode::kDvbCsa2) {
odd_key_str = std::string(odd_key, kCsaContentKeySizeBytes);
odd_key_str = odd_key_str + odd_key_str; // Make it 16 bytes.
} else {
odd_key_str = std::string(odd_key, kContentKeySizeBytes);
}
std::string odd_content_iv_str(odd_content_iv, content_iv_size_);
std::string odd_entitlement_key_id_str(odd_entitlement_key_id,
kEntitlementKeyIdSizeBytes);
std::string odd_entitlement_key_str(odd_entitlement_key, kEntitlementKeySizeBytes);
// Double check some input sizes.
if (even_key_str.size() != kContentKeySizeBytes ||
odd_key_str.size() != kContentKeySizeBytes) {
LOG(ERROR) << "Size of content key is incorrect";
return INVALID_ARGUMENT;
}
if (even_content_iv.size() != content_iv_size_ ||
odd_content_iv.size() != content_iv_size_) {
if (even_content_iv_str.size() != content_iv_size_ ||
odd_content_iv_str.size() != content_iv_size_) {
LOG(ERROR) << "Size of content IV is incorrect";
return INVALID_ARGUMENT;
}
@@ -125,10 +160,10 @@ WvCasStatus WvCasEcm::GenerateEcm(const std::string& even_key,
return INTERNAL;
}
FixedKeyFetcher fixed_key_fetcher(
/* even_entitlement_key_id= */ entitlement_key_id,
/* even_entitlement_key= */ entitlement_key,
/* odd_entitlement_key_id= */ entitlement_key_id,
/* odd_entitlement_key= */ entitlement_key);
/* even_entitlement_key_id= */ even_entitlement_key_id_str,
/* even_entitlement_key= */ even_entitlement_key_str,
/* odd_entitlement_key_id= */ odd_entitlement_key_id_str,
/* odd_entitlement_key= */ odd_entitlement_key_str);
if (!(status = fixed_key_fetcher.RequestEntitlementKey(entitlement_request,
&entitlement_response))
.ok()) {
@@ -148,33 +183,40 @@ WvCasStatus WvCasEcm::GenerateEcm(const std::string& even_key,
ecm_param.rotation_enabled = key_rotation_enabled_;
// Add even entitlement key.
ecm_param.key_params.emplace_back();
ecm_param.key_params[0].key_data = even_key;
ecm_param.key_params[0].wrapped_key_iv = crypto_util::DeriveIv(even_key);
ecm_param.key_params[0].key_id = crypto_util::DeriveKeyId(even_key);
ecm_param.key_params[0].content_ivs.push_back(even_content_iv);
ecm_param.key_params[0].key_data = even_key_str;
ecm_param.key_params[0].wrapped_key_iv = crypto_util::DeriveIv(even_key_str);
ecm_param.key_params[0].key_id = crypto_util::DeriveKeyId(even_key_str);
ecm_param.key_params[0].content_ivs.push_back(even_content_iv_str);
// Add odd entitlement key.
ecm_param.key_params.emplace_back();
ecm_param.key_params[1].key_data = odd_key;
ecm_param.key_params[1].wrapped_key_iv = crypto_util::DeriveIv(odd_key);
ecm_param.key_params[1].key_id = crypto_util::DeriveKeyId(odd_key);
ecm_param.key_params[1].content_ivs.push_back(odd_content_iv);
ecm_param.key_params[1].key_data = odd_key_str;
ecm_param.key_params[1].wrapped_key_iv = crypto_util::DeriveIv(odd_key_str);
ecm_param.key_params[1].key_id = crypto_util::DeriveKeyId(odd_key_str);
ecm_param.key_params[1].content_ivs.push_back(odd_content_iv_str);
*ecm = ecm_generator.GenerateEcm(ecm_param);
size_t expected_ecm_size = content_iv_size_ == 8
? kEcmWith8BytesContentIvSizeBytes
: kEcmWith16BytesContentIvSizeBytes;
if (ecm->size() != expected_ecm_size) {
LOG(ERROR) << "Generated an ECM with invalid size: " << ecm->size();
ecm->clear();
return INTERNAL;
}
return OK;
}
WvCasStatus WvCasEcm::GenerateSingleKeyEcm(const std::string& even_key,
const std::string& even_content_iv,
const std::string& entitlement_key_id,
const std::string& entitlement_key,
std::string* ecm) const {
WvCasStatus WvCasEcm::GenerateSingleKeyEcm(
const char* const even_key, const char* const even_content_iv,
const char* const even_entitlement_key_id,
const char* const even_entitlement_key, std::string* ecm) const {
DCHECK(even_key);
DCHECK(even_content_iv);
DCHECK(even_entitlement_key_id);
DCHECK(even_entitlement_key);
DCHECK(ecm);
if (crypto_mode_ == CryptoMode::kDvbCsa2 &&
even_key.length() == kCsaContentKeySizeBytes) {
return GenerateSingleKeyEcm(absl::StrCat(even_key, even_key),
even_content_iv, entitlement_key_id,
entitlement_key, ecm);
}
if (!initialized_) {
LOG(ERROR) << "WvCasEcm has not been properly initialized";
return UNAVAILABLE;
@@ -184,11 +226,27 @@ WvCasStatus WvCasEcm::GenerateSingleKeyEcm(const std::string& even_key,
<< "Please call GenerateEcm() instead when key rotation is enabled";
return UNAVAILABLE;
}
if (even_key.size() != kContentKeySizeBytes) {
// Create strings in such way to handle possible '\x00' bytes in the input.
std::string even_key_str;
if (crypto_mode_ == CryptoMode::kDvbCsa2) {
even_key_str = std::string(even_key, kCsaContentKeySizeBytes);
even_key_str = even_key_str + even_key_str; // Make it 16 bytes.
} else {
even_key_str = std::string(even_key, kContentKeySizeBytes);
}
std::string even_content_iv_str(even_content_iv, content_iv_size_);
std::string even_entitlement_key_id_str(even_entitlement_key_id,
kEntitlementKeyIdSizeBytes);
std::string even_entitlement_key_str(even_entitlement_key,
kEntitlementKeySizeBytes);
// Double check some input sizes.
if (even_key_str.size() != kContentKeySizeBytes) {
LOG(ERROR) << "Size of content key is incorrect";
return INVALID_ARGUMENT;
}
if (even_content_iv.size() != content_iv_size_) {
if (even_content_iv_str.size() != content_iv_size_) {
LOG(ERROR) << "Size of content IV is incorrect";
return INVALID_ARGUMENT;
}
@@ -213,8 +271,8 @@ WvCasStatus WvCasEcm::GenerateSingleKeyEcm(const std::string& even_key,
return INTERNAL;
}
FixedKeyFetcher fixed_key_fetcher(
/* even_entitlement_key_id= */ entitlement_key_id,
/* even_entitlement_key= */ entitlement_key,
/* even_entitlement_key_id= */ even_entitlement_key_id_str,
/* even_entitlement_key= */ even_entitlement_key_str,
/* odd_entitlement_key_id= */ "",
/* odd_entitlement_key= */ "");
if (!(status = fixed_key_fetcher.RequestEntitlementKey(entitlement_request,
@@ -236,12 +294,21 @@ WvCasStatus WvCasEcm::GenerateSingleKeyEcm(const std::string& even_key,
ecm_param.rotation_enabled = key_rotation_enabled_;
// Add even entitlement key.
ecm_param.key_params.emplace_back();
ecm_param.key_params[0].key_data = even_key;
ecm_param.key_params[0].wrapped_key_iv = crypto_util::DeriveIv(even_key);
ecm_param.key_params[0].key_id = crypto_util::DeriveKeyId(even_key);
ecm_param.key_params[0].content_ivs.push_back(even_content_iv);
ecm_param.key_params[0].key_data = even_key_str;
ecm_param.key_params[0].wrapped_key_iv = crypto_util::DeriveIv(even_key_str);
ecm_param.key_params[0].key_id = crypto_util::DeriveKeyId(even_key_str);
ecm_param.key_params[0].content_ivs.push_back(even_content_iv_str);
*ecm = ecm_generator.GenerateEcm(ecm_param);
size_t expected_ecm_size = content_iv_size_ == 8
? kSingleKeyEcmWith8BytesContentIvSizeBytes
: kSingleKeyEcmWith16BytesContentIvSizeBytes;
if (ecm->size() != expected_ecm_size) {
LOG(ERROR) << "Generated an ECM with invalid size: " << ecm->size();
ecm->clear();
return INTERNAL;
}
return OK;
}

79
media_cas_packager_sdk/public/wv_cas_ecm.h
View File

@@ -55,52 +55,61 @@ class WvCasEcm {
// Generate an ECM containing two keys (even and odd). Can be called when
// |key_rotation_enabled| is initialized to 'true'.
//
// Args:
// - |even_key| clear even content key
// - |even_content_iv| iv used along with |even_key| for encrypting content
// - |odd_key| clear odd content key
// - |odd_content_iv| iv used along with |odd_key| for encrypting content
// - |entitlement_key_id| key id for |entitlement_key|
// - |entitlement_key| entitlement key used to encrypt even and odd keys
// - |ecm| for returning the generated ECM, must not be nullptr
// Args (all pointer parameters must be not nullptr):
// - |even_key| clear even content key, must be 8 bytes for kDvbCsa2,
// 16 bytes for kAesCtr or kAesCbc
// - |even_content_iv| iv used along with |even_key| for encrypting content,
// length must match |content_iv_size| set during initialization
// - |even_entitlement_key_id| key id for |even_entitlement_key|,
// must be 16 bytes length
// - |even_entitlement_key| entitlement key used to encrypt even key,
// must be 32 bytes length
// - |odd_key| clear odd content key, must be 8 bytes for kDvbCsa2,
// 16 bytes for kAesCtr or kAesCbc
// - |odd_content_iv| iv used along with |odd_key| for encrypting content,
// length must match |content_iv_size| set during initialization
// - |odd_entitlement_key_id| key id for |odd_entitlement_key|,
// must be 16 bytes length
// - |odd_entitlement_key| entitlement key used to encrypt odd key,
// must be 32 bytes length
// - |ecm| for returning the generated ECM,
// size of the generated ecm is 149 bytes when content iv is 8 bytes
// 165 bytes when content iv is 16 bytes
//
// Returns:
// - A status indicating whether there was any error during processing
//
// Note:
// - The same |entitlement_key| will be used to encrypt both |even_key|
// and |odd_key| in the ECM
// - Size of |even_content_iv| and |odd_content_iv| must match
// |content_iv_size| set during initialization
virtual WvCasStatus GenerateEcm(const std::string& even_key,
const std::string& even_content_iv,
const std::string& odd_key,
const std::string& odd_content_iv,
const std::string& entitlement_key_id,
const std::string& entitlement_key,
virtual WvCasStatus GenerateEcm(const char* const even_key,
const char* const even_content_iv,
const char* const even_entitlement_key_id,
const char* const even_entitlement_key,
const char* const odd_key,
const char* const odd_content_iv,
const char* const odd_entitlement_key_id,
const char* const odd_entitlement_key,
std::string* ecm) const;
// Generate an ECM containing only a singe even key. Can be called when
// |key_rotation_enabled| is initialized to 'false'.
//
// Args:
// - |even_key| clear even content key
// - |even_content_iv| iv used along with |even_key| for encrypting content
// - |entitlement_key_id| key id for |entitlement_key|
// - |entitlement_key| entitlement key used to encrypt even key
// - |ecm| for returning the generated ECM, must not be nullptr
// Args (all pointer parameters must be not nullptr):
// - |even_key| clear even content key, must be 8 bytes for kDvbCsa2,
// 16 bytes for kAesCtr or kAesCbc
// - |even_content_iv| iv used along with |even_key| for encrypting content,
// length must match |content_iv_size| set during initialization
// - |even_entitlement_key_id| key id for |even_entitlement_key|,
// must be 16 bytes length
// - |even_entitlement_key| entitlement key used to encrypt even key,
// must be 32 bytes length
// - |ecm| for returning the generated ECM,
// size of the generated ecm is 77 bytes when content iv is 8 bytes
// 85 bytes when content iv is 16 bytes
//
// Returns:
// - A status indicating whether there was any error during processing
//
// Note:
// - Size of |even_content_iv| and |odd_content_iv| must match
// |content_iv_size| set during initialization
virtual WvCasStatus GenerateSingleKeyEcm(const std::string& even_key,
const std::string& even_content_iv,
const std::string& entitlement_key_id,
const std::string& entitlement_key,
std::string* ecm) const;
virtual WvCasStatus GenerateSingleKeyEcm(
const char* const even_key, const char* const even_content_iv,
const char* const even_entitlement_key_id,
const char* const even_entitlement_key, std::string* ecm) const;
private:
bool initialized_ = false;

300
media_cas_packager_sdk/public/wv_cas_ecm_test.cc
View File

@@ -18,14 +18,24 @@ using ::testing::Test;
namespace widevine {
namespace cas {
const char kEvenKey[] = "even_content_key"; // 16 bytes
const char kCsaEvenKey[] = "12345678"; // 8 bytes
const char kEvenContentIv8Bytes[] = "evencont"; // 8 bytes
const char kOddKey[] = "odd_content_key."; // 16 bytes
const char kCsaOddKey[] = "87654321"; // 8 bytes
const char kOddContentIv8Bytes[] = "oddcont."; // 8 bytes
const char kEntitlementKeyId[] = "ent_key_id......"; // 16 bytes
const char kEntitlementKey[] = "entitlement_key................."; // 32 bytes
const char kEvenKey[] = "even_key........"; // 16 bytes
const char kCsaEvenKey[] = "even_key"; // 8 bytes
const char kCsaEvenKeyWithNul[] = {'\x01', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x01'};
const char kEvenContentIv8Bytes[] = "even_iv."; // 8 bytes
const char kEvenContentIv16Bytes[] = "even_iv........."; // 16 bytes
const char kEvenEntitlementKeyId[] = "even_ent_key_id."; // 16 bytes
const char kEvenEntitlementKey[] =
"even_entitlement_key............"; // 32 bytes
const char kOddKey[] = "odd_key........."; // 16 bytes
const char kCsaOddKey[] = "odd_key."; // 8 bytes
const char kCsaOddKeyWithNul[] = {'\x00', '\x02', '\x00', '\x00',
'\x00', '\x00', '\x02', '\x00'};
const char kOddContentIv8Bytes[] = "odd_iv.."; // 8 bytes
const char kOddContentIv16Bytes[] = "od_iv..........."; // 16 bytes
const char kOddEntitlementKeyId[] = "odd_ent_key_id.."; // 16 bytes
const char kOddEntitlementKey[] =
"odd_entitlement_key............."; // 32 bytes
class WvCasEcmTest : public Test {
protected:
@@ -33,7 +43,7 @@ class WvCasEcmTest : public Test {
WvCasEcm wv_cas_ecm_;
};
TEST_F(WvCasEcmTest, InitializeTwice) {
TEST_F(WvCasEcmTest, Initialize_Twice_Error) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8,
/* key_rotation_enabled= */ true,
CryptoMode::kAesCtr));
@@ -43,14 +53,14 @@ TEST_F(WvCasEcmTest, InitializeTwice) {
CryptoMode::kAesCtr));
}
TEST_F(WvCasEcmTest, InitializeInvalidContentIvSize) {
TEST_F(WvCasEcmTest, Initialize_InvalidContentIvSize_Error) {
EXPECT_EQ(INVALID_ARGUMENT,
wv_cas_ecm_.Initialize(/* content_iv_size= */ 4,
/* key_rotation_enabled= */ true,
CryptoMode::kAesCtr));
}
TEST_F(WvCasEcmTest, InitializeKeyRotationEnabledThenGenerateSingleKeyEcm) {
TEST_F(WvCasEcmTest, GenerateSingleKeyEcm_KeyRotationEnabled_Error) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8,
/* key_rotation_enabled= */ true,
CryptoMode::kAesCtr));
@@ -59,245 +69,255 @@ TEST_F(WvCasEcmTest, InitializeKeyRotationEnabledThenGenerateSingleKeyEcm) {
wv_cas_ecm_.GenerateSingleKeyEcm("", "", "", "", &actual_ecm));
}
TEST_F(WvCasEcmTest, InitializeKeyRotationDisabledThenGenerateEcm) {
TEST_F(WvCasEcmTest, GenerateEcm_KeyRotationDisabled_Error) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8,
/* key_rotation_enabled= */ false,
CryptoMode::kAesCtr));
std::string actual_ecm;
EXPECT_EQ(UNAVAILABLE,
wv_cas_ecm_.GenerateEcm("", "", "", "", "", "", &actual_ecm));
EXPECT_EQ(UNAVAILABLE, wv_cas_ecm_.GenerateEcm("", "", "", "", "", "", "", "",
&actual_ecm));
}
TEST_F(WvCasEcmTest, GenerateEcmInvalidContentIv) {
TEST_F(WvCasEcmTest, GenerateEcm_8BytesContentIv_Ctr_Success) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8,
/* key_rotation_enabled= */ true,
CryptoMode::kAesCtr));
std::string actual_ecm;
EXPECT_EQ(INVALID_ARGUMENT,
EXPECT_EQ(OK,
wv_cas_ecm_.GenerateEcm(
/* even_key= */ kEvenKey,
/* even_content_iv= */ kEvenContentIv8Bytes,
/* odd_key= */ kOddKey,
/* odd_content_iv= */ "123456789",
/* entitlement_key_id= */ kEntitlementKeyId,
/* entitlement_key= */ kEntitlementKey, &actual_ecm));
}
TEST_F(WvCasEcmTest, GenerateSingleKeyEcmInvalidContentIv) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8,
/* key_rotation_enabled= */ false,
CryptoMode::kAesCtr));
std::string actual_ecm;
EXPECT_EQ(INVALID_ARGUMENT,
wv_cas_ecm_.GenerateSingleKeyEcm(
/* even_key= */ kEvenKey,
/* even_content_iv= */ "1234",
/* entitlement_key_id= */ kEntitlementKeyId,
/* entitlement_key= */ kEntitlementKey, &actual_ecm));
}
TEST_F(WvCasEcmTest, GenerateEcmInvalidContentKey) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8,
/* key_rotation_enabled= */ true,
CryptoMode::kAesCtr));
std::string actual_ecm;
EXPECT_EQ(INVALID_ARGUMENT,
wv_cas_ecm_.GenerateEcm(
/* even_key= */ kEvenKey,
/* even_content_iv= */ kEvenContentIv8Bytes,
/* odd_key= */ "12345678",
/* odd_content_iv= */ kOddContentIv8Bytes,
/* entitlement_key_id= */ kEntitlementKeyId,
/* entitlement_key= */ kEntitlementKey, &actual_ecm));
}
TEST_F(WvCasEcmTest, GenerateSingleKeyEcmInvalidContentKey) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8,
/* key_rotation_enabled= */ false,
CryptoMode::kAesCtr));
std::string actual_ecm;
EXPECT_EQ(INVALID_ARGUMENT,
wv_cas_ecm_.GenerateSingleKeyEcm(
/* even_key= */ "12345678",
/* even_content_iv= */ kEvenContentIv8Bytes,
/* entitlement_key_id= */ kEntitlementKeyId,
/* entitlement_key= */ kEntitlementKey, &actual_ecm));
}
TEST_F(WvCasEcmTest, GenerateEcm8BytesContentIvCtrSuccess) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8,
/* key_rotation_enabled= */ true,
CryptoMode::kAesCtr));
std::string actual_ecm;
EXPECT_EQ(OK, wv_cas_ecm_.GenerateEcm(
/* even_key= */ kEvenKey,
/* even_content_iv= */ kEvenContentIv8Bytes,
/* even_entitlement_key_id= */ kEvenEntitlementKeyId,
/* even_entitlement_key= */ kEvenEntitlementKey,
/* odd_key= */ kOddKey,
/* odd_content_iv= */ kOddContentIv8Bytes,
/* entitlement_key_id= */ kEntitlementKeyId,
/* entitlement_key= */ kEntitlementKey, &actual_ecm));
/* odd_entitlement_key_id= */ kOddEntitlementKeyId,
/* odd_entitlement_key= */ kOddEntitlementKey, &actual_ecm));
EXPECT_EQ(
"4ad4010380656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8"
"c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665"
"6e636f6e74656e745f6b65795f69642e2e2e2e2e2e0700509b67763b3f1c356bc1e1dc8b"
"ac99a1e2f95c37d9183cbb96582f3a05fdbe29925c37c6c6a45eb552b5ddf87f8a6f6464"
"636f6e742e",
"4ad40103806576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952"
"a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665"
"6e5f69762e6f64645f656e745f6b65795f69642e2e34cd74b6b998889aad0e71b44bdd8c"
"0e03e31ea68ab80a6ee79f59f0936bc6aa64fe976b6a4a5db2dc7e3ebba4a0bd876f6464"
"5f69762e2e",
absl::BytesToHexString(actual_ecm));
}
TEST_F(WvCasEcmTest, GenerateSingleKeyEcm8BytesContentIvCtrSuccess) {
TEST_F(WvCasEcmTest, GenerateSingleKeyEcm_8BytesContentIv_Ctr_Success) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8,
/* key_rotation_enabled= */ false,
CryptoMode::kAesCtr));
std::string actual_ecm;
EXPECT_EQ(OK, wv_cas_ecm_.GenerateSingleKeyEcm(
EXPECT_EQ(OK,
wv_cas_ecm_.GenerateSingleKeyEcm(
/* even_key= */ kEvenKey,
/* even_content_iv= */ kEvenContentIv8Bytes,
/* entitlement_key_id= */ kEntitlementKeyId,
/* entitlement_key= */ kEntitlementKey, &actual_ecm));
/* even_entitlement_key_id= */ kEvenEntitlementKeyId,
/* even_entitlement_key= */ kEvenEntitlementKey, &actual_ecm));
EXPECT_EQ(
"4ad4010280656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8"
"c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665"
"6e636f6e74",
"4ad40102806576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952"
"a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665"
"6e5f69762e",
absl::BytesToHexString(actual_ecm));
}
TEST_F(WvCasEcmTest, GenerateEcm16BytesContentIvCtrSuccess) {
TEST_F(WvCasEcmTest, GenerateEcm_16BytesContentIv_Ctr_Success) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 16,
/* key_rotation_enabled= */ true,
CryptoMode::kAesCtr));
std::string actual_ecm;
EXPECT_EQ(OK, wv_cas_ecm_.GenerateEcm(
EXPECT_EQ(OK,
wv_cas_ecm_.GenerateEcm(
/* even_key= */ kEvenKey,
/* even_content_iv= */
absl::StrCat(kEvenContentIv8Bytes, kEvenContentIv8Bytes),
kEvenContentIv16Bytes,
/* even_entitlement_key_id= */ kEvenEntitlementKeyId,
/* even_entitlement_key= */ kEvenEntitlementKey,
/* odd_key= */ kOddKey,
/* odd_content_iv= */
absl::StrCat(kOddContentIv8Bytes, kOddContentIv8Bytes),
/* entitlement_key_id= */ kEntitlementKeyId,
/* entitlement_key= */ kEntitlementKey, &actual_ecm));
kOddContentIv16Bytes,
/* odd_entitlement_key_id= */ kOddEntitlementKeyId,
/* odd_entitlement_key= */ kOddEntitlementKey, &actual_ecm));
EXPECT_EQ(
"4ad40103c0656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8"
"c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665"
"6e636f6e746576656e636f6e74656e745f6b65795f69642e2e2e2e2e2e0700509b67763b"
"3f1c356bc1e1dc8bac99a1e2f95c37d9183cbb96582f3a05fdbe29925c37c6c6a45eb552"
"b5ddf87f8a6f6464636f6e742e6f6464636f6e742e",
"4ad40103c06576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952"
"a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665"
"6e5f69762e2e2e2e2e2e2e2e2e6f64645f656e745f6b65795f69642e2e34cd74b6b99888"
"9aad0e71b44bdd8c0e03e31ea68ab80a6ee79f59f0936bc6aa64fe976b6a4a5db2dc7e3e"
"bba4a0bd876f645f69762e2e2e2e2e2e2e2e2e2e2e",
absl::BytesToHexString(actual_ecm));
}
TEST_F(WvCasEcmTest, GenerateSingleKeyEcm16BytesContentIvCtrSuccess) {
TEST_F(WvCasEcmTest, GenerateSingleKeyEcm_16BytesContentIv_Ctr_Success) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 16,
/* key_rotation_enabled= */ false,
CryptoMode::kAesCtr));
std::string actual_ecm;
EXPECT_EQ(OK, wv_cas_ecm_.GenerateSingleKeyEcm(
EXPECT_EQ(OK,
wv_cas_ecm_.GenerateSingleKeyEcm(
/* even_key= */ kEvenKey,
/* even_content_iv= */
absl::StrCat(kEvenContentIv8Bytes, kEvenContentIv8Bytes),
/* entitlement_key_id= */ kEntitlementKeyId,
/* entitlement_key= */ kEntitlementKey, &actual_ecm));
kEvenContentIv16Bytes,
/* even_entitlement_key_id= */ kEvenEntitlementKeyId,
/* even_entitlement_key= */ kEvenEntitlementKey, &actual_ecm));
EXPECT_EQ(
"4ad40102c0656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8"
"c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665"
"6e636f6e746576656e636f6e74",
"4ad40102c06576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952"
"a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665"
"6e5f69762e2e2e2e2e2e2e2e2e",
absl::BytesToHexString(actual_ecm));
}
TEST_F(WvCasEcmTest, GenerateEcm16BytesContentIvCbcSuccess) {
TEST_F(WvCasEcmTest, GenerateEcm_16BytesContentIv_Cbc_Success) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 16,
/* key_rotation_enabled= */ true,
CryptoMode::kAesCbc));
std::string actual_ecm;
EXPECT_EQ(OK, wv_cas_ecm_.GenerateEcm(
EXPECT_EQ(OK,
wv_cas_ecm_.GenerateEcm(
/* even_key= */ kEvenKey,
/* even_content_iv= */
absl::StrCat(kEvenContentIv8Bytes, kEvenContentIv8Bytes),
kEvenContentIv16Bytes,
/* even_entitlement_key_id= */ kEvenEntitlementKeyId,
/* even_entitlement_key= */ kEvenEntitlementKey,
/* odd_key= */ kOddKey,
/* odd_content_iv= */
absl::StrCat(kOddContentIv8Bytes, kOddContentIv8Bytes),
/* entitlement_key_id= */ kEntitlementKeyId,
/* entitlement_key= */ kEntitlementKey, &actual_ecm));
kOddContentIv16Bytes,
/* odd_entitlement_key_id= */ kOddEntitlementKeyId,
/* odd_entitlement_key= */ kOddEntitlementKey, &actual_ecm));
EXPECT_EQ(
"4ad40105c0656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8"
"c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665"
"6e636f6e746576656e636f6e74656e745f6b65795f69642e2e2e2e2e2e0700509b67763b"
"3f1c356bc1e1dc8bac99a1e2f95c37d9183cbb96582f3a05fdbe29925c37c6c6a45eb552"
"b5ddf87f8a6f6464636f6e742e6f6464636f6e742e",
"4ad40105c06576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952"
"a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665"
"6e5f69762e2e2e2e2e2e2e2e2e6f64645f656e745f6b65795f69642e2e34cd74b6b99888"
"9aad0e71b44bdd8c0e03e31ea68ab80a6ee79f59f0936bc6aa64fe976b6a4a5db2dc7e3e"
"bba4a0bd876f645f69762e2e2e2e2e2e2e2e2e2e2e",
absl::BytesToHexString(actual_ecm));
}
TEST_F(WvCasEcmTest, GenerateSingleKeyEcm16BytesContentIvCbcSuccess) {
TEST_F(WvCasEcmTest, GenerateSingleKeyEcm_16BytesContentIv_Cbc_Success) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 16,
/* key_rotation_enabled= */ false,
CryptoMode::kAesCbc));
std::string actual_ecm;
EXPECT_EQ(OK, wv_cas_ecm_.GenerateSingleKeyEcm(
EXPECT_EQ(OK,
wv_cas_ecm_.GenerateSingleKeyEcm(
/* even_key= */ kEvenKey,
/* even_content_iv= */
absl::StrCat(kEvenContentIv8Bytes, kEvenContentIv8Bytes),
/* entitlement_key_id= */ kEntitlementKeyId,
/* entitlement_key= */ kEntitlementKey, &actual_ecm));
kEvenContentIv16Bytes,
/* even_entitlement_key_id= */ kEvenEntitlementKeyId,
/* even_entitlement_key= */ kEvenEntitlementKey, &actual_ecm));
EXPECT_EQ(
"4ad40104c0656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8"
"c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665"
"6e636f6e746576656e636f6e74",
"4ad40104c06576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952"
"a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665"
"6e5f69762e2e2e2e2e2e2e2e2e",
absl::BytesToHexString(actual_ecm));
}
TEST_F(WvCasEcmTest, GenerateEcm8BytesContentIvCsaSuccess) {
TEST_F(WvCasEcmTest, GenerateEcm_8BytesContentIv_Csa_Success) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8,
/* key_rotation_enabled= */ true,
CryptoMode::kDvbCsa2));
std::string actual_ecm;
EXPECT_EQ(OK, wv_cas_ecm_.GenerateEcm(
EXPECT_EQ(OK,
wv_cas_ecm_.GenerateEcm(
/* even_key= */ kCsaEvenKey,
/* even_content_iv= */
kEvenContentIv8Bytes,
/* even_entitlement_key_id= */ kEvenEntitlementKeyId,
/* even_entitlement_key= */ kEvenEntitlementKey,
/* odd_key= */ kCsaOddKey,
/* odd_content_iv= */
kOddContentIv8Bytes,
/* entitlement_key_id= */ kEntitlementKeyId,
/* entitlement_key= */ kEntitlementKey, &actual_ecm));
/* odd_entitlement_key_id= */ kOddEntitlementKeyId,
/* odd_entitlement_key= */ kOddEntitlementKey, &actual_ecm));
EXPECT_EQ(
"4ad4010780656e745f6b65795f69642e2e2e2e2e2e1970666a56b136d5d63b009c1a514a"
"948b8c0a380f2c9965134faac9d92992627abdd06f4a268bd12f8989373aece8bd657665"
"6e636f6e74656e745f6b65795f69642e2e2e2e2e2eda65f122610af2c9c9fa7ad18d07f4"
"3faab4190ac47c0d974547e8615d7bc64beb665a2d7c36f687ad8ec518e83062076f6464"
"636f6e742e",
"4ad40107806576656e5f656e745f6b65795f69642ee9c009a9d6a07c7bc3ca82f39c1f10"
"e6b5f391e74f120cfb876efba02d7f506f0ef185b3398096111dafd86ff7d395a2657665"
"6e5f69762e6f64645f656e745f6b65795f69642e2e7f655fe61e99e89e03ac23df98cc02"
"1cf21dfe9637c72c3480727ab18332d4ee219e81b8f34c9df2704b0595501832736f6464"
"5f69762e2e",
absl::BytesToHexString(actual_ecm));
}
TEST_F(WvCasEcmTest, GenerateSingleKeyEcm8BytesContentIvCsaSuccess) {
TEST_F(WvCasEcmTest, GenerateSingleKeyEcm_8BytesContentIv_Csa_Success) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8,
/* key_rotation_enabled= */ false,
CryptoMode::kDvbCsa2));
std::string actual_ecm;
EXPECT_EQ(OK, wv_cas_ecm_.GenerateSingleKeyEcm(
EXPECT_EQ(OK,
wv_cas_ecm_.GenerateSingleKeyEcm(
/* even_key= */ kCsaEvenKey,
/* even_content_iv= */
kEvenContentIv8Bytes,
/* entitlement_key_id= */ kEntitlementKeyId,
/* entitlement_key= */ kEntitlementKey, &actual_ecm));
/* even_entitlement_key_id= */ kEvenEntitlementKeyId,
/* even_entitlement_key= */ kEvenEntitlementKey, &actual_ecm));
EXPECT_EQ(
"4ad4010680656e745f6b65795f69642e2e2e2e2e2e1970666a56b136d5d63b009c1a514a"
"948b8c0a380f2c9965134faac9d92992627abdd06f4a268bd12f8989373aece8bd657665"
"6e636f6e74",
"4ad40106806576656e5f656e745f6b65795f69642ee9c009a9d6a07c7bc3ca82f39c1f10"
"e6b5f391e74f120cfb876efba02d7f506f0ef185b3398096111dafd86ff7d395a2657665"
"6e5f69762e",
absl::BytesToHexString(actual_ecm));
}
TEST_F(WvCasEcmTest, GenerateEcm_8BytesContentIv_Csa_NulCharInKey_Success) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8,
/* key_rotation_enabled= */ true,
CryptoMode::kDvbCsa2));
std::string actual_ecm;
EXPECT_EQ(OK,
wv_cas_ecm_.GenerateEcm(
/* even_key= */ kCsaEvenKeyWithNul,
/* even_content_iv= */
kEvenContentIv8Bytes,
/* even_entitlement_key_id= */ kEvenEntitlementKeyId,
/* even_entitlement_key= */ kEvenEntitlementKey,
/* odd_key= */ kCsaOddKeyWithNul,
/* odd_content_iv= */
kOddContentIv8Bytes,
/* odd_entitlement_key_id= */ kOddEntitlementKeyId,
/* odd_entitlement_key= */ kOddEntitlementKey, &actual_ecm));
EXPECT_EQ(
"4ad40107806576656e5f656e745f6b65795f69642e71ffb7d9500261db7a92974405c2cf"
"d0b085eb9a85a57dbdb799158e829996988524bf3b3cfe01b28d4474f85ec2991d657665"
"6e5f69762e6f64645f656e745f6b65795f69642e2e874aab870ffba640875a4521d3cd57"
"02f26d0f9c7e9c69d7059c9ad42b091ec1f151aaa190536f4f330edebe84fe5a786f6464"
"5f69762e2e",
absl::BytesToHexString(actual_ecm));
}
TEST_F(WvCasEcmTest,
GenerateSingleKeyEcm_8BytesContentIv_Csa_NulCharInKey_Success) {
EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8,
/* key_rotation_enabled= */ false,
CryptoMode::kDvbCsa2));
std::string actual_ecm;
EXPECT_EQ(OK,
wv_cas_ecm_.GenerateSingleKeyEcm(
/* even_key= */ kCsaEvenKeyWithNul,
/* even_content_iv= */
kEvenContentIv8Bytes,
/* even_entitlement_key_id= */ kEvenEntitlementKeyId,
/* even_entitlement_key= */ kEvenEntitlementKey, &actual_ecm));
EXPECT_EQ(
"4ad40106806576656e5f656e745f6b65795f69642e71ffb7d9500261db7a92974405c2cf"
"d0b085eb9a85a57dbdb799158e829996988524bf3b3cfe01b28d4474f85ec2991d657665"
"6e5f69762e",
absl::BytesToHexString(actual_ecm));
}