Source release 16.2.0

core/include/crypto_session.h

@@ -44,11 +44,11 @@ class CryptoSessionFactory;
 class CryptoSession {
  public:
   using HdcpCapability = OEMCrypto_HDCP_Capability;
-  typedef enum {
+  enum UsageDurationStatus {
     kUsageDurationsInvalid = 0,
     kUsageDurationPlaybackNotBegun = 1,
     kUsageDurationsValid = 2,
-  } UsageDurationStatus;
+  };
 
   struct SupportedCertificateTypes {
     bool rsa_2048_bit;
@@ -64,6 +64,17 @@ class CryptoSession {
 
   virtual ~CryptoSession();
 
+  // This method will try to terminate OEMCrypto if |session_size_| is 0.
+  // A platform configured property |delay_oem_crypto_termination| will
+  // determine if termination occurs immediately or after a delay.
+  // If termination is delayed, a countdown mechanism is employed.
+  // Call |TryTerminate| periodically until it no longer returns true.
+  // To immediately terminate call |DisableDelayedTermination| before calling
+  // |TryTerminate|.
+  static bool TryTerminate();
+
+  static void DisableDelayedTermination();
+
   virtual CdmResponseType GetProvisioningToken(std::string* client_token);
   virtual CdmClientTokenType GetPreProvisionTokenType() {
     return pre_provision_token_type_;
@@ -75,6 +86,8 @@ class CryptoSession {
   virtual CdmSecurityLevel GetSecurityLevel(SecurityLevel requested_level);
   virtual bool GetApiVersion(uint32_t* version);
   virtual bool GetApiVersion(SecurityLevel requested_level, uint32_t* version);
+  virtual bool GetApiMinorVersion(SecurityLevel requested_level,
+                                  uint32_t* minor_version);
 
   virtual CdmResponseType GetInternalDeviceUniqueId(std::string* device_id);
   virtual CdmResponseType GetExternalDeviceUniqueId(std::string* device_id);
@@ -89,13 +102,15 @@ class CryptoSession {
   virtual bool IsOpen() { return open_; }
   virtual CryptoSessionId oec_session_id() { return oec_session_id_; }
 
-  // Key request/response
+  // All request/responses
   virtual const std::string& request_id() { return request_id_; }
-  virtual CdmResponseType PrepareRequest(const std::string& key_deriv_message,
-                                         bool is_provisioning,
-                                         std::string* signature);
-  virtual CdmResponseType PrepareRenewalRequest(const std::string& message,
-                                                std::string* signature);
+  virtual CdmResponseType GenerateNonce(uint32_t* nonce);
+
+  // License request/responses
+  virtual CdmResponseType PrepareAndSignLicenseRequest(
+      const std::string& message, std::string* core_message,
+      std::string* signature);
+  // V15 licenses.
   virtual CdmResponseType LoadKeys(const std::string& message,
                                    const std::string& signature,
                                    const std::string& mac_key_iv,
@@ -104,52 +119,46 @@ class CryptoSession {
                                    const std::string& provider_session_token,
                                    const std::string& srm_requirement,
                                    CdmLicenseKeyType key_type);
-  virtual CdmResponseType LoadEntitledContentKeys(
-      const std::vector<CryptoKey>& key_array);
-  virtual CdmResponseType LoadCertificatePrivateKey(std::string& wrapped_key);
+  // V16 licenses.
+  virtual CdmResponseType LoadLicense(const std::string& signed_message,
+                                      const std::string& core_message,
+                                      const std::string& signature,
+                                      CdmLicenseKeyType key_type);
+
+  // Renewal request/responses
+  virtual CdmResponseType PrepareAndSignRenewalRequest(
+      const std::string& message, std::string* core_message,
+      std::string* signature);
+  // V15 licenses.
   virtual CdmResponseType RefreshKeys(const std::string& message,
                                       const std::string& signature,
-                                      int num_keys, const CryptoKey* key_array);
-  virtual CdmResponseType GenerateNonce(uint32_t* nonce);
+                                      const std::vector<CryptoKey>& key_array);
+  // V16 licenses.
+  virtual CdmResponseType LoadRenewal(const std::string& signed_message,
+                                      const std::string& core_message,
+                                      const std::string& signature);
+
+  // Entitled content Keys.
+  virtual CdmResponseType LoadEntitledContentKeys(
+      const std::vector<CryptoKey>& key_array);
+
+  // Provisioning request/responses
   virtual CdmResponseType GenerateDerivedKeys(const std::string& message);
   virtual CdmResponseType GenerateDerivedKeys(const std::string& message,
                                               const std::string& session_key);
-  virtual CdmResponseType RewrapCertificate(const std::string& signed_message,
-                                            const std::string& signature,
-                                            const std::string& nonce,
-                                            const std::string& private_key,
-                                            const std::string& iv,
-                                            const std::string& wrapping_key,
-                                            std::string* wrapped_private_key);
+  virtual CdmResponseType PrepareAndSignProvisioningRequest(
+      const std::string& message, std::string* core_message,
+      std::string* signature);
+  virtual CdmResponseType LoadProvisioning(const std::string& signed_message,
+                                           const std::string& core_message,
+                                           const std::string& signature,
+                                           std::string* wrapped_private_key);
+  virtual CdmResponseType LoadCertificatePrivateKey(
+      const std::string& wrapped_key);
 
   // Media data path
-  virtual CdmResponseType Decrypt(const CdmDecryptionParameters& params);
+  virtual CdmResponseType Decrypt(const CdmDecryptionParametersV16& params);
 
-  // Usage related methods
-  // The overloaded method with |security_level| may be called without a
-  // preceding call to Open. The other method must call Open first.
-  virtual bool UsageInformationSupport(bool* has_support);
-  virtual bool UsageInformationSupport(SecurityLevel security_level,
-                                       bool* has_support);
-  virtual CdmResponseType UpdateUsageInformation();  // only for OEMCrypto v9-12
-  virtual CdmResponseType DeactivateUsageInformation(
-      const std::string& provider_session_token);
-  virtual CdmResponseType GenerateUsageReport(
-      const std::string& provider_session_token, std::string* usage_report,
-      UsageDurationStatus* usage_duration_status,
-      int64_t* seconds_since_started, int64_t* seconds_since_last_played);
-  virtual CdmResponseType ReleaseUsageInformation(
-      const std::string& message, const std::string& signature,
-      const std::string& provider_session_token);
-  // Delete a usage information for a single token.  This does not require
-  // a signed message from the server.
-  virtual CdmResponseType DeleteUsageInformation(
-      const std::string& provider_session_token);
-  // Delete usage information for a list of tokens.  This does not require
-  // a signed message from the server.
-  virtual CdmResponseType DeleteMultipleUsageInformation(
-      const std::vector<std::string>& provider_session_tokens);
-  virtual CdmResponseType DeleteAllUsageReports();
   virtual bool IsAntiRollbackHwPresent();
 
   // The overloaded methods with |security_level| may be called without a
@@ -178,7 +187,11 @@ class CryptoSession {
                                    std::string* info);
   virtual bool GetBuildInformation(std::string* info);
 
-  virtual uint32_t IsDecryptHashSupported(SecurityLevel security_level);
+  virtual bool GetMaximumUsageTableEntries(SecurityLevel security_level,
+                                           size_t* number_of_entries);
+
+  virtual bool GetDecryptHashSupport(SecurityLevel security_level,
+                                     uint32_t* hash_support);
 
   virtual CdmResponseType SetDecryptHash(uint32_t frame_number,
                                          const std::string& hash);
@@ -204,32 +217,49 @@ class CryptoSession {
                                         CdmSigningAlgorithm algorithm,
                                         const std::string& signature);
 
-  // Usage table header and usage entry related methods
+  // Usage table API related methods.
+  //   Used to manipulate the CDM managed usage table header & entries,
+  //   delegating calls to OEMCrypto.
+
+  // Usage support.
+  virtual CdmResponseType GetUsageSupportType(CdmUsageSupportType* type);
+
+  // The overloaded method with |security_level| may be called without a
+  // preceding call to Open. The other method must call Open first.
+  virtual bool UsageInformationSupport(bool* has_support);
+  virtual bool UsageInformationSupport(SecurityLevel security_level,
+                                       bool* has_support);
+
+  // Usage report.
+  virtual CdmResponseType DeactivateUsageInformation(
+      const std::string& provider_session_token);
+  virtual CdmResponseType GenerateUsageReport(
+      const std::string& provider_session_token, std::string* usage_report,
+      UsageDurationStatus* usage_duration_status,
+      int64_t* seconds_since_started, int64_t* seconds_since_last_played);
+
+  // Usage table header.
   virtual UsageTableHeader* GetUsageTableHeader() {
     return usage_table_header_;
   }
-  virtual CdmResponseType GetUsageSupportType(CdmUsageSupportType* type);
+
   virtual CdmResponseType CreateUsageTableHeader(
       CdmUsageTableHeader* usage_table_header);
   virtual CdmResponseType LoadUsageTableHeader(
       const CdmUsageTableHeader& usage_table_header);
+
+  // Usage entry.
   virtual CdmResponseType CreateUsageEntry(uint32_t* entry_number);
   virtual CdmResponseType LoadUsageEntry(uint32_t entry_number,
                                          const CdmUsageEntry& usage_entry);
   virtual CdmResponseType UpdateUsageEntry(
       CdmUsageTableHeader* usage_table_header, CdmUsageEntry* usage_entry);
+
+  // Adjust usage entries in usage table header.
   virtual CdmResponseType ShrinkUsageTableHeader(
       uint32_t new_entry_count, CdmUsageTableHeader* usage_table_header);
   virtual CdmResponseType MoveUsageEntry(uint32_t new_entry_number);
-  virtual bool CreateOldUsageEntry(uint64_t time_since_license_received,
-                                   uint64_t time_since_first_decrypt,
-                                   uint64_t time_since_last_decrypt,
-                                   UsageDurationStatus status,
-                                   const std::string& server_mac_key,
-                                   const std::string& client_mac_key,
-                                   const std::string& provider_session_token);
-  virtual CdmResponseType CopyOldUsageEntry(
-      const std::string& provider_session_token);
+
   virtual bool GetAnalogOutputCapabilities(bool* can_support_output,
                                            bool* can_disable_output,
                                            bool* can_support_cgms_a);
@@ -249,7 +279,10 @@ class CryptoSession {
  private:
   friend class CryptoSessionForTest;
   friend class CryptoSessionFactory;
+#if defined(UNIT_TEST)
+  friend class CertificateProvisioningTest;
   friend class WvCdmTestBase;
+#endif
 
   // The global factory method can be set to generate special crypto sessions
   // just for testing.  These sessions will avoid nonce floods and will ask
@@ -261,33 +294,17 @@ class CryptoSession {
   }
 
   void Init();
-  void Terminate();
   CdmResponseType GetTokenFromKeybox(std::string* token);
   CdmResponseType GetTokenFromOemCert(std::string* token);
   static bool ExtractSystemIdFromOemCert(const std::string& oem_cert,
                                          uint32_t* system_id);
   CdmResponseType GetSystemIdInternal(uint32_t* system_id);
-  CdmResponseType GenerateSignature(const std::string& message,
-                                    std::string* signature);
   CdmResponseType GenerateRsaSignature(const std::string& message,
                                        std::string* signature);
+  size_t GetMaxSubsampleRegionSize();
 
   bool SetDestinationBufferType();
 
-  CdmResponseType RewrapDeviceRSAKey(const std::string& message,
-                                     const std::string& signature,
-                                     const std::string& nonce,
-                                     const std::string& enc_rsa_key,
-                                     const std::string& rsa_key_iv,
-                                     std::string* wrapped_rsa_key);
-
-  CdmResponseType RewrapDeviceRSAKey30(const std::string& message,
-                                       const std::string& nonce,
-                                       const std::string& private_key,
-                                       const std::string& iv,
-                                       const std::string& wrapping_key,
-                                       std::string* wrapped_private_key);
-
   CdmResponseType SelectKey(const std::string& key_id,
                             CdmCipherMode cipher_mode);
 
@@ -299,17 +316,24 @@ class CryptoSession {
       CdmEncryptionAlgorithm algorithm);
   size_t GenericEncryptionBlockSize(CdmEncryptionAlgorithm algorithm);
 
-  // These methods are used when a subsample exceeds the maximum buffer size
-  // that the device can handle.
-  OEMCryptoResult CopyBufferInChunks(
-      const CdmDecryptionParameters& params,
-      OEMCrypto_DestBufferDesc buffer_descriptor);
-  OEMCryptoResult DecryptInChunks(
-      const CdmDecryptionParameters& params,
-      const OEMCrypto_DestBufferDesc& full_buffer_descriptor,
-      const OEMCrypto_CENCEncryptPatternDesc& pattern_descriptor,
-      size_t max_chunk_size);
-  static void IncrementIV(uint64_t increase_by, std::vector<uint8_t>* iv_out);
+  // These methods fall back into each other in the order given, depending on
+  // how much data they were given and how much data OEMCrypto can accept in one
+  // call.
+  OEMCryptoResult DecryptMultipleSamples(
+      const std::vector<OEMCrypto_SampleDescription>& samples,
+      CdmCipherMode cipher_mode,
+      const OEMCrypto_CENCEncryptPatternDesc& pattern);
+  OEMCryptoResult DecryptSample(
+      const OEMCrypto_SampleDescription& sample, CdmCipherMode cipher_mode,
+      const OEMCrypto_CENCEncryptPatternDesc& pattern);
+  OEMCryptoResult LegacyDecrypt(
+      const OEMCrypto_SampleDescription& sample, CdmCipherMode cipher_mode,
+      const OEMCrypto_CENCEncryptPatternDesc& pattern);
+  OEMCryptoResult LegacyCopyBufferInChunks(
+      const OEMCrypto_SampleDescription& sample, size_t max_chunk_size);
+  OEMCryptoResult LegacyDecryptInChunks(
+      const OEMCrypto_SampleDescription& sample, CdmCipherMode cipher_mode,
+      const OEMCrypto_CENCEncryptPatternDesc& pattern, size_t max_chunk_size);
 
   // These methods should be used to take the various CryptoSession mutexes in
   // preference to taking the mutexes directly.
@@ -332,7 +356,7 @@ class CryptoSession {
   // Initialization & Termination  |         WithOecWriteLock()
   // Property                      |          WithOecReadLock()
   // Session Initialization        |         WithOecWriteLock()
-  // Usage Table                   |         WithOecWriteLock()
+  // Usage Table Header & Entries  |         WithOecWriteLock()
   // Session                       |       WithOecSessionLock()
   //
   // Note that accessing |key_session_| often accesses the OEMCrypto session, so
@@ -380,6 +404,7 @@ class CryptoSession {
 
   static bool initialized_;
   static int session_count_;
+  static int termination_counter_;
 
   metrics::CryptoMetrics* metrics_;
   metrics::TimerMetric life_span_;
@@ -396,7 +421,6 @@ class CryptoSession {
   bool is_destination_buffer_type_valid_;
   SecurityLevel requested_security_level_;
 
-  bool is_usage_support_type_valid_;
   CdmUsageSupportType usage_support_type_;
   UsageTableHeader* usage_table_header_;
   static UsageTableHeader* usage_table_header_l1_;
@@ -405,8 +429,15 @@ class CryptoSession {
   std::string request_id_;
   static std::atomic<uint64_t> request_id_index_source_;
 
-  CdmCipherMode cipher_mode_;
   uint32_t api_version_;
+  size_t max_subsample_region_size_;
+
+  // Stores the most recent error code returned from a call to
+  // OEMCrypto_DecryptCENC.  This is used to reduce the total number of
+  // error logs for decrypt calls, as there could be a large number of
+  // same error code in sequence of each other.  A value of
+  // OEMCrypto_SUCCESS indicates that no error have yet occurred.
+  OEMCryptoResult last_decrypt_error_ = OEMCrypto_SUCCESS;
 
   // In order to avoid creating a deadlock if instantiation needs to take any
   // of the CryptoSession static mutexes, |factory_| is protected by its own
@@ -415,7 +446,7 @@ class CryptoSession {
   static std::unique_ptr<CryptoSessionFactory> factory_;
 
   CORE_DISALLOW_COPY_AND_ASSIGN(CryptoSession);
-};
+};  // class CryptoSession
 
 class CryptoSessionFactory {
  public: