Source release 17.1.0

core/test/test_base.h

@@ -1,20 +1,22 @@
 // Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary
-// source code may only be used and distributed under the Widevine Master
-// License Agreement.
+// source code may only be used and distributed under the Widevine License
+// Agreement.
 
 #ifndef WVCDM_CORE_TEST_BASE_H_
 #define WVCDM_CORE_TEST_BASE_H_
 
+#include <gtest/gtest.h>
+
+#include <memory>
 #include <string>
 #include <vector>
 
-#include <gtest/gtest.h>
-
 #include "cdm_engine.h"
 #include "config_test_env.h"
+#include "create_test_file_system.h"
 #include "crypto_session.h"
 #include "metrics_collections.h"
-#include "oec_session_util.h"
+#include "oemcrypto_types.h"
 #include "string_conversions.h"
 
 namespace wvcdm {
@@ -26,7 +28,7 @@ class WvCdmTestBase : public ::testing::Test {
   ~WvCdmTestBase() override {}
   void SetUp() override;
   virtual std::string binary_key_id() const {
-    return a2bs_hex(config_.key_id());
+    return wvutil::a2bs_hex(config_.key_id());
   }
 
   // Returns true if the test program should continue, if false, the caller
@@ -63,9 +65,12 @@ class WvCdmTestBase : public ::testing::Test {
   static std::string SignHMAC(const std::string& message,
                               const std::vector<uint8_t>& key);
 
-  // The default test configuration.  This is influenced by command line
-  // arguments before any tests are created.
-  static ConfigTestEnv default_config_;
+  // The default test configuration.  This is created in Initialize() and
+  // influenced by command line arguments before any tests are created.
+  static std::unique_ptr<ConfigTestEnv> default_config_;
+
+  // If the tests should use the QA test keybox.
+  static bool use_qa_test_keybox_;
 
   // Configuration for an individual test.  This is initialized to be the
   // default configuration, but can be modified by the test itself.
@@ -80,7 +85,7 @@ class WvCdmTestBase : public ::testing::Test {
 // metrics and file system.
 class TestCdmEngine : public CdmEngine {
  public:
-  TestCdmEngine(FileSystem* file_system,
+  TestCdmEngine(wvutil::FileSystem* file_system,
                 std::shared_ptr<metrics::EngineMetrics> metrics)
       : CdmEngine(file_system, metrics) {}
 };
@@ -88,12 +93,13 @@ class TestCdmEngine : public CdmEngine {
 class WvCdmTestBaseWithEngine : public WvCdmTestBase {
  public:
   WvCdmTestBaseWithEngine()
-      : dummy_engine_metrics_(new metrics::EngineMetrics()),
-        cdm_engine_(&file_system_, dummy_engine_metrics_) {}
+      : file_system_(CreateTestFileSystem()),
+        dummy_engine_metrics_(new metrics::EngineMetrics()),
+        cdm_engine_(file_system_.get(), dummy_engine_metrics_) {}
 
  protected:
-  FileSystem file_system_;
-  shared_ptr<metrics::EngineMetrics> dummy_engine_metrics_;
+  std::unique_ptr<wvutil::FileSystem> file_system_;
+  std::shared_ptr<metrics::EngineMetrics> dummy_engine_metrics_;
   TestCdmEngine cdm_engine_;
 };
 
@@ -102,69 +108,7 @@ class TestCryptoSession : public CryptoSession {
   explicit TestCryptoSession(metrics::CryptoMetrics* crypto_metrics);
   // This intercepts nonce flood errors, which is useful for tests that request
   // many nonces and are not time critical.
-  CdmResponseType GenerateNonce(uint32_t* nonce);
-};
-
-// A holder for a license.  Users of this class will first open a session with
-// OpenSession, then generate a key request with GenerateKeyRequest, and then
-// call CreateDefaultLicense to create a bare-bones license with no keys in it.
-// The user may then access the license to adjust the policy, or use AddKey to
-// add keys to the license.  The license is then loaded via SignAndLoadLicense.
-class TestLicenseHolder {
- public:
-  // cdm_engine must exist and outlive the TestLicenseHolder.
-  TestLicenseHolder(CdmEngine* cdm_engine);
-  ~TestLicenseHolder();
-  // Caller must ensure device already provisioned.
-  void OpenSession(const std::string& key_system);
-  void CloseSession();
-  // Use the cdm_engine to generate a key request in the session.  This should
-  // be called after OpenSession.  This saves the signed license request, so
-  // that the DRM certificate can be extracted in CreateDefaultLicense.
-  void GenerateKeyRequest(const std::string& key_id,
-                          const std::string& init_data_type_string);
-  // Create a bare-bones license from the license request. After this, the user
-  // may access and modify the license using license() below.
-  void CreateDefaultLicense();
-  // Sign the license using the DRM certificate's RSA key.  Then the license is
-  // passed to the cdm_engine using AddKey.  After this, the license is loaded
-  // and the keys may be used.
-  void SignAndLoadLicense();
-
-  // The session id.  This is only valid after a call to OpenSession.
-  const std::string& session_id() { return session_id_; }
-  // The license protobuf.  This is only valid after CreateDefaultLicense.
-  video_widevine::License* license() { return &license_; };
-  // Add a key with the given key control block and key data.
-  // If the block's verification is empty, it will be set to a valid value.
-  // The key data is encrypted correctly.
-  video_widevine::License_KeyContainer* AddKey(
-      const KeyId& key_id, const std::vector<uint8_t>& key_data,
-      const wvoec::KeyControlBlock& block);
-
- private:
-  // Helper method to generate mac keys and encryption keys for the license.
-  void DeriveKeysFromSessionKey();
-  // Derive a single mac key or encryption key using CMAC.
-  bool DeriveKey(const std::vector<uint8_t>& key,
-                 const std::vector<uint8_t>& context, int counter,
-                 std::vector<uint8_t>* out);
-  // Add the mac keys to the license.
-  void AddMacKey();
-
-  CdmEngine* cdm_engine_;
-  std::string signed_license_request_data_;
-  std::string license_request_data_;
-  std::string session_id_;
-  bool session_opened_;
-  RsaPublicKey rsa_key_;  // From the DRM Certificate.
-  video_widevine::License license_;
-  std::vector<uint8_t> derived_mac_key_server_;
-  std::vector<uint8_t> derived_mac_key_client_;
-  std::vector<uint8_t> mac_key_server_;
-  std::vector<uint8_t> mac_key_client_;
-  std::vector<uint8_t> enc_key_;
-  std::vector<uint8_t> session_key_;
+  CdmResponseType GenerateNonce(uint32_t* nonce) override;
 };
 
 // Given a PSSH data structure, this makes a PSSH string for use in