Migration from jb-mr2 to master for Widevine CDM

Android development of the widevine CDM has been done on the jb-mr2 branch of the cdm code base. This CL contains a merge of that jb-mr2 work to CDM master, and also reflects the evolution of the common Modular DRM code base since jb-mr2 branched. Change-Id: I1d7e1a12d092c00044a4298261146cb97808d4ef
2013-07-29 17:29:07 -07:00
parent edb987db07
commit 0190f99fb3
68 changed files with 4754 additions and 3601 deletions
--- a/libwvdrmengine/cdm/core/src/crypto_session.cpp
+++ b/libwvdrmengine/cdm/core/src/crypto_session.cpp
@@ -5,9 +5,10 @@

 #include "crypto_session.h"

+#include <arpa/inet.h>  // TODO(fredgc): Add ntoh to wv_cdm_utilities.h
 #include <iostream>

-#include "crypto_engine.h"
+#include "crypto_key.h"
 #include "log.h"
 // TODO(gmorgan,jtinker): decide if OEMCryptoCENC is needed here.
 #include "OEMCryptoCENC.h"
@@ -21,95 +22,226 @@ std::string EncodeUint32(unsigned int u) {
  std::string s;
  s.append(1, (u >> 24) & 0xFF);
  s.append(1, (u >> 16) & 0xFF);
-  s.append(1, (u >>  8) & 0xFF);
-  s.append(1, (u >>  0) & 0xFF);
+  s.append(1, (u >> 8) & 0xFF);
+  s.append(1, (u >> 0) & 0xFF);
  return s;
 }
 }

 namespace wvcdm {

-// wrapper classes for OEMCrypto interface
-// CryptoEngine -- top-level interface
-// CryptoSession -- session-specific interface
-// CryptoKey -- key interface
+Lock CryptoSession::crypto_lock_;
+bool CryptoSession::initialized_ = false;
+int CryptoSession::session_count_ = 0;

-// CryptoSession methods
-
-CryptoSession::CryptoSession() :
-    valid_(false),
-    open_(false),
-    is_destination_buffer_type_valid_(false) {}
-
-CryptoSession::CryptoSession(const std::string& sname) :
-    valid_(true),
-    open_(false),
-    cdm_session_id_(sname),
-    is_destination_buffer_type_valid_(false) {}
+CryptoSession::CryptoSession()
+    : open_(false), is_destination_buffer_type_valid_(false) {
+  Init();
+}

 CryptoSession::~CryptoSession() {
  if (open_) {
    Close();
  }
-  LOGV("CryptoSession::dtor: SLock");
-  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
-  crypto_engine->sessions_.erase(cdm_session_id_);
-  if (0 == crypto_engine->sessions_.size()) {
-    crypto_engine->DeleteInstance();
+  Terminate();
+}
+
+void CryptoSession::Init() {
+  LOGV("CryptoSession::Init");
+  AutoLock auto_lock(crypto_lock_);
+  session_count_ += 1;
+  if (initialized_) return;
+  OEMCryptoResult sts = OEMCrypto_Initialize();
+  if (OEMCrypto_SUCCESS != sts) {
+    LOGE("OEMCrypto_Initialize failed: %d", sts);
+    return;
+  }
+  initialized_ = true;
+}
+
+void CryptoSession::Terminate() {
+  LOGV("CryptoSession::Terminate");
+  AutoLock auto_lock(crypto_lock_);
+  session_count_ -= 1;
+  if (session_count_ > 0 || !initialized_) return;
+  OEMCryptoResult sts = OEMCrypto_Terminate();
+  if (OEMCrypto_SUCCESS != sts) {
+    LOGE("OEMCrypto_Terminate failed: %d", sts);
+  }
+  initialized_ = false;
+}
+
+bool CryptoSession::ValidateKeybox() {
+  LOGV("CryptoSession::ValidateKeybox: Lock");
+  AutoLock auto_lock(crypto_lock_);
+  if (!initialized_) {
+    return false;
+  }
+  OEMCryptoResult result = OEMCrypto_IsKeyboxValid();
+  return (OEMCrypto_SUCCESS == result);
+}
+
+bool CryptoSession::GetToken(std::string* token) {
+  if (!token) {
+    LOGE("CryptoSession::GetToken : No token passed to method.");
+    return false;
+  }
+  uint8_t buf[KEYBOX_KEY_DATA_SIZE];
+  size_t bufSize = sizeof(buf);
+  LOGV("CryptoSession::GetToken: Lock");
+  AutoLock auto_lock(crypto_lock_);
+  if (!initialized_) {
+    return false;
+  }
+  OEMCryptoResult sts = OEMCrypto_GetKeyData(buf, &bufSize);
+  if (OEMCrypto_SUCCESS != sts) {
+    return false;
+  }
+  token->assign((const char*)buf, (size_t)bufSize);
+  return true;
+}
+
+CryptoSession::SecurityLevel CryptoSession::GetSecurityLevel() {
+  LOGV("CryptoSession::GetSecurityLevel: Lock");
+  AutoLock auto_lock(crypto_lock_);
+  if (!initialized_) {
+    return kSecurityLevelUninitialized;
+  }
+  std::string security_level = OEMCrypto_SecurityLevel();
+
+  if ((security_level.size() != 2) || (security_level.at(0) != 'L')) {
+    return kSecurityLevelUnknown;
  }

-  CryptoKeyMap::iterator i(keys_.begin());
-  for (; i != keys_.end(); ++i)
-    delete i->second;
-  keys_.clear();
+  switch (security_level.at(1)) {
+    case '1':
+      return kSecurityLevelL1;
+    case '2':
+      return kSecurityLevelL2;
+    case '3':
+      return kSecurityLevelL3;
+    default:
+      return kSecurityLevelUnknown;
+  }
+
+  return kSecurityLevelUnknown;
+}
+
+bool CryptoSession::GetDeviceUniqueId(std::string* device_id) {
+  if (!device_id) {
+    LOGE("CryptoSession::GetDeviceUniqueId : No buffer passed to method.");
+    return false;
+  }
+
+  std::vector<uint8_t> id;
+  size_t id_length = 32;
+
+  id.resize(id_length);
+
+  LOGV("CryptoSession::GetDeviceUniqueId: Lock");
+  AutoLock auto_lock(crypto_lock_);
+  if (!initialized_) {
+    return false;
+  }
+  OEMCryptoResult sts = OEMCrypto_GetDeviceID(&id[0], &id_length);
+
+  if (OEMCrypto_SUCCESS != sts) {
+    return false;
+  }
+
+  *device_id = reinterpret_cast<const char*>(&id[0]);
+  return true;
+}
+
+bool CryptoSession::GetSystemId(uint32_t* system_id) {
+  if (!system_id) {
+    LOGE("CryptoSession::GetSystemId : No buffer passed to method.");
+    return false;
+  }
+
+  uint8_t buf[KEYBOX_KEY_DATA_SIZE];
+  size_t buf_size = sizeof(buf);
+
+  LOGV("CryptoSession::GetSystemId: Lock");
+  AutoLock auto_lock(crypto_lock_);
+  if (!initialized_) {
+    return false;
+  }
+  OEMCryptoResult sts = OEMCrypto_GetKeyData(buf, &buf_size);
+
+  if (OEMCrypto_SUCCESS != sts) {
+    return false;
+  }
+
+  // Decode 32-bit int encoded as network-byte-order byte array starting at
+  // index 4.
+  uint32_t* id = reinterpret_cast<uint32_t*>(&buf[4]);
+
+  *system_id = ntohl(*id);
+  return true;
+}
+
+bool CryptoSession::GetProvisioningId(std::string* provisioning_id) {
+  if (!provisioning_id) {
+    LOGE("CryptoSession::GetProvisioningId : No buffer passed to method.");
+    return false;
+  }
+
+  uint8_t buf[KEYBOX_KEY_DATA_SIZE];
+  size_t buf_size = sizeof(buf);
+
+  LOGV("CryptoSession::GetProvisioningId: Lock");
+  AutoLock auto_lock(crypto_lock_);
+  if (!initialized_) {
+    return false;
+  }
+  OEMCryptoResult sts = OEMCrypto_GetKeyData(buf, &buf_size);
+
+  if (OEMCrypto_SUCCESS != sts) {
+    return false;
+  }
+
+  provisioning_id->assign(reinterpret_cast<char*>(&buf[8]), 16);
+  return true;
 }

 bool CryptoSession::Open() {
  LOGV("CryptoSession::Open: Lock");
-  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
-  AutoLock auto_lock(crypto_engine->crypto_lock_);
+  AutoLock auto_lock(crypto_lock_);
+  if (!initialized_) return false;
+  if (open_) return true;
+
  OEMCrypto_SESSION sid;
-  OEMCryptoResult sts;
-  if (open_)
-    return false;
-  sts = OEMCrypto_OpenSession(&sid);
-  if (OEMCrypto_SUCCESS != sts) {
-    open_ = false;
-  } else {
+  if (OEMCrypto_SUCCESS == OEMCrypto_OpenSession(&sid)) {
    oec_session_id_ = static_cast<CryptoSessionId>(sid);
-    LOGV("OpenSession: id= %ld", (uint32_t) oec_session_id_);
+    LOGV("OpenSession: id= %ld", (uint32_t)oec_session_id_);
    open_ = true;
  }
  return open_;
 }

 void CryptoSession::Close() {
-  LOGV("CryptoSession::Close: Lock");
-  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
-  AutoLock auto_lock(crypto_engine->crypto_lock_);
-  LOGV("CloseSession: id=%ld open=%s", (uint32_t) oec_session_id_, open_? "true" : "false") ;
-  if (open_) {
-    OEMCryptoResult sts = OEMCrypto_CloseSession(oec_session_id_);
-    if (OEMCrypto_SUCCESS == sts) {
-      open_ = false;
-    }
+  LOGV("CloseSession: id=%ld open=%s", (uint32_t)oec_session_id_,
+       open_ ? "true" : "false");
+  AutoLock auto_lock(crypto_lock_);
+  if (!open_) return;
+  if (OEMCrypto_SUCCESS == OEMCrypto_CloseSession(oec_session_id_)) {
+    open_ = false;
  }
 }

 void CryptoSession::GenerateRequestId(std::string& req_id_str) {
  LOGV("CryptoSession::GenerateRequestId: Lock");
-  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
-  AutoLock auto_lock(crypto_engine->crypto_lock_);
+  AutoLock auto_lock(crypto_lock_);
  // TODO(gmorgan): Get unique ID from OEMCrypto
  req_id_str.assign("987654321");
 }

 bool CryptoSession::PrepareRequest(const std::string& message,
-                                   std::string* signature,
-                                   bool is_provisioning) {
+                                   bool is_provisioning,
+                                   std::string* signature) {
  LOGV("CryptoSession::PrepareRequest: Lock");
-  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
-  AutoLock auto_lock(crypto_engine->crypto_lock_);
+  AutoLock auto_lock(crypto_lock_);

  if (!signature) {
    LOGE("CryptoSession::PrepareRequest : No output destination provided.");
@@ -117,15 +249,11 @@ bool CryptoSession::PrepareRequest(const std::string& message,
  }

  if (!Properties::use_certificates_as_identification() || is_provisioning) {
-    if (!GenerateDerivedKeys(message))
-      return false;
+    if (!GenerateDerivedKeys(message)) return false;

-    if (!GenerateSignature(message, signature, false))
-      return false;
-  }
-  else {
-    if (!GenerateSignature(message, signature, true))
-      return false;
+    if (!GenerateSignature(message, false, signature)) return false;
+  } else {
+    if (!GenerateSignature(message, true, signature)) return false;
  }

  return true;
@@ -134,15 +262,15 @@ bool CryptoSession::PrepareRequest(const std::string& message,
 bool CryptoSession::PrepareRenewalRequest(const std::string& message,
                                          std::string* signature) {
  LOGV("CryptoSession::PrepareRenewalRequest: Lock");
-  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
-  AutoLock auto_lock(crypto_engine->crypto_lock_);
+  AutoLock auto_lock(crypto_lock_);

  if (!signature) {
-    LOGE("CryptoSession::PrepareRenewalRequest : No output destination provided.");
+    LOGE("CryptoSession::PrepareRenewalRequest : No output destination "
+         "provided.");
    return false;
  }

-  if (!GenerateSignature(message, signature, false)) {
+  if (!GenerateSignature(message, false, signature)) {
    return false;
  }

@@ -162,13 +290,14 @@ void CryptoSession::GenerateMacContext(const std::string& input_context,
  deriv_context->assign(kSigningKeyLabel);
  deriv_context->append(1, '\0');
  deriv_context->append(input_context);
-  deriv_context->append(EncodeUint32(kSigningKeySizeBits*2));
+  deriv_context->append(EncodeUint32(kSigningKeySizeBits * 2));
 }

 void CryptoSession::GenerateEncryptContext(const std::string& input_context,
                                           std::string* deriv_context) {
  if (!deriv_context) {
-    LOGE("CryptoSession::GenerateEncryptContext : No output destination provided.");
+    LOGE("CryptoSession::GenerateEncryptContext : No output destination "
+         "provided.");
    return;
  }

@@ -193,12 +322,10 @@ size_t CryptoSession::GetOffset(std::string message, std::string field) {
 bool CryptoSession::LoadKeys(const std::string& message,
                             const std::string& signature,
                             const std::string& mac_key_iv,
-                             const std::string& mac_key,
-                             int num_keys,
+                             const std::string& mac_key, int num_keys,
                             const CryptoKey* key_array) {
  LOGV("CryptoSession::LoadKeys: Lock");
-  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
-  AutoLock auto_lock(crypto_engine->crypto_lock_);
+  AutoLock auto_lock(crypto_lock_);

  const uint8_t* msg = reinterpret_cast<const uint8_t*>(message.data());
  const uint8_t* enc_mac_key = NULL;
@@ -208,7 +335,7 @@ bool CryptoSession::LoadKeys(const std::string& message,
    enc_mac_key_iv = msg + GetOffset(message, mac_key_iv);
  }
  std::vector<OEMCrypto_KeyObject> load_key_array(num_keys);
-  for (int i=0; i<num_keys; ++i) {
+  for (int i = 0; i < num_keys; ++i) {
    const CryptoKey* ki = &key_array[i];
    OEMCrypto_KeyObject* ko = &load_key_array[i];
    ko->key_id = msg + GetOffset(message, ki->key_id());
@@ -219,30 +346,28 @@ bool CryptoSession::LoadKeys(const std::string& message,
    if (ki->HasKeyControl()) {
      ko->key_control_iv = msg + GetOffset(message, ki->key_control_iv());
      ko->key_control = msg + GetOffset(message, ki->key_control());
-    }
-    else {
-      LOGE("For key %d: XXX key has no control block. size=%d", i, ki->key_control().size());
+    } else {
+      LOGE("For key %d: XXX key has no control block. size=%d", i,
+           ki->key_control().size());
      ko->key_control_iv = NULL;
      ko->key_control = NULL;
    }
  }
-  LOGV("LoadKeys: id=%ld", (uint32_t) oec_session_id_);
-  return (OEMCrypto_SUCCESS == OEMCrypto_LoadKeys(
-      oec_session_id_, msg, message.size(),
-      reinterpret_cast<const uint8_t*>(signature.data()),
-      signature.size(), enc_mac_key_iv, enc_mac_key,
-      num_keys, &load_key_array[0]));
+  LOGV("LoadKeys: id=%ld", (uint32_t)oec_session_id_);
+  return (OEMCrypto_SUCCESS ==
+          OEMCrypto_LoadKeys(oec_session_id_, msg, message.size(),
+                             reinterpret_cast<const uint8_t*>(signature.data()),
+                             signature.size(), enc_mac_key_iv, enc_mac_key,
+                             num_keys, &load_key_array[0]));
 }

 bool CryptoSession::LoadCertificatePrivateKey(std::string& wrapped_key) {
  LOGV("CryptoSession::LoadKeys: Lock");
-  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
-  AutoLock auto_lock(crypto_engine->crypto_lock_);
+  AutoLock auto_lock(crypto_lock_);

-  LOGV("LoadDeviceRSAKey: id=%ld", (uint32_t) oec_session_id_);
+  LOGV("LoadDeviceRSAKey: id=%ld", (uint32_t)oec_session_id_);
  OEMCryptoResult sts = OEMCrypto_LoadDeviceRSAKey(
-      oec_session_id_,
-      reinterpret_cast<const uint8_t*>(wrapped_key.data()),
+      oec_session_id_, reinterpret_cast<const uint8_t*>(wrapped_key.data()),
      wrapped_key.size());

  if (OEMCrypto_SUCCESS != sts) {
@@ -254,16 +379,14 @@ bool CryptoSession::LoadCertificatePrivateKey(std::string& wrapped_key) {
 }

 bool CryptoSession::RefreshKeys(const std::string& message,
-                                const std::string& signature,
-                                int num_keys,
+                                const std::string& signature, int num_keys,
                                const CryptoKey* key_array) {
  LOGV("CryptoSession::RefreshKeys: Lock");
-  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
-  AutoLock auto_lock(crypto_engine->crypto_lock_);
+  AutoLock auto_lock(crypto_lock_);

  const uint8_t* msg = reinterpret_cast<const uint8_t*>(message.data());
  std::vector<OEMCrypto_KeyRefreshObject> load_key_array(num_keys);
-  for (int i=0; i<num_keys; ++i) {
+  for (int i = 0; i < num_keys; ++i) {
    const CryptoKey* ki = &key_array[i];
    OEMCrypto_KeyRefreshObject* ko = &load_key_array[i];
    if (ki->key_id().empty()) {
@@ -278,30 +401,28 @@ bool CryptoSession::RefreshKeys(const std::string& message,
        ko->key_control_iv = msg + GetOffset(message, ki->key_control_iv());
      }
      ko->key_control = msg + GetOffset(message, ki->key_control());
-    }
-    else {
+    } else {
      ko->key_control_iv = NULL;
      ko->key_control = NULL;
    }
  }
  LOGV("RefreshKeys: id=%ld", static_cast<uint32_t>(oec_session_id_));
-  return (OEMCrypto_SUCCESS == OEMCrypto_RefreshKeys(
-      oec_session_id_, msg, message.size(),
-      reinterpret_cast<const uint8_t*>(signature.data()),
-      signature.size(),
-      num_keys, &load_key_array[0]));
+  return (
+      OEMCrypto_SUCCESS ==
+      OEMCrypto_RefreshKeys(oec_session_id_, msg, message.size(),
+                            reinterpret_cast<const uint8_t*>(signature.data()),
+                            signature.size(), num_keys, &load_key_array[0]));
 }

 bool CryptoSession::SelectKey(const std::string& key_id) {
  LOGV("CryptoSession::SelectKey: Lock");
-  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
-  AutoLock auto_lock(crypto_engine->crypto_lock_);
+  AutoLock auto_lock(crypto_lock_);
  const uint8_t* key_id_string =
      reinterpret_cast<const uint8_t*>(key_id.data());

  LOGV("SelectKey: id=%ld", static_cast<uint32_t>(oec_session_id_));
-  OEMCryptoResult sts = OEMCrypto_SelectKey(oec_session_id_, key_id_string,
-                                            key_id.size());
+  OEMCryptoResult sts =
+      OEMCrypto_SelectKey(oec_session_id_, key_id_string, key_id.size());
  if (OEMCrypto_SUCCESS != sts) {
    return false;
  }
@@ -314,7 +435,7 @@ bool CryptoSession::GenerateDerivedKeys(const std::string& message) {
  GenerateMacContext(message, &mac_deriv_message);
  GenerateEncryptContext(message, &enc_deriv_message);

-  LOGV("GenerateDerivedKeys: id=%ld", (uint32_t) oec_session_id_);
+  LOGV("GenerateDerivedKeys: id=%ld", (uint32_t)oec_session_id_);
  OEMCryptoResult sts = OEMCrypto_GenerateDerivedKeys(
      oec_session_id_,
      reinterpret_cast<const uint8_t*>(mac_deriv_message.data()),
@@ -337,10 +458,9 @@ bool CryptoSession::GenerateDerivedKeys(const std::string& message,
  GenerateMacContext(message, &mac_deriv_message);
  GenerateEncryptContext(message, &enc_deriv_message);

-  LOGV("GenerateDerivedKeys: id=%ld", (uint32_t) oec_session_id_);
+  LOGV("GenerateDerivedKeys: id=%ld", (uint32_t)oec_session_id_);
  OEMCryptoResult sts = OEMCrypto_DeriveKeysFromSessionKey(
-      oec_session_id_,
-      reinterpret_cast<const uint8_t*>(session_key.data()),
+      oec_session_id_, reinterpret_cast<const uint8_t*>(session_key.data()),
      session_key.size(),
      reinterpret_cast<const uint8_t*>(mac_deriv_message.data()),
      mac_deriv_message.size(),
@@ -355,51 +475,43 @@ bool CryptoSession::GenerateDerivedKeys(const std::string& message,
  return true;
 }

-bool CryptoSession::GenerateSignature(const std::string& message,
-                                      std::string* signature,
-                                      bool use_rsa) {
-  LOGV("GenerateSignature: id=%ld", (uint32_t) oec_session_id_);
-  if (!signature)
-    return false;
+bool CryptoSession::GenerateSignature(const std::string& message, bool use_rsa,
+                                      std::string* signature) {
+  LOGV("GenerateSignature: id=%ld", (uint32_t)oec_session_id_);
+  if (!signature) return false;

  size_t length = 0;
-  OEMCryptoResult sts;
+  OEMCryptoResult sts = OEMCrypto_SUCCESS;
  if (use_rsa) {
    sts = OEMCrypto_GenerateRSASignature(
-        oec_session_id_,
-        reinterpret_cast<const uint8_t*>(message.data()),
-        message.size(),
-        NULL,
-        &length);
-  }
-  else {
+        oec_session_id_, reinterpret_cast<const uint8_t*>(message.data()),
+        message.size(), NULL, &length);
+    if (OEMCrypto_ERROR_SHORT_BUFFER != sts) {
+      LOGD("GenerateSignature: OEMCrypto_GenerateRSASignature err=%d", sts);
+      return false;
+    }
+  } else {
+    length = kSignatureSize;
+    // TODO(gmorgan,kqyang): Use OEMCrypto_GenerateSignature to determine
+    // length after marvell fixes their implementation.
+    /*
    sts = OEMCrypto_GenerateSignature(
-        oec_session_id_,
-        reinterpret_cast<const uint8_t*>(message.data()),
-        message.size(),
-        NULL,
-        &length);
-  }
-
-  if (OEMCrypto_ERROR_SHORT_BUFFER != sts) {
-    LOGD("GenerateSignature: OEMCrypto_GenerateSignature err=%d", sts);
-    return false;
+        oec_session_id_, reinterpret_cast<const uint8_t*>(message.data()),
+        message.size(), NULL, &length);
+    */
  }

  signature->resize(length);

  if (use_rsa) {
    sts = OEMCrypto_GenerateRSASignature(
-        oec_session_id_,
-        reinterpret_cast<const uint8_t*>(message.data()),
+        oec_session_id_, reinterpret_cast<const uint8_t*>(message.data()),
        message.size(),
        reinterpret_cast<uint8_t*>(const_cast<char*>(signature->data())),
        &length);
-  }
-  else {
+  } else {
    sts = OEMCrypto_GenerateSignature(
-        oec_session_id_,
-        reinterpret_cast<const uint8_t*>(message.data()),
+        oec_session_id_, reinterpret_cast<const uint8_t*>(message.data()),
        message.size(),
        reinterpret_cast<uint8_t*>(const_cast<char*>(signature->data())),
        &length);
@@ -410,29 +522,24 @@ bool CryptoSession::GenerateSignature(const std::string& message,
    return false;
  }

-  // TODO(fredgc): remove in K, when L1 library reports correct length.
+  // TODO(fredgc): b/8878371
+  // remove in K, when L1 library reports correct length.
  signature->resize(length);

  return true;
 }

-CdmResponseType CryptoSession::Decrypt(bool is_encrypted,
-                                       bool is_secure,
-                                       const uint8_t* encrypt_buffer,
-                                       size_t encrypt_length,
-                                       const std::vector<uint8_t>& iv,
-                                       size_t block_offset,
-                                       void* decrypt_buffer,
-                                       size_t decrypt_buffer_offset,
-                                       bool is_video) {
+CdmResponseType CryptoSession::Decrypt(
+    bool is_encrypted, bool is_secure, const uint8_t* encrypt_buffer,
+    size_t encrypt_length, const std::vector<uint8_t>& iv, size_t block_offset,
+    void* decrypt_buffer, size_t decrypt_buffer_offset, bool is_video) {
  if (!is_destination_buffer_type_valid_) {
-    if (!SetDestinationBufferType())
-      return UNKNOWN_ERROR;
+    if (!SetDestinationBufferType()) return UNKNOWN_ERROR;
  }

  OEMCrypto_DestBufferDesc buffer_descriptor;
  buffer_descriptor.type =
-      is_secure ? destination_buffer_type_: OEMCrypto_BufferType_Clear;
+      is_secure ? destination_buffer_type_ : OEMCrypto_BufferType_Clear;

  switch (buffer_descriptor.type) {
    case OEMCrypto_BufferType_Clear:
@@ -452,13 +559,8 @@ CdmResponseType CryptoSession::Decrypt(bool is_encrypted,
  }

  OEMCryptoResult sts = OEMCrypto_DecryptCTR(
-      oec_session_id_,
-      encrypt_buffer,
-      encrypt_length,
-      is_encrypted,
-      &iv[0],
-      block_offset,
-      &buffer_descriptor,
+      oec_session_id_, encrypt_buffer, encrypt_length, is_encrypted, &iv[0],
+      block_offset, &buffer_descriptor,
      OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample);

  if (OEMCrypto_SUCCESS != sts) {
@@ -474,29 +576,23 @@ bool CryptoSession::GenerateNonce(uint32_t* nonce) {
  }

  LOGV("CryptoSession::GenerateNonce: Lock");
-  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
-  AutoLock auto_lock(crypto_engine->crypto_lock_);
-  return(OEMCrypto_SUCCESS == OEMCrypto_GenerateNonce(oec_session_id_, nonce));
+  AutoLock auto_lock(crypto_lock_);
+
+  return (OEMCrypto_SUCCESS == OEMCrypto_GenerateNonce(oec_session_id_, nonce));
 }

 bool CryptoSession::SetDestinationBufferType() {
-  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
-
  if (Properties::oem_crypto_use_secure_buffers()) {
-    if (crypto_engine->GetSecurityLevel() == CryptoEngine::kSecurityLevelL1) {
+    if (GetSecurityLevel() == CryptoSession::kSecurityLevelL1) {
      destination_buffer_type_ = OEMCrypto_BufferType_Secure;
-    }
-    else {
+    } else {
      destination_buffer_type_ = OEMCrypto_BufferType_Clear;
    }
-  }
-  else if (Properties::oem_crypto_use_fifo()) {
+  } else if (Properties::oem_crypto_use_fifo()) {
    destination_buffer_type_ = OEMCrypto_BufferType_Direct;
-  }
-  else if (Properties::oem_crypto_use_userspace_buffers()) {
+  } else if (Properties::oem_crypto_use_userspace_buffers()) {
    destination_buffer_type_ = OEMCrypto_BufferType_Clear;
-  }
-  else {
+  } else {
    return false;
  }

@@ -508,14 +604,10 @@ bool CryptoSession::RewrapDeviceRSAKey(const std::string& message,
                                       const std::string& signature,
                                       const std::string& nonce,
                                       const std::string& enc_rsa_key,
-                                       size_t enc_rsa_key_length,
                                       const std::string& rsa_key_iv,
                                       std::string* wrapped_rsa_key) {
-  LOGV("CryptoSession::RewrapDeviceRSAKey: Lock+++");
-  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
-  AutoLock auto_lock(crypto_engine->crypto_lock_);
-
-  LOGV("crypto session id=%ld", static_cast<uint32_t>(oec_session_id_));
+  LOGD("CryptoSession::RewrapDeviceRSAKey, session id=%ld",
+       static_cast<uint32_t>(oec_session_id_));

  const uint8_t* signed_msg = reinterpret_cast<const uint8_t*>(message.data());
  const uint8_t* msg_rsa_key = NULL;
@@ -524,21 +616,17 @@ bool CryptoSession::RewrapDeviceRSAKey(const std::string& message,
  if (enc_rsa_key.size() >= MAC_KEY_SIZE && rsa_key_iv.size() >= KEY_IV_SIZE) {
    msg_rsa_key = signed_msg + GetOffset(message, enc_rsa_key);
    msg_rsa_key_iv = signed_msg + GetOffset(message, rsa_key_iv);
-    msg_nonce = reinterpret_cast<const uint32_t*>(
-        signed_msg + GetOffset(message, nonce));
+    msg_nonce = reinterpret_cast<const uint32_t*>(signed_msg +
+                                                  GetOffset(message, nonce));
  }

  // Gets wrapped_rsa_key_length by passing NULL as uint8_t* wrapped_rsa_key
  // and 0 as wrapped_rsa_key_length.
  size_t wrapped_rsa_key_length = 0;
  OEMCryptoResult status = OEMCrypto_RewrapDeviceRSAKey(
-      oec_session_id_,
-      signed_msg, message.size(),
+      oec_session_id_, signed_msg, message.size(),
      reinterpret_cast<const uint8_t*>(signature.data()), signature.size(),
-      msg_nonce,
-      msg_rsa_key, enc_rsa_key_length,
-      msg_rsa_key_iv,
-      NULL,
+      msg_nonce, msg_rsa_key, enc_rsa_key.size(), msg_rsa_key_iv, NULL,
      &wrapped_rsa_key_length);
  if (status != OEMCrypto_ERROR_SHORT_BUFFER) {
    LOGE("OEMCrypto_RewrapDeviceRSAKey fails to get wrapped_rsa_key_length");
@@ -547,20 +635,16 @@ bool CryptoSession::RewrapDeviceRSAKey(const std::string& message,

  wrapped_rsa_key->resize(wrapped_rsa_key_length);
  status = OEMCrypto_RewrapDeviceRSAKey(
-      oec_session_id_,
-      signed_msg,
-      message.size(),
-      reinterpret_cast<const uint8_t*>(signature.data()),
-      signature.size(),
-      msg_nonce,
-      msg_rsa_key,
-      enc_rsa_key_length,
-      msg_rsa_key_iv,
-      reinterpret_cast<uint8_t*>(const_cast<char*>(wrapped_rsa_key->data())),
+      oec_session_id_, signed_msg, message.size(),
+      reinterpret_cast<const uint8_t*>(signature.data()), signature.size(),
+      msg_nonce, msg_rsa_key, enc_rsa_key.size(), msg_rsa_key_iv,
+      reinterpret_cast<uint8_t*>(&(*wrapped_rsa_key)[0]),
      &wrapped_rsa_key_length);

-  // TODO(fredgc): remove in K, when L1 library reports correct length.
+  // TODO(fredgc): b/8878371
+  // remove in K, when L1 library reports correct length.
  wrapped_rsa_key->resize(wrapped_rsa_key_length);
+
  if (OEMCrypto_SUCCESS != status) {
    LOGE("OEMCrypto_RewrapDeviceRSAKey fails with %d", status);
    return false;
@@ -569,4 +653,15 @@ bool CryptoSession::RewrapDeviceRSAKey(const std::string& message,
  return true;
 }

+bool CryptoSession::GetRandom(uint8_t* random_data, size_t data_length) {
+  OEMCryptoResult sts = OEMCrypto_GetRandom(random_data, data_length);
+
+  if (sts != OEMCrypto_SUCCESS) {
+    LOGE("OEMCrypto_GetRandom fails with %d", sts);
+    return false;
+  }
+
+  return true;
+}
+
 };  // namespace wvcdm