Testbed classes inherit from oemcrypto reference code

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

This CL removes code from the testbed that is duplicated in the
reference code using inheritance.

bug: 76393338 Split mock into reference code and testbed code
test: unit tests
Change-Id: I7b5f5330a595fa1756e6dfdf75bc07addb6107a8

libwvdrmengine/oemcrypto/ref/src/oemcrypto_engine_ref.cpp

@@ -30,7 +30,7 @@ namespace wvoec_ref {
 CryptoEngine::CryptoEngine(scoped_ptr<wvcdm::FileSystem> file_system)
     : root_of_trust_(config_provisioning_method()),
       file_system_(file_system),
-      usage_table_(this) {
+      usage_table_(NULL) {
   ERR_load_crypto_strings();
 }
 
@@ -44,16 +44,25 @@ CryptoEngine::~CryptoEngine() {
   ERR_free_strings();
 }
 
-SessionId CryptoEngine::CreateSession() {
+bool CryptoEngine::Initialize() {
-  wvcdm::AutoLock lock(session_table_lock_);
+  usage_table_.reset(MakeUsageTable());
-  static int unique_id = 1;
+  return true;
-  SessionId sid = (SessionId)++unique_id;
-  SessionContext* sctx =
-      new SessionContext(this, sid, root_of_trust_.SharedRsaKey());
-  sessions_[sid] = sctx;
-  return sid;
 }
 
+SessionId CryptoEngine::OpenSession() {
+  wvcdm::AutoLock lock(session_table_lock_);
+  static OEMCrypto_SESSION unique_id = 1;
+  SessionId id = ++unique_id;
+  sessions_[id] = MakeSession(id);
+  return id;
+}
+
+SessionContext* CryptoEngine::MakeSession(SessionId sid) {
+  return new SessionContext(this, sid, root_of_trust_.SharedRsaKey());
+}
+
+UsageTable* CryptoEngine::MakeUsageTable() { return new UsageTable(this); }
+
 bool CryptoEngine::DestroySession(SessionId sid) {
   SessionContext* sctx = FindSession(sid);
   wvcdm::AutoLock lock(session_table_lock_);

libwvdrmengine/oemcrypto/ref/src/oemcrypto_engine_ref.h

@@ -15,7 +15,7 @@
 
 #include <openssl/rsa.h>
 
-#include "OEMCryptoCENC.h"  // Needed for enums only.
+#include "OEMCryptoCENC.h"
 #include "file_store.h"
 #include "lock.h"
 #include "oemcrypto_auth_ref.h"
@@ -42,7 +42,7 @@ class CryptoEngine {
 
   virtual ~CryptoEngine();
 
-  virtual bool Initialize() { return true; }
+  virtual bool Initialize();
 
   bool ValidRootOfTrust() { return root_of_trust_.Validate(); }
 
@@ -74,7 +74,7 @@ class CryptoEngine {
 
   virtual void Terminate() {}
 
-  SessionId CreateSession();
+  virtual SessionId OpenSession();
 
   bool DestroySession(SessionId sid);
 
@@ -94,7 +94,7 @@ class CryptoEngine {
   // Returns the max HDCP version supported.
   virtual OEMCrypto_HDCP_Capability config_maximum_hdcp_capability();
 
-  UsageTable& usage_table() { return usage_table_; }
+  UsageTable& usage_table() { return *(usage_table_.get()); }
   wvcdm::FileSystem* file_system() { return file_system_.get(); }
 
   // If config_local_display_only() returns true, we pretend we are using a
@@ -172,14 +172,14 @@ class CryptoEngine {
 
  protected:
   explicit CryptoEngine(scoped_ptr<wvcdm::FileSystem> file_system);
+  virtual SessionContext* MakeSession(SessionId sid);
+  virtual UsageTable* MakeUsageTable();
   uint8_t* destination_;
-
- private:
   ActiveSessions sessions_;
   AuthenticationRoot root_of_trust_;
   wvcdm::Lock session_table_lock_;
   scoped_ptr<wvcdm::FileSystem> file_system_;
-  UsageTable usage_table_;
+  scoped_ptr<UsageTable> usage_table_;
 
   CORE_DISALLOW_COPY_AND_ASSIGN(CryptoEngine);
 };

libwvdrmengine/oemcrypto/ref/src/oemcrypto_ref.cpp

@@ -96,7 +96,7 @@ extern "C" OEMCryptoResult OEMCrypto_OpenSession(OEMCrypto_SESSION* session) {
     LOGE("[OEMCrypto_OpenSession(): failed due to too many sessions]");
     return OEMCrypto_ERROR_TOO_MANY_SESSIONS;
   }
-  SessionId sid = crypto_engine->CreateSession();
+  SessionId sid = crypto_engine->OpenSession();
   *session = (OEMCrypto_SESSION)sid;
   return OEMCrypto_SUCCESS;
 }

libwvdrmengine/oemcrypto/ref/src/oemcrypto_scoped_ptr.h

@@ -20,6 +20,7 @@ class scoped_ptr {
  public:
   explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
   T* get() const { return ptr_.get(); }
+  void reset(T* p = NULL) { ptr_.reset(p); }
 
  private:
   std::auto_ptr<T> ptr_;
@@ -35,7 +36,7 @@ class scoped_ptr {
   T& operator*() const { return *ptr_; }
   T* operator->() const { return ptr_.get(); }
   T* get() const { return ptr_.get(); }
-  void reset(T* p = NULL) { ptr_.reset(); }
+  void reset(T* p = NULL) { ptr_.reset(p); }
 
  private:
   std::unique_ptr<T> ptr_;

libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.cpp

@@ -307,16 +307,6 @@ bool SessionContext::GenerateSignature(const uint8_t* message,
     return false;
   }
 
-  bool using_usage_entry_mac_key_client = false;
-  std::vector<uint8_t> usage_entry_mac_key_client;
-  if (usage_entry_status_ == kUsageEntryLoaded) {
-    usage_entry_mac_key_client.assign(
-        usage_entry_->mac_key_client(),
-        usage_entry_->mac_key_client() + wvoec::MAC_KEY_SIZE * sizeof(uint8_t));
-    using_usage_entry_mac_key_client =
-        mac_key_client_ == usage_entry_mac_key_client;
-  }
-
   unsigned int md_len = *signature_length;
   if (HMAC(EVP_sha256(), &mac_key_client_[0], wvoec::MAC_KEY_SIZE, message,
            message_length, signature, &md_len)) {
@@ -818,6 +808,7 @@ OEMCryptoResult SessionContext::RefreshKey(
   Key* content_key = session_keys_->Find(key_id);
 
   if (NULL == content_key) {
+    LOGE("Key ID not found.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
 
@@ -840,6 +831,7 @@ OEMCryptoResult SessionContext::RefreshKey(
 
   KeyControlBlock key_control_block(control);
   if (!key_control_block.valid()) {
+    LOGE("Error parsing key control.");
     return OEMCrypto_ERROR_INVALID_CONTEXT;
   }
   if ((key_control_block.control_bits() & wvoec::kControlNonceEnabled) &&

libwvdrmengine/oemcrypto/ref/src/oemcrypto_session.h

@@ -14,14 +14,14 @@
 
 #include <openssl/rsa.h>
 
-#include "OEMCryptoCENC.h"  // Needed for enums only.
+#include "OEMCryptoCENC.h"
 #include "oemcrypto_auth_ref.h"
 #include "oemcrypto_key_ref.h"
 #include "oemcrypto_nonce_table.h"
 #include "oemcrypto_rsa_key_shared.h"
 #include "oemcrypto_session_key_table.h"
-#include "oemcrypto_usage_table_ref.h"
 #include "oemcrypto_types.h"
+#include "oemcrypto_usage_table_ref.h"
 
 namespace wvoec_ref {
 
@@ -74,26 +74,25 @@ class SessionContext {
         usage_entry_(NULL),
         srm_requirements_status_(NoSRMVersion),
         usage_entry_status_(kNoUsageEntry) {}
-  ~SessionContext();
+  virtual ~SessionContext();
 
   bool isValid() { return valid_; }
 
-  bool DeriveKeys(const std::vector<uint8_t>& master_key,
+  virtual bool DeriveKeys(const std::vector<uint8_t>& master_key,
-                  const std::vector<uint8_t>& mac_context,
+                          const std::vector<uint8_t>& mac_context,
-                  const std::vector<uint8_t>& enc_context);
+                          const std::vector<uint8_t>& enc_context);
-  bool RSADeriveKeys(const std::vector<uint8_t>& enc_session_key,
+  virtual bool RSADeriveKeys(const std::vector<uint8_t>& enc_session_key,
-                     const std::vector<uint8_t>& mac_context,
+                             const std::vector<uint8_t>& mac_context,
-                     const std::vector<uint8_t>& enc_context);
+                             const std::vector<uint8_t>& enc_context);
-  bool GenerateSignature(const uint8_t* message, size_t message_length,
+  virtual bool GenerateSignature(const uint8_t* message, size_t message_length,
-                         uint8_t* signature, size_t* signature_length);
+                                 uint8_t* signature, size_t* signature_length);
   size_t RSASignatureSize();
-  OEMCryptoResult GenerateRSASignature(const uint8_t* message,
+  virtual OEMCryptoResult GenerateRSASignature(
-                                       size_t message_length,
+      const uint8_t* message, size_t message_length, uint8_t* signature,
-                                       uint8_t* signature,
+      size_t* signature_length, RSA_Padding_Scheme padding_scheme);
-                                       size_t* signature_length,
+  virtual bool ValidateMessage(const uint8_t* message, size_t message_length,
-                                       RSA_Padding_Scheme padding_scheme);
+                               const uint8_t* signature,
-  bool ValidateMessage(const uint8_t* message, size_t message_length,
+                               size_t signature_length);
-                       const uint8_t* signature, size_t signature_length);
   OEMCryptoResult DecryptCENC(const uint8_t* iv, size_t block_offset,
                               const OEMCrypto_CENCEncryptPatternDesc* pattern,
                               const uint8_t* cipher_data,
@@ -118,7 +117,7 @@ class SessionContext {
                                  size_t signature_length);
   void StartTimer();
   uint32_t CurrentTimer();  // (seconds).
-  OEMCryptoResult LoadKeys(
+  virtual OEMCryptoResult LoadKeys(
       const uint8_t* message, size_t message_length, const uint8_t* signature,
       size_t signature_length, const uint8_t* enc_mac_key_iv,
       const uint8_t* enc_mac_keys, size_t num_keys,
@@ -126,14 +125,13 @@ class SessionContext {
       size_t pst_length, const uint8_t* srm_requirement,
       OEMCrypto_LicenseType license_type);
   OEMCryptoResult LoadEntitledContentKeys(
-      size_t num_keys,
+      size_t num_keys, const OEMCrypto_EntitledContentKeyObject* key_array);
-      const OEMCrypto_EntitledContentKeyObject* key_array);
+  virtual OEMCryptoResult InstallKey(const KeyId& key_id,
-  OEMCryptoResult InstallKey(const KeyId& key_id,
+                                     const std::vector<uint8_t>& key_data,
-                             const std::vector<uint8_t>& key_data,
+                                     const std::vector<uint8_t>& key_data_iv,
-                             const std::vector<uint8_t>& key_data_iv,
+                                     const std::vector<uint8_t>& key_control,
-                             const std::vector<uint8_t>& key_control,
+                                     const std::vector<uint8_t>& key_control_iv,
-                             const std::vector<uint8_t>& key_control_iv,
+                                     bool second_license);
-                             bool second_license);
   bool InstallRSAEncryptedKey(const uint8_t* encrypted_message_key,
                               size_t encrypted_message_key_length);
   bool DecryptRSAKey(const uint8_t* enc_rsa_key, size_t enc_rsa_key_length,
@@ -141,14 +139,14 @@ class SessionContext {
   bool EncryptRSAKey(const uint8_t* pkcs8_rsa_key, size_t enc_rsa_key_length,
                      const uint8_t* enc_rsa_key_iv, uint8_t* enc_rsa_key);
   bool LoadRSAKey(const uint8_t* pkcs8_rsa_key, size_t rsa_key_length);
-  OEMCryptoResult RefreshKey(const KeyId& key_id,
+  virtual OEMCryptoResult RefreshKey(
-                             const std::vector<uint8_t>& key_control,
+      const KeyId& key_id, const std::vector<uint8_t>& key_control,
-                             const std::vector<uint8_t>& key_control_iv);
+      const std::vector<uint8_t>& key_control_iv);
-  bool UpdateMacKeys(const std::vector<uint8_t>& mac_keys,
+  virtual bool UpdateMacKeys(const std::vector<uint8_t>& mac_keys,
-                     const std::vector<uint8_t>& iv);
+                             const std::vector<uint8_t>& iv);
-  bool QueryKeyControlBlock(const KeyId& key_id, uint32_t* data);
+  virtual bool QueryKeyControlBlock(const KeyId& key_id, uint32_t* data);
-  OEMCryptoResult SelectContentKey(const KeyId& key_id,
+  virtual OEMCryptoResult SelectContentKey(const KeyId& key_id,
-                                   OEMCryptoCipherMode cipher_mode);
+                                           OEMCryptoCipherMode cipher_mode);
   const Key* current_content_key(void) { return current_content_key_; }
   void set_mac_key_server(const std::vector<uint8_t>& mac_key_server) {
     mac_key_server_ = mac_key_server;
@@ -169,20 +167,20 @@ class SessionContext {
   bool CheckNonce(uint32_t nonce);
   void FlushNonces();
 
-  OEMCryptoResult CreateNewUsageEntry(uint32_t* usage_entry_number);
+  virtual OEMCryptoResult CreateNewUsageEntry(uint32_t* usage_entry_number);
-  OEMCryptoResult LoadUsageEntry(uint32_t index,
+  virtual OEMCryptoResult LoadUsageEntry(uint32_t index,
-                                 const std::vector<uint8_t>& buffer);
+                                         const std::vector<uint8_t>& buffer);
-  OEMCryptoResult UpdateUsageEntry(uint8_t* header_buffer,
+  virtual OEMCryptoResult UpdateUsageEntry(uint8_t* header_buffer,
-                                   size_t* header_buffer_length,
+                                           size_t* header_buffer_length,
-                                   uint8_t* entry_buffer,
+                                           uint8_t* entry_buffer,
-                                   size_t* entry_buffer_length);
+                                           size_t* entry_buffer_length);
-  OEMCryptoResult DeactivateUsageEntry(const std::vector<uint8_t>& pst);
+  virtual OEMCryptoResult DeactivateUsageEntry(const std::vector<uint8_t>& pst);
-  OEMCryptoResult ReportUsage(const std::vector<uint8_t>& pst, uint8_t* buffer,
+  virtual OEMCryptoResult ReportUsage(const std::vector<uint8_t>& pst,
-                              size_t* buffer_length);
+                                      uint8_t* buffer, size_t* buffer_length);
   OEMCryptoResult MoveEntry(uint32_t new_index);
   OEMCryptoResult CopyOldUsageEntry(const std::vector<uint8_t>& pst);
 
- private:
+ protected:
   bool DeriveKey(const std::vector<uint8_t>& key,
                  const std::vector<uint8_t>& context, int counter,
                  std::vector<uint8_t>* out);

libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.cpp

@@ -366,6 +366,10 @@ OEMCryptoResult UsageTable::UpdateUsageEntry(SessionContext* session,
   return result;
 }
 
+UsageTableEntry* UsageTable::MakeEntry(uint32_t index) {
+  return new UsageTableEntry(this, index, master_generation_number_);
+}
+
 OEMCryptoResult UsageTable::CreateNewUsageEntry(SessionContext* session,
                                                 UsageTableEntry** entry,
                                                 uint32_t* usage_entry_number) {
@@ -376,8 +380,7 @@ OEMCryptoResult UsageTable::CreateNewUsageEntry(SessionContext* session,
   if (!entry) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   if (!usage_entry_number) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   uint32_t index = generation_numbers_.size();
-  UsageTableEntry* new_entry =
+  UsageTableEntry* new_entry = MakeEntry(index);
-      new UsageTableEntry(this, index, master_generation_number_);
   generation_numbers_.push_back(master_generation_number_);
   sessions_.push_back(session);
   master_generation_number_++;
@@ -401,8 +404,7 @@ OEMCryptoResult UsageTable::LoadUsageEntry(SessionContext* session,
     LOGE("LoadUsageEntry: index %d used by other session.", index);
     return OEMCrypto_ERROR_INVALID_SESSION;
   }
-  UsageTableEntry* new_entry =
+  UsageTableEntry* new_entry = MakeEntry(index);
-      new UsageTableEntry(this, index, master_generation_number_);
 
   OEMCryptoResult status = new_entry->LoadData(ce_, index, buffer);
   if (status != OEMCrypto_SUCCESS) {

libwvdrmengine/oemcrypto/ref/src/oemcrypto_usage_table_ref.h

@@ -42,8 +42,7 @@ struct StoredUsageEntry {
 class UsageTableEntry {
  public:
   UsageTableEntry(UsageTable* table, uint32_t index, int64_t generation);
-  //     owner_(owner), session_(session), loaded_(false) {}
+  virtual ~UsageTableEntry();  // Free memory, remove reference in header.
-  ~UsageTableEntry();  // Free memory, remove reference in header.
   bool Inactive() { return data_.status >= kInactive; }
   OEMCryptoResult SetPST(const uint8_t* pst, size_t pst_length);
   bool VerifyPST(const uint8_t* pst, size_t pst_length);
@@ -56,14 +55,14 @@ class UsageTableEntry {
   // for update.
   bool CheckForUse();
   void Deactivate(const std::vector<uint8_t>& pst);
-  OEMCryptoResult ReportUsage(const std::vector<uint8_t>& pst, uint8_t* buffer,
+  virtual OEMCryptoResult ReportUsage(const std::vector<uint8_t>& pst,
-                              size_t* buffer_length);
+                                      uint8_t* buffer, size_t* buffer_length);
-  void UpdateAndIncrement();
+  virtual void UpdateAndIncrement();
   OEMCryptoResult SaveData(CryptoEngine* ce, SessionContext* session,
                            uint8_t* signed_buffer, size_t buffer_size);
   OEMCryptoResult LoadData(CryptoEngine* ce, uint32_t index,
                            const std::vector<uint8_t>& buffer);
-  OEMCryptoResult CopyOldUsageEntry(const std::vector<uint8_t>& pst);
+  virtual OEMCryptoResult CopyOldUsageEntry(const std::vector<uint8_t>& pst);
   int64_t generation_number() { return data_.generation_number; }
   void set_generation_number(int64_t value) { data_.generation_number = value; }
   void set_index(int32_t index) { data_.index = index; }
@@ -72,7 +71,7 @@ class UsageTableEntry {
   const uint8_t* mac_key_server() { return data_.mac_key_server; }
   const uint8_t* mac_key_client() { return data_.mac_key_client; }
 
- private:
+ protected:
   UsageTable* usage_table_;  // Owner of this object.
   bool recent_decrypt_;
   bool forbid_report_;
@@ -82,8 +81,8 @@ class UsageTableEntry {
 class UsageTable {
  public:
   explicit UsageTable(CryptoEngine* ce)
-      : ce_(ce), header_loaded_(false), old_table_(NULL){};
+      : ce_(ce), header_loaded_(false), old_table_(NULL) {};
-  ~UsageTable();
+  virtual ~UsageTable();
 
   OEMCryptoResult CreateNewUsageEntry(SessionContext* session,
                                       UsageTableEntry** entry,
@@ -113,23 +112,23 @@ class UsageTable {
                                       uint64_t time_since_first_decrypt,
                                       uint64_t time_since_last_decrypt,
                                       OEMCrypto_Usage_Entry_Status status,
-                                      uint8_t *server_mac_key,
+                                      uint8_t* server_mac_key,
-                                      uint8_t *client_mac_key,
+                                      uint8_t* client_mac_key,
-                                      const uint8_t* pst,
+                                      const uint8_t* pst, size_t pst_length);
-                                      size_t pst_length);
 
- private:
+ protected:
-  OEMCryptoResult SaveUsageTableHeader(uint8_t* signed_buffer,
+  virtual UsageTableEntry* MakeEntry(uint32_t index);
-                                       size_t buffer_size);
+  virtual OEMCryptoResult SaveUsageTableHeader(uint8_t* signed_buffer,
-  bool SaveGenerationNumber();
+                                               size_t buffer_size);
-  bool LoadGenerationNumber(bool or_make_new_one);
+  virtual bool SaveGenerationNumber();
+  virtual bool LoadGenerationNumber(bool or_make_new_one);
 
   CryptoEngine* ce_;
   bool header_loaded_;
   int64_t master_generation_number_;
   std::vector<int64_t> generation_numbers_;
   std::vector<SessionContext*> sessions_;
-  OldUsageTable *old_table_;
+  OldUsageTable* old_table_;
 };
 
 }  // namespace wvoec_ref