diff --git a/example/wv_cas_ecm_example.cc b/example/wv_cas_ecm_example.cc index ff088e1..4c5dab4 100644 --- a/example/wv_cas_ecm_example.cc +++ b/example/wv_cas_ecm_example.cc @@ -14,32 +14,32 @@ #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::CryptoMode::kDvbCsa2); + 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: " << widevine::cas::GetWvCasStatusMessage(status) << 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(ecm.at(i))); + printf("'\\x%02x', ", static_cast(ecm.at(i))); } std::cout << std::endl; } diff --git a/media_cas_packager_sdk/public/wv_cas_ecm.cc b/media_cas_packager_sdk/public/wv_cas_ecm.cc index 08c48a1..7f9a8f5 100644 --- a/media_cas_packager_sdk/public/wv_cas_ecm.cc +++ b/media_cas_packager_sdk/public/wv_cas_ecm.cc @@ -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; } diff --git a/media_cas_packager_sdk/public/wv_cas_ecm.h b/media_cas_packager_sdk/public/wv_cas_ecm.h index 0d38c43..14bce9d 100644 --- a/media_cas_packager_sdk/public/wv_cas_ecm.h +++ b/media_cas_packager_sdk/public/wv_cas_ecm.h @@ -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; diff --git a/media_cas_packager_sdk/public/wv_cas_ecm_test.cc b/media_cas_packager_sdk/public/wv_cas_ecm_test.cc index 74a3a2a..bc31973 100644 --- a/media_cas_packager_sdk/public/wv_cas_ecm_test.cc +++ b/media_cas_packager_sdk/public/wv_cas_ecm_test.cc @@ -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, + /* even_entitlement_key_id= */ kEvenEntitlementKeyId, + /* even_entitlement_key= */ kEvenEntitlementKey, /* odd_key= */ kOddKey, - /* odd_content_iv= */ "123456789", - /* entitlement_key_id= */ kEntitlementKeyId, - /* entitlement_key= */ kEntitlementKey, &actual_ecm)); + /* odd_content_iv= */ kOddContentIv8Bytes, + /* odd_entitlement_key_id= */ kOddEntitlementKeyId, + /* odd_entitlement_key= */ kOddEntitlementKey, &actual_ecm)); + + EXPECT_EQ( + "4ad40103806576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952" + "a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665" + "6e5f69762e6f64645f656e745f6b65795f69642e2e34cd74b6b998889aad0e71b44bdd8c" + "0e03e31ea68ab80a6ee79f59f0936bc6aa64fe976b6a4a5db2dc7e3ebba4a0bd876f6464" + "5f69762e2e", + absl::BytesToHexString(actual_ecm)); } -TEST_F(WvCasEcmTest, GenerateSingleKeyEcmInvalidContentIv) { +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(INVALID_ARGUMENT, + EXPECT_EQ(OK, wv_cas_ecm_.GenerateSingleKeyEcm( /* even_key= */ kEvenKey, - /* even_content_iv= */ "1234", - /* entitlement_key_id= */ kEntitlementKeyId, - /* entitlement_key= */ kEntitlementKey, &actual_ecm)); + /* even_content_iv= */ kEvenContentIv8Bytes, + /* even_entitlement_key_id= */ kEvenEntitlementKeyId, + /* even_entitlement_key= */ kEvenEntitlementKey, &actual_ecm)); + + EXPECT_EQ( + "4ad40102806576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952" + "a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665" + "6e5f69762e", + absl::BytesToHexString(actual_ecm)); } -TEST_F(WvCasEcmTest, GenerateEcmInvalidContentKey) { - EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8, +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(INVALID_ARGUMENT, + EXPECT_EQ(OK, 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)); + /* even_content_iv= */ + kEvenContentIv16Bytes, + /* even_entitlement_key_id= */ kEvenEntitlementKeyId, + /* even_entitlement_key= */ kEvenEntitlementKey, + /* odd_key= */ kOddKey, + /* odd_content_iv= */ + kOddContentIv16Bytes, + /* odd_entitlement_key_id= */ kOddEntitlementKeyId, + /* odd_entitlement_key= */ kOddEntitlementKey, &actual_ecm)); + + EXPECT_EQ( + "4ad40103c06576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952" + "a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665" + "6e5f69762e2e2e2e2e2e2e2e2e6f64645f656e745f6b65795f69642e2e34cd74b6b99888" + "9aad0e71b44bdd8c0e03e31ea68ab80a6ee79f59f0936bc6aa64fe976b6a4a5db2dc7e3e" + "bba4a0bd876f645f69762e2e2e2e2e2e2e2e2e2e2e", + absl::BytesToHexString(actual_ecm)); } -TEST_F(WvCasEcmTest, GenerateSingleKeyEcmInvalidContentKey) { - EXPECT_EQ(OK, wv_cas_ecm_.Initialize(/* content_iv_size= */ 8, +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(INVALID_ARGUMENT, + EXPECT_EQ(OK, 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, - /* odd_key= */ kOddKey, - /* odd_content_iv= */ kOddContentIv8Bytes, - /* entitlement_key_id= */ kEntitlementKeyId, - /* entitlement_key= */ kEntitlementKey, &actual_ecm)); + /* even_key= */ kEvenKey, + /* even_content_iv= */ + kEvenContentIv16Bytes, + /* even_entitlement_key_id= */ kEvenEntitlementKeyId, + /* even_entitlement_key= */ kEvenEntitlementKey, &actual_ecm)); EXPECT_EQ( - "4ad4010380656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8" - "c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665" - "6e636f6e74656e745f6b65795f69642e2e2e2e2e2e0700509b67763b3f1c356bc1e1dc8b" - "ac99a1e2f95c37d9183cbb96582f3a05fdbe29925c37c6c6a45eb552b5ddf87f8a6f6464" - "636f6e742e", + "4ad40102c06576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952" + "a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665" + "6e5f69762e2e2e2e2e2e2e2e2e", absl::BytesToHexString(actual_ecm)); } -TEST_F(WvCasEcmTest, GenerateSingleKeyEcm8BytesContentIvCtrSuccess) { - 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( - /* even_key= */ kEvenKey, - /* even_content_iv= */ kEvenContentIv8Bytes, - /* entitlement_key_id= */ kEntitlementKeyId, - /* entitlement_key= */ kEntitlementKey, &actual_ecm)); - - EXPECT_EQ( - "4ad4010280656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8" - "c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665" - "6e636f6e74", - absl::BytesToHexString(actual_ecm)); -} - -TEST_F(WvCasEcmTest, GenerateEcm16BytesContentIvCtrSuccess) { - 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( - /* even_key= */ kEvenKey, - /* even_content_iv= */ - absl::StrCat(kEvenContentIv8Bytes, kEvenContentIv8Bytes), - /* odd_key= */ kOddKey, - /* odd_content_iv= */ - absl::StrCat(kOddContentIv8Bytes, kOddContentIv8Bytes), - /* entitlement_key_id= */ kEntitlementKeyId, - /* entitlement_key= */ kEntitlementKey, &actual_ecm)); - - EXPECT_EQ( - "4ad40103c0656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8" - "c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665" - "6e636f6e746576656e636f6e74656e745f6b65795f69642e2e2e2e2e2e0700509b67763b" - "3f1c356bc1e1dc8bac99a1e2f95c37d9183cbb96582f3a05fdbe29925c37c6c6a45eb552" - "b5ddf87f8a6f6464636f6e742e6f6464636f6e742e", - absl::BytesToHexString(actual_ecm)); -} - -TEST_F(WvCasEcmTest, GenerateSingleKeyEcm16BytesContentIvCtrSuccess) { - 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( - /* even_key= */ kEvenKey, - /* even_content_iv= */ - absl::StrCat(kEvenContentIv8Bytes, kEvenContentIv8Bytes), - /* entitlement_key_id= */ kEntitlementKeyId, - /* entitlement_key= */ kEntitlementKey, &actual_ecm)); - - EXPECT_EQ( - "4ad40102c0656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8" - "c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665" - "6e636f6e746576656e636f6e74", - 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( - /* even_key= */ kEvenKey, - /* even_content_iv= */ - absl::StrCat(kEvenContentIv8Bytes, kEvenContentIv8Bytes), - /* odd_key= */ kOddKey, - /* odd_content_iv= */ - absl::StrCat(kOddContentIv8Bytes, kOddContentIv8Bytes), - /* entitlement_key_id= */ kEntitlementKeyId, - /* entitlement_key= */ kEntitlementKey, &actual_ecm)); + EXPECT_EQ(OK, + wv_cas_ecm_.GenerateEcm( + /* even_key= */ kEvenKey, + /* even_content_iv= */ + kEvenContentIv16Bytes, + /* even_entitlement_key_id= */ kEvenEntitlementKeyId, + /* even_entitlement_key= */ kEvenEntitlementKey, + /* odd_key= */ kOddKey, + /* odd_content_iv= */ + 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( - /* even_key= */ kEvenKey, - /* even_content_iv= */ - absl::StrCat(kEvenContentIv8Bytes, kEvenContentIv8Bytes), - /* entitlement_key_id= */ kEntitlementKeyId, - /* entitlement_key= */ kEntitlementKey, &actual_ecm)); + EXPECT_EQ(OK, + wv_cas_ecm_.GenerateSingleKeyEcm( + /* even_key= */ kEvenKey, + /* even_content_iv= */ + 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( - /* even_key= */ kCsaEvenKey, - /* even_content_iv= */ - kEvenContentIv8Bytes, - /* odd_key= */ kCsaOddKey, - /* odd_content_iv= */ - kOddContentIv8Bytes, - /* entitlement_key_id= */ kEntitlementKeyId, - /* entitlement_key= */ kEntitlementKey, &actual_ecm)); + 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, + /* 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( - /* even_key= */ kCsaEvenKey, - /* even_content_iv= */ - kEvenContentIv8Bytes, - /* entitlement_key_id= */ kEntitlementKeyId, - /* entitlement_key= */ kEntitlementKey, &actual_ecm)); + EXPECT_EQ(OK, + wv_cas_ecm_.GenerateSingleKeyEcm( + /* even_key= */ kCsaEvenKey, + /* even_content_iv= */ + kEvenContentIv8Bytes, + /* 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)); }