OEMCrypto v16.2

Merge from Widevine repo of http://go/wvgerrit/93404

This is the unit tests, reference code, and documentation for
OEMCrypto v16.2. Backwards compatibility should work for a v15
OEMCrypto.

Some review comments will be addressed in future CLs.

Bug: 141247171
Test: Unit tests
Test: Media GTS tests on bonito
Change-Id: I9d427c07580e180c0a4cfdc4a68f538d351c0ddd

libwvdrmengine/oemcrypto/test/oec_session_util.h

@@ -133,13 +133,6 @@ uint32_t htonl_fnc(uint32_t x);
 // Prints error string from BoringSSL
 void dump_boringssl_error();
 
-// Given a message and field, returns an OEMCrypto_Substring with the field's
-// offset into the message and its length. If |set_zero| is true, both the
-// offset and length will be zero.
-OEMCrypto_Substring GetSubstring(const std::string& message = "",
-                                 const std::string& field = "",
-                                 bool set_zero = false);
-
 class Session;
 // The prototype of the OEMCrypto function to prepare and sign a request.
 typedef OEMCryptoResult (*PrepAndSignRequest_t)(
@@ -159,7 +152,7 @@ class RoundTrip {
         core_response_(),
         response_data_(),
         encrypted_response_data_(),
-        message_size_(sizeof(ResponseData) + kMaxCoreMessage){};
+        required_message_size_(0) {}
   virtual ~RoundTrip() {}
 
   // Have OEMCrypto sign a request message and then verify the signature and the
@@ -190,9 +183,7 @@ class RoundTrip {
   }
 
   // Set the size of the buffer used the encrypted license.
-  void set_message_size(size_t size) { message_size_ = size; }
-  // The size of the encrypted message.
-  size_t message_size() { return message_size_; }
+  void set_message_size(size_t size) { required_message_size_ = size; }
   std::vector<uint8_t>& response_signature() { return response_signature_; }
   const std::string& serialized_core_message() const {
     return serialized_core_message_;
@@ -218,7 +209,9 @@ class RoundTrip {
   CoreRequest core_request_;
   CoreResponse core_response_;
   ResponseData response_data_, encrypted_response_data_;
-  size_t message_size_;  // How much of the padded message to use.
+  // Message buffers will be at least this big. Tests for loading and signing
+  // messages will increase all buffers to this size.
+  size_t required_message_size_;
   std::vector<uint8_t> response_signature_;
   std::string serialized_core_message_;
   std::vector<uint8_t> encrypted_response_;
@@ -257,6 +250,15 @@ class ProvisioningRoundTrip
   // Verify the values of the core response.
   virtual void FillAndVerifyCoreRequest(
       const std::string& core_message_string) override;
+  // Load the response, without the retry. Called by LoadResponse.
+  OEMCryptoResult LoadResponseNoRetry(Session* session,
+                                      size_t* wrapped_key_length);
+  // This takes a pointer in the response_data_ and remaps it to the same
+  // pointer within the encrypted message. This is used for backwards
+  // compatibliity testing, so that a v15 oemcrypto will accept range checks.
+  template <typename T>
+  const T* RemapPointer(const T* response_pointer) const;
+
   uint32_t allowed_schemes_;
   Encryptor encryptor_;
   // The message key used for Prov 3.0.
@@ -317,7 +319,7 @@ class LicenseRoundTrip
   }
   // Change the hash of the core request. This should cause the response to be
   // rejected.
-  void BreakRequestHash() { core_response_.request_hash[3] ^= 42; }
+  void BreakRequestHash() { request_hash_[3] ^= 42; }
   // Set the API version for the license itself. This will be used in
   // CreateDefaultResponse.
   void set_api_version(uint32_t api_version) { api_version_ = api_version; }
@@ -363,6 +365,7 @@ class LicenseRoundTrip
   // Whether this is a content license or an entitlement license. Used in
   // CreateDefaultResponse.
   OEMCrypto_LicenseType license_type_;
+  uint8_t request_hash_[ODK_SHA256_HASH_SIZE];
 };
 
 class RenewalRoundTrip
@@ -377,11 +380,20 @@ class RenewalRoundTrip
       : RoundTrip(license_messages->session()),
         license_messages_(license_messages),
         refresh_object_(),
+        renewal_duration_seconds_(
+            license_messages->core_response()
+                .timer_limits.initial_renewal_duration_seconds),
         is_release_(false) {}
   void CreateDefaultResponse() override;
   void EncryptAndSignResponse() override;
   OEMCryptoResult LoadResponse() override { return LoadResponse(session_); }
   OEMCryptoResult LoadResponse(Session* session) override;
+  uint64_t renewal_duration_seconds() const {
+    return renewal_duration_seconds_;
+  }
+  void set_renewal_duration_seconds(uint64_t renewal_duration_seconds) {
+    renewal_duration_seconds_ = renewal_duration_seconds;
+  }
   void set_is_release(bool is_release) { is_release_ = is_release; }
 
  protected:
@@ -393,6 +405,7 @@ class RenewalRoundTrip
       const std::string& core_message_string) override;
   LicenseRoundTrip* license_messages_;
   OEMCrypto_KeyRefreshObject refresh_object_;
+  uint64_t renewal_duration_seconds_;
   bool is_release_;  // If this is a license release, and not a real renewal.
 };