OEMCrypto Usage Tables

This CL adds usage tables to the OEMCrypto reference implementation
(mock) and unit tests.

There is also a new parameter called oem_crypto_require_usage_tables
that determines if the usage tables are required or not.  This is set
to true for Android and false for all other platforms.

This CL is most of OEMCrypto version 9 updates.

This CL is a copy of
https://widevine-internal-review.googlesource.com/#/c/9720
https://widevine-internal-review.googlesource.com/#/c/9874
https://widevine-internal-review.googlesource.com/#/c/9873

Change-Id: I78c4f7651306f9f79ba2260c3e04fb1eca7e20e3

libwvdrmengine/cdm/core/include/properties.h

@@ -39,6 +39,9 @@ class Properties {
   static inline bool oem_crypto_use_userspace_buffers() {
     return oem_crypto_use_userspace_buffers_;
   }
+  static inline bool oem_crypto_require_usage_tables() {
+    return oem_crypto_require_usage_tables_;
+  }
   static inline bool use_certificates_as_identification() {
     return use_certificates_as_identification_;
   }
@@ -87,6 +90,9 @@ class Properties {
   static void set_oem_crypto_use_userspace_buffers(bool flag) {
     oem_crypto_use_userspace_buffers_ = flag;
   }
+  static void set_oem_crypto_require_usage_tables(bool flag) {
+    oem_crypto_require_usage_tables_ = flag;
+  }
   static void set_use_certificates_as_identification(bool flag) {
     use_certificates_as_identification_ = flag;
   }
@@ -104,6 +110,7 @@ class Properties {
   static bool oem_crypto_use_secure_buffers_;
   static bool oem_crypto_use_fifo_;
   static bool oem_crypto_use_userspace_buffers_;
+  static bool oem_crypto_require_usage_tables_;
   static bool use_certificates_as_identification_;
   static bool decrypt_with_empty_session_support_;
   static bool security_level_path_backward_compatibility_support_;

libwvdrmengine/cdm/core/include/string_conversions.h

@@ -21,6 +21,7 @@ std::vector<uint8_t> Base64SafeDecode(const std::string& bin_input);
 std::string HexEncode(const uint8_t* bytes, unsigned size);
 std::string IntToString(int value);
 std::string UintToString(unsigned int value);
+int64_t htonll64(int64_t x);
 
 };  // namespace wvcdm
 

libwvdrmengine/cdm/core/src/properties.cpp

@@ -14,6 +14,7 @@ bool Properties::require_explicit_renew_request_;
 bool Properties::oem_crypto_use_secure_buffers_;
 bool Properties::oem_crypto_use_fifo_;
 bool Properties::oem_crypto_use_userspace_buffers_;
+bool Properties::oem_crypto_require_usage_tables_;
 bool Properties::use_certificates_as_identification_;
 bool Properties::decrypt_with_empty_session_support_;
 bool Properties::security_level_path_backward_compatibility_support_;
@@ -25,6 +26,7 @@ void Properties::Init() {
   oem_crypto_use_secure_buffers_ = kPropertyOemCryptoUseSecureBuffers;
   oem_crypto_use_fifo_ = kPropertyOemCryptoUseFifo;
   oem_crypto_use_userspace_buffers_ = kPropertyOemCryptoUseUserSpaceBuffers;
+  oem_crypto_require_usage_tables_ = kPropertyOemCryptoRequireUsageTable;
   use_certificates_as_identification_ =
       kPropertyUseCertificatesAsIdentification;
   decrypt_with_empty_session_support_ = kDecryptWithEmptySessionSupport;

libwvdrmengine/cdm/core/src/string_conversions.cpp

@@ -2,6 +2,7 @@
 
 #include "string_conversions.h"
 
+#include <arpa/inet.h>
 #include <ctype.h>
 #include <iostream>
 #include <stdio.h>
@@ -167,4 +168,21 @@ std::string UintToString(unsigned int value) {
   return out_string;
 }
 
+int64_t htonll64(int64_t x) {  // Convert to big endian (network-byte-order)
+  union {
+    uint32_t array[2];
+    int64_t number;
+  } mixed;
+  mixed.number = 1;
+  if (mixed.array[0] == 1) {
+    mixed.number = x;  // Little Endian.
+    uint32_t temp = mixed.array[0];
+    mixed.array[0] = htonl(mixed.array[1]);
+    mixed.array[1] = htonl(temp);
+    return mixed.number;
+  } else {
+    return x;  // Big Endian.
+  }
+}
+
 };  // namespace wvcdm

libwvdrmengine/cdm/core/test/base64_test.cpp

@@ -70,4 +70,18 @@ TEST_P(Base64EncodeDecodeTest, EncodeDecodeTest) {
 INSTANTIATE_TEST_CASE_P(ExecutesBase64Test, Base64EncodeDecodeTest,
                         ::testing::ValuesIn(kBase64TestVectors));
 
+class HtoNLL64Test : public ::testing::Test {};
+
+TEST_F(HtoNLL64Test, PositiveNumber) {
+  uint8_t data[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+  int64_t *network_byte_order = reinterpret_cast<int64_t *>(data);
+  int64_t host_byte_order = htonll64(*network_byte_order);
+  EXPECT_EQ(0x0102030405060708, host_byte_order);
+}
+TEST_F(HtoNLL64Test, NegativeNumber) {
+  uint8_t data[8] = {0xfe, 2, 3, 4, 5, 6, 7, 8};
+  int64_t *network_byte_order = reinterpret_cast<int64_t *>(data);
+  int64_t host_byte_order = htonll64(*network_byte_order);
+  EXPECT_EQ(-0x01FdFcFbFaF9F8F8, host_byte_order);
+}
 }  // namespace wvcdm

libwvdrmengine/cdm/include/properties_configuration.h

@@ -22,6 +22,9 @@ const bool kPropertyOemCryptoUseSecureBuffers = true;
 const bool kPropertyOemCryptoUseFifo = false;
 const bool kPropertyOemCryptoUseUserSpaceBuffers = false;
 
+// If true, the unit tests require OEMCrypto to support usage tables.
+const bool kPropertyOemCryptoRequireUsageTable = true;
+
 // If false, keyboxes will be used as client identification
 // and passed as the token in the license request
 const bool kPropertyUseCertificatesAsIdentification = true;