Print uint16 as \x01 not \x1

-------------
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

example/wv_cas_ecm_example.cc

@@ -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 kCsaEvenKey[] = "even_key";                    // 8 bytes
-const char kEvenKey[] = "even_content_key";                         // 16 bytes
+const char kEvenContentIv8Bytes[] = "even_iv.";           // 8 bytes
-const char kCsaEvenKey[] = "12345678";                              // 8 bytes
+const char kEvenEntitlementKeyId[] = "fake_key_id1....";  // 16 bytes
-const char kEvenContentIv8Bytes[] = "evencont";                     // 8 bytes
+const char kEvenEntitlementKey[] =
-const char kEvenContentIv16Bytes[] = "evencontevencont";            // 16 bytes
+    "fakefakefakefakefakefakefake1...";                  // 32 bytes
-const char kOddKey[] = "odd_content_key.";                          // 16 bytes
+const char kCsaOddKey[] = "odd_key.";                    // 8 bytes
-const char kCsaOddKey[] = "87654321";                               // 8 bytes
+const char kOddContentIv8Bytes[] = "odd_iv..";           // 8 bytes
-const char kOddContentIv8Bytes[] = "oddcont.";                      // 8 bytes
+const char kOddEntitlementKeyId[] = "fake_key_id2....";  // 16 bytes
-const char kOddContentIv16Bytes[] = "oddcont.oddcont.";             // 16 bytes
+const char kOddEntitlementKey[] =
-const char kEntitlementKeyId[] = "ent_key_id......";                // 16 bytes
+    "fakefakefakefakefakefakefake2...";  // 32 bytes
-const char kEntitlementKey[] = "entitlement_key.................";  // 32 bytes
 
 int main(int argc, char **argv) {
   widevine::cas::WvCasEcm wv_cas_ecm;
-  widevine::cas::WvCasStatus status =
+  widevine::cas::WvCasStatus status = wv_cas_ecm.Initialize(
-      wv_cas_ecm.Initialize(/* content_iv_size= */ 8, kKeyRotationEnabled,
+      /* 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,
+  status = wv_cas_ecm.GenerateEcm(
-                                  kOddContentIv8Bytes, kEntitlementKeyId,
+      kCsaEvenKey, kEvenContentIv8Bytes, kEvenEntitlementKeyId,
-                                  kEntitlementKey, &ecm);
+      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;
   }

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,
+WvCasStatus WvCasEcm::GenerateEcm(
-                                  const std::string& even_content_iv,
+    const char* const even_key, const char* const even_content_iv,
-                                  const std::string& odd_key,
+    const char* const even_entitlement_key_id,
-                                  const std::string& odd_content_iv,
+    const char* const even_entitlement_key, const char* const odd_key,
-                                  const std::string& entitlement_key_id,
+    const char* const odd_content_iv, const char* const odd_entitlement_key_id,
-                                  const std::string& entitlement_key,
+    const char* const odd_entitlement_key, std::string* ecm) const {
-                                  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_ ||
+  if (even_content_iv_str.size() != content_iv_size_ ||
-      odd_content_iv.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_id= */ even_entitlement_key_id_str,
-      /* even_entitlement_key= */ entitlement_key,
+      /* even_entitlement_key= */ even_entitlement_key_str,
-      /* odd_entitlement_key_id= */ entitlement_key_id,
+      /* odd_entitlement_key_id= */ odd_entitlement_key_id_str,
-      /* odd_entitlement_key= */ entitlement_key);
+      /* 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].key_data = even_key_str;
-  ecm_param.key_params[0].wrapped_key_iv = crypto_util::DeriveIv(even_key);
+  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);
+  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);
+  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].key_data = odd_key_str;
-  ecm_param.key_params[1].wrapped_key_iv = crypto_util::DeriveIv(odd_key);
+  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);
+  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);
+  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,
+WvCasStatus WvCasEcm::GenerateSingleKeyEcm(
-                                           const std::string& even_content_iv,
+    const char* const even_key, const char* const even_content_iv,
-                                           const std::string& entitlement_key_id,
+    const char* const even_entitlement_key_id,
-                                           const std::string& entitlement_key,
+    const char* const even_entitlement_key, std::string* ecm) const {
-                                           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_id= */ even_entitlement_key_id_str,
-      /* even_entitlement_key= */ entitlement_key,
+      /* 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].key_data = even_key_str;
-  ecm_param.key_params[0].wrapped_key_iv = crypto_util::DeriveIv(even_key);
+  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);
+  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);
+  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;
 }
 

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:
+  // Args (all pointer parameters must be not nullptr):
-  // - |even_key| clear even content key
+  // - |even_key| clear even content key, must be 8 bytes for kDvbCsa2,
-  // - |even_content_iv| iv used along with |even_key| for encrypting content
+  //   16 bytes for kAesCtr or kAesCbc
-  // - |odd_key| clear odd content key
+  // - |even_content_iv| iv used along with |even_key| for encrypting content,
-  // - |odd_content_iv| iv used along with |odd_key| for encrypting content
+  //   length must match |content_iv_size| set during initialization
-  // - |entitlement_key_id| key id for |entitlement_key|
+  // - |even_entitlement_key_id| key id for |even_entitlement_key|,
-  // - |entitlement_key| entitlement key used to encrypt even and odd keys
+  //   must be 16 bytes length
-  // - |ecm| for returning the generated ECM, must not be nullptr
+  // - |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
-  //
+  virtual WvCasStatus GenerateEcm(const char* const even_key,
-  // Note:
+                                  const char* const even_content_iv,
-  // - The same |entitlement_key| will be used to encrypt both |even_key|
+                                  const char* const even_entitlement_key_id,
-  //   and |odd_key| in the ECM
+                                  const char* const even_entitlement_key,
-  // - Size of |even_content_iv| and |odd_content_iv| must match
+                                  const char* const odd_key,
-  //   |content_iv_size| set during initialization
+                                  const char* const odd_content_iv,
-  virtual WvCasStatus GenerateEcm(const std::string& even_key,
+                                  const char* const odd_entitlement_key_id,
-                                  const std::string& even_content_iv,
+                                  const char* const odd_entitlement_key,
-                                  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;
 
   // Generate an ECM containing only a singe even key. Can be called when
   // |key_rotation_enabled| is initialized to 'false'.
   //
-  // Args:
+  // Args (all pointer parameters must be not nullptr):
-  // - |even_key| clear even content key
+  // - |even_key| clear even content key, must be 8 bytes for kDvbCsa2,
-  // - |even_content_iv| iv used along with |even_key| for encrypting content
+  //   16 bytes for kAesCtr or kAesCbc
-  // - |entitlement_key_id| key id for |entitlement_key|
+  // - |even_content_iv| iv used along with |even_key| for encrypting content,
-  // - |entitlement_key| entitlement key used to encrypt even key
+  //   length must match |content_iv_size| set during initialization
-  // - |ecm| for returning the generated ECM, must not be nullptr
+  // - |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
-  //
+  virtual WvCasStatus GenerateSingleKeyEcm(
-  // Note:
+      const char* const even_key, const char* const even_content_iv,
-  // - Size of |even_content_iv| and |odd_content_iv| must match
+      const char* const even_entitlement_key_id,
-  //   |content_iv_size| set during initialization
+      const char* const even_entitlement_key, std::string* ecm) const;
-  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;
 
  private:
   bool initialized_ = false;

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 kEvenKey[] = "even_key........";               // 16 bytes
-const char kCsaEvenKey[] = "12345678";                              // 8 bytes
+const char kCsaEvenKey[] = "even_key";                    // 8 bytes
-const char kEvenContentIv8Bytes[] = "evencont";                     // 8 bytes
+const char kCsaEvenKeyWithNul[] = {'\x01', '\x00', '\x00', '\x00',
-const char kOddKey[] = "odd_content_key.";                          // 16 bytes
+                                   '\x00', '\x00', '\x00', '\x01'};
-const char kCsaOddKey[] = "87654321";                               // 8 bytes
+const char kEvenContentIv8Bytes[] = "even_iv.";           // 8 bytes
-const char kOddContentIv8Bytes[] = "oddcont.";                      // 8 bytes
+const char kEvenContentIv16Bytes[] = "even_iv.........";  // 16 bytes
-const char kEntitlementKeyId[] = "ent_key_id......";                // 16 bytes
+const char kEvenEntitlementKeyId[] = "even_ent_key_id.";  // 16 bytes
-const char kEntitlementKey[] = "entitlement_key.................";  // 32 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,
+  EXPECT_EQ(UNAVAILABLE, wv_cas_ecm_.GenerateEcm("", "", "", "", "", "", "", "",
-            wv_cas_ecm_.GenerateEcm("", "", "", "", "", "", &actual_ecm));
+                                                 &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,
+                /* even_entitlement_key_id= */ kEvenEntitlementKeyId,
-                /* odd_content_iv= */ "123456789",
+                /* even_entitlement_key= */ kEvenEntitlementKey,
-                /* 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,
                 /* odd_key= */ kOddKey,
                 /* odd_content_iv= */ kOddContentIv8Bytes,
-                    /* entitlement_key_id= */ kEntitlementKeyId,
+                /* odd_entitlement_key_id= */ kOddEntitlementKeyId,
-                    /* entitlement_key= */ kEntitlementKey, &actual_ecm));
+                /* odd_entitlement_key= */ kOddEntitlementKey, &actual_ecm));
 
   EXPECT_EQ(
-      "4ad4010380656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8"
+      "4ad40103806576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952"
-      "c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665"
+      "a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665"
-      "6e636f6e74656e745f6b65795f69642e2e2e2e2e2e0700509b67763b3f1c356bc1e1dc8b"
+      "6e5f69762e6f64645f656e745f6b65795f69642e2e34cd74b6b998889aad0e71b44bdd8c"
-      "ac99a1e2f95c37d9183cbb96582f3a05fdbe29925c37c6c6a45eb552b5ddf87f8a6f6464"
+      "0e03e31ea68ab80a6ee79f59f0936bc6aa64fe976b6a4a5db2dc7e3ebba4a0bd876f6464"
-      "636f6e742e",
+      "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,
+                /* even_entitlement_key_id= */ kEvenEntitlementKeyId,
-                    /* entitlement_key= */ kEntitlementKey, &actual_ecm));
+                /* even_entitlement_key= */ kEvenEntitlementKey, &actual_ecm));
 
   EXPECT_EQ(
-      "4ad4010280656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8"
+      "4ad40102806576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952"
-      "c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665"
+      "a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665"
-      "6e636f6e74",
+      "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),
+                kOddContentIv16Bytes,
-                    /* entitlement_key_id= */ kEntitlementKeyId,
+                /* odd_entitlement_key_id= */ kOddEntitlementKeyId,
-                    /* entitlement_key= */ kEntitlementKey, &actual_ecm));
+                /* odd_entitlement_key= */ kOddEntitlementKey, &actual_ecm));
 
   EXPECT_EQ(
-      "4ad40103c0656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8"
+      "4ad40103c06576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952"
-      "c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665"
+      "a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665"
-      "6e636f6e746576656e636f6e74656e745f6b65795f69642e2e2e2e2e2e0700509b67763b"
+      "6e5f69762e2e2e2e2e2e2e2e2e6f64645f656e745f6b65795f69642e2e34cd74b6b99888"
-      "3f1c356bc1e1dc8bac99a1e2f95c37d9183cbb96582f3a05fdbe29925c37c6c6a45eb552"
+      "9aad0e71b44bdd8c0e03e31ea68ab80a6ee79f59f0936bc6aa64fe976b6a4a5db2dc7e3e"
-      "b5ddf87f8a6f6464636f6e742e6f6464636f6e742e",
+      "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),
+                kEvenContentIv16Bytes,
-                    /* entitlement_key_id= */ kEntitlementKeyId,
+                /* even_entitlement_key_id= */ kEvenEntitlementKeyId,
-                    /* entitlement_key= */ kEntitlementKey, &actual_ecm));
+                /* even_entitlement_key= */ kEvenEntitlementKey, &actual_ecm));
 
   EXPECT_EQ(
-      "4ad40102c0656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8"
+      "4ad40102c06576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952"
-      "c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665"
+      "a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665"
-      "6e636f6e746576656e636f6e74",
+      "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),
+                kOddContentIv16Bytes,
-                    /* entitlement_key_id= */ kEntitlementKeyId,
+                /* odd_entitlement_key_id= */ kOddEntitlementKeyId,
-                    /* entitlement_key= */ kEntitlementKey, &actual_ecm));
+                /* odd_entitlement_key= */ kOddEntitlementKey, &actual_ecm));
 
   EXPECT_EQ(
-      "4ad40105c0656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8"
+      "4ad40105c06576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952"
-      "c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665"
+      "a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665"
-      "6e636f6e746576656e636f6e74656e745f6b65795f69642e2e2e2e2e2e0700509b67763b"
+      "6e5f69762e2e2e2e2e2e2e2e2e6f64645f656e745f6b65795f69642e2e34cd74b6b99888"
-      "3f1c356bc1e1dc8bac99a1e2f95c37d9183cbb96582f3a05fdbe29925c37c6c6a45eb552"
+      "9aad0e71b44bdd8c0e03e31ea68ab80a6ee79f59f0936bc6aa64fe976b6a4a5db2dc7e3e"
-      "b5ddf87f8a6f6464636f6e742e6f6464636f6e742e",
+      "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),
+                kEvenContentIv16Bytes,
-                    /* entitlement_key_id= */ kEntitlementKeyId,
+                /* even_entitlement_key_id= */ kEvenEntitlementKeyId,
-                    /* entitlement_key= */ kEntitlementKey, &actual_ecm));
+                /* even_entitlement_key= */ kEvenEntitlementKey, &actual_ecm));
 
   EXPECT_EQ(
-      "4ad40104c0656e745f6b65795f69642e2e2e2e2e2ea5693deeba52b4cb27e7021eefa2f8"
+      "4ad40104c06576656e5f656e745f6b65795f69642e3d1798a8729c0a316583bd514cf952"
-      "c2b25f7d48e60627208f4ecca00703aa2467f28b214546a42320e3fa49f936369c657665"
+      "a94350a82ce961f90b1008c9cdce343b2827827aeb1ba30292c0061d80cf50ce7f657665"
-      "6e636f6e746576656e636f6e74",
+      "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,
+                /* odd_entitlement_key_id= */ kOddEntitlementKeyId,
-                    /* entitlement_key= */ kEntitlementKey, &actual_ecm));
+                /* odd_entitlement_key= */ kOddEntitlementKey, &actual_ecm));
 
   EXPECT_EQ(
-      "4ad4010780656e745f6b65795f69642e2e2e2e2e2e1970666a56b136d5d63b009c1a514a"
+      "4ad40107806576656e5f656e745f6b65795f69642ee9c009a9d6a07c7bc3ca82f39c1f10"
-      "948b8c0a380f2c9965134faac9d92992627abdd06f4a268bd12f8989373aece8bd657665"
+      "e6b5f391e74f120cfb876efba02d7f506f0ef185b3398096111dafd86ff7d395a2657665"
-      "6e636f6e74656e745f6b65795f69642e2e2e2e2e2eda65f122610af2c9c9fa7ad18d07f4"
+      "6e5f69762e6f64645f656e745f6b65795f69642e2e7f655fe61e99e89e03ac23df98cc02"
-      "3faab4190ac47c0d974547e8615d7bc64beb665a2d7c36f687ad8ec518e83062076f6464"
+      "1cf21dfe9637c72c3480727ab18332d4ee219e81b8f34c9df2704b0595501832736f6464"
-      "636f6e742e",
+      "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,
+                /* even_entitlement_key_id= */ kEvenEntitlementKeyId,
-                    /* entitlement_key= */ kEntitlementKey, &actual_ecm));
+                /* even_entitlement_key= */ kEvenEntitlementKey, &actual_ecm));
 
   EXPECT_EQ(
-      "4ad4010680656e745f6b65795f69642e2e2e2e2e2e1970666a56b136d5d63b009c1a514a"
+      "4ad40106806576656e5f656e745f6b65795f69642ee9c009a9d6a07c7bc3ca82f39c1f10"
-      "948b8c0a380f2c9965134faac9d92992627abdd06f4a268bd12f8989373aece8bd657665"
+      "e6b5f391e74f120cfb876efba02d7f506f0ef185b3398096111dafd86ff7d395a2657665"
-      "6e636f6e74",
+      "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));
 }