Widevine CENC drm engine update

bug: 8601053

This import syncs to the widevine git repository change
commit 6a99ad1b59ad39495f62954b3065ddc22b78da49

It includes the following changes from the widevine git
repository, which complete the jb-mr2 features

    Fix Unit Test Makefile
    Adds support for device certificate provisioning.
    Support application parameters
    Certificate based licensing
    Proto for client files
    Implement Property Query API
    Add Device Query For Unique ID
    Implement Generic Crypto in DrmEngine
    Do not validate Key IDs on clear playback
    Allow OEMCrypto_DecryptCTR with clear content and no key
    Add a case to the MediaDrm API test to repro b/8594163
    Implement requiresSecureDecoderComponent
    Implement Eventing API
    Add end-to-end decryption test with vectors
    Refactoring of properties class
    Refactor OEMCrypto unittest.
    Fix for b/8567853: License renewal doesn't renew license.
    Add KEY_ERROR callback to WvContentDecryptionModule() ctor.
    Merged certificate_provisioning.proto and
      client_identification.proto to license_protocol.proto.
    Fix nonce check failure after a malformed key in OEC Mock.
    asynchronize decryption
    Allow querying of control information
    make debugging AddKey & Decrypt statuses easier
    Revert "Revert "Send KEY_ERROR event to app on license
      expiration or failure""
    Revert "Send KEY_ERROR event to app on license expiration
      or failure"
    Send KEY_ERROR event to app on license expiration or failure
    remove extra session id copy
    use KeyError constants directly
    replace variable-length arrays with std::vector and fixed-sized array
    pass session ids as const references
    refactor key extraction and update keys on renewal
    Updates to enable renewals and signaling license expiration.
    fix error constant in OEMCrypto_DecryptCTR

Change-Id: I5f7236c7bdff1d5ece6115fd2893f8a1e1e07c50

libwvdrmengine/cdm/core/include/cdm_engine.h

@@ -3,6 +3,7 @@
 #ifndef CDM_BASE_CDM_ENGINE_H_
 #define CDM_BASE_CDM_ENGINE_H_
 
+#include "crypto_engine.h"
 #include "timer.h"
 #include "wv_cdm_types.h"
 
@@ -15,13 +16,13 @@ typedef std::map<CdmSessionId, CdmSession*> CdmSessionMap;
 
 class CdmEngine : public TimerHandler {
  public:
-  CdmEngine() {}
+  CdmEngine();
   ~CdmEngine();
 
   // Session related methods
   CdmResponseType OpenSession(const CdmKeySystem& key_system,
                               CdmSessionId* session_id);
-  CdmResponseType CloseSession(CdmSessionId& session_id);
+  CdmResponseType CloseSession(const CdmSessionId& session_id);
 
   // License related methods
   // Construct a valid license request
@@ -66,6 +67,10 @@ class CdmEngine : public TimerHandler {
   CdmResponseType QueryKeyStatus(const CdmSessionId& session_id,
                                  CdmQueryMap* key_info);
 
+  // Query seesion control information
+  CdmResponseType QueryKeyControlInfo(const CdmSessionId& session_id,
+                                      CdmQueryMap* key_info);
+
   // Provisioning related methods
   CdmResponseType GetProvisioningRequest(CdmProvisioningRequest* request,
                                          std::string* default_url);
@@ -92,20 +97,31 @@ class CdmEngine : public TimerHandler {
   bool IsKeyValid(const KeyId& key_id);
 
   // Event listener related methods
-  bool AttachEventListener(CdmSessionId& session_id,
+  bool AttachEventListener(const CdmSessionId& session_id,
                            WvCdmEventListener* listener);
-  bool DetachEventListener(CdmSessionId& session_id,
+  bool DetachEventListener(const CdmSessionId& session_id,
                            WvCdmEventListener* listener);
  private:
   // private methods
-  bool ValidateKeySystem(const CdmKeySystem& key_system);
   // Cancel all sessions
   bool CancelSessions();
+  void CleanupProvisioingSessions(CdmSession* cdm_session,
+                                  CryptoEngine* crypto_engine,
+                                  const CdmSessionId& cdm_session_id);
+  void ComposeJsonRequest(const std::string& message,
+                          const std::string& signature,
+                          CdmProvisioningRequest* request);
+
   // Parse a blob of multiple concatenated PSSH atoms to extract the first
   // widevine pssh
   // TODO(gmorgan): This should be done by the user of this class.
   bool ExtractWidevinePssh(const CdmInitData& init_data,
                            CdmInitData* output);
+  bool ParseJsonResponse(const CdmProvisioningResponse& json_str,
+                         const std::string& start_substr,
+                         const std::string& end_substr,
+                         std::string* result);
+  bool ValidateKeySystem(const CdmKeySystem& key_system);
 
   // timer related methods to drive policy decisions
   void EnablePolicyTimer();

libwvdrmengine/cdm/core/include/cdm_session.h

@@ -18,12 +18,10 @@ namespace wvcdm {
 
 class CdmSession {
  public:
-  CdmSession() : session_id_(GenerateSessionId()),
-                 license_received_(false),
-                 properties_valid_(false) {}
+  CdmSession() : session_id_(GenerateSessionId()), license_received_(false) {}
   ~CdmSession() {}
 
-  bool Init();
+  CdmResponseType Init();
 
   bool DestroySession();
 
@@ -35,7 +33,9 @@ class CdmSession {
   bool VerifySession(const CdmKeySystem& key_system,
                      const CdmInitData& init_data);
 
-  CdmResponseType GenerateKeyRequest(const CdmInitData& init_data,
+  CdmResponseType GenerateKeyRequest(const CdmInitData& pssh_data,
+                                     const CdmLicenseType license_type,
+                                     CdmAppParameterMap& app_parameters,
                                      CdmKeyMessage* key_request);
 
   // AddKey() - Accept license response and extract key info.
@@ -47,6 +47,9 @@ class CdmSession {
   // Query license information
   CdmResponseType QueryKeyStatus(CdmQueryMap* key_info);
 
+  // Query session control info
+  CdmResponseType QueryKeyControlInfo(CdmQueryMap* key_info);
+
   // Decrypt() - Accept encrypted buffer and return decrypted data.
   CdmResponseType Decrypt(bool is_encrypted,
                           const KeyId& key_id,
@@ -77,6 +80,8 @@ class CdmSession {
   // Generate unique ID for each new session.
   CdmSessionId GenerateSessionId();
 
+  bool LoadDeviceCertificate(std::string* cert, std::string* wrapped_key);
+
   // instance variables
   const CdmSessionId session_id_;
   CdmKeySystem key_system_;
@@ -85,11 +90,11 @@ class CdmSession {
   PolicyEngine policy_engine_;
   bool license_received_;
 
-  bool properties_valid_;
-  bool require_explicit_renew_request_;
-
   KeyId key_id_;
 
+  // Used for certificate based licensing
+  std::string wrapped_key_;
+
   std::set<WvCdmEventListener*> listeners_;
 
   // TODO(kqyang): CdmKey not defined yet

libwvdrmengine/cdm/core/include/crypto_engine.h

@@ -5,6 +5,8 @@
 #ifndef CDM_BASE_CRYPTO_ENGINE_H_
 #define CDM_BASE_CRYPTO_ENGINE_H_
 
+#include <string>
+
 #include "crypto_session.h"
 #include "lock.h"
 #include "wv_cdm_types.h"
@@ -46,13 +48,7 @@ class CryptoEngine {
   } SecurityLevel;
 
   SecurityLevel GetSecurityLevel();
-
-  bool properties_valid() const { return properties_valid_; }
-  bool oem_crypto_use_secure_buffers() const
-      { return oem_crypto_use_secure_buffers_; }
-  bool oem_crypto_use_fifo() const { return oem_crypto_use_fifo_; }
-  bool oem_crypto_use_userspace_buffers() const
-      { return oem_crypto_use_userspace_buffers_; }
+  std::string GetDeviceUniqueId();
 
 private:
 
@@ -69,11 +65,6 @@ private:
   mutable Lock sessions_lock_;
   CryptoSessionMap sessions_;
 
-  bool properties_valid_;
-  bool oem_crypto_use_secure_buffers_;
-  bool oem_crypto_use_fifo_;
-  bool oem_crypto_use_userspace_buffers_;
-
   CORE_DISALLOW_COPY_AND_ASSIGN(CryptoEngine);
 };
 

libwvdrmengine/cdm/core/include/crypto_key.h

@@ -35,8 +35,6 @@ private:
   std::string key_data_;
   std::string key_control_;
   std::string key_control_iv_;
-
-  CORE_DISALLOW_COPY_AND_ASSIGN(CryptoKey);
 };
 
 }; // namespace wvcdm

libwvdrmengine/cdm/core/include/crypto_session.h

@@ -44,11 +44,24 @@ class CryptoSession {
                 const std::string& mac_key,
                 int num_keys,
                 const CryptoKey* key_array);
+  bool LoadCertificatePrivateKey(std::string& wrapped_key);
   bool RefreshKeys(const std::string& message,
                    const std::string& signature,
                    int num_keys,
                    const CryptoKey* key_array);
   bool GenerateNonce(uint32_t* nonce);
+  bool GenerateDerivedKeys(const std::string& message);
+  bool GenerateDerivedKeys(const std::string& message,
+                           const std::string& session_key);
+  bool GenerateSignature(const std::string& message,
+                         std::string* signature);
+  bool RewrapDeviceRSAKey(const std::string& message,
+                          const uint32_t* nonce,
+                          const uint8_t* enc_rsa_key,
+                          size_t enc_rsa_key_length,
+                          const uint8_t* enc_rsa_key_iv,
+                          uint8_t* wrapped_rsa_key,
+                          size_t* wrapped_rsa_key_length);
 
   // Media data path
   bool SelectKey(const std::string& key_id);
@@ -61,6 +74,7 @@ class CryptoSession {
                           bool is_video);
 
  private:
+  static const size_t kSignatureSize = 32; // size for HMAC-SHA256 signature
 
   void GenerateMacContext(const std::string& input_context,
                           std::string* deriv_context);

libwvdrmengine/cdm/core/include/license.h

@@ -9,6 +9,7 @@
 namespace wvcdm {
 
 using video_widevine_server::sdk::LicenseIdentification;
+using video_widevine_server::sdk::SignedMessage;
 
 class CryptoSession;
 class PolicyEngine;
@@ -23,19 +24,26 @@ class CdmLicense {
   bool Init(const std::string& token, CryptoSession* session,
             PolicyEngine* policy_engine);
 
-  bool PrepareKeyRequest(const CdmInitData& init_data,
+  bool PrepareKeyRequest(const CdmInitData& pssh_data,
+                         const CdmLicenseType license_type,
+                         CdmAppParameterMap& app_parameters,
                          CdmKeyMessage* signed_request);
   bool PrepareKeyRenewalRequest(CdmKeyMessage* signed_request);
-  bool HandleKeyResponse(const CdmKeyResponse& license_response);
-  bool HandleKeyRenewalResponse(const CdmKeyResponse& license_response);
+  CdmResponseType HandleKeyResponse(const CdmKeyResponse& license_response);
+  CdmResponseType HandleKeyRenewalResponse(
+      const CdmKeyResponse& license_response);
 
 private:
+  CdmResponseType HandleKeyErrorResponse(const SignedMessage& signed_message);
 
   LicenseIdentification license_id_;
   CryptoSession* session_;
   PolicyEngine* policy_engine_;
   std::string token_;
 
+  // Used for certificate based licensing
+  CdmKeyMessage key_request_;
+
   CORE_DISALLOW_COPY_AND_ASSIGN(CdmLicense);
 };
 

libwvdrmengine/cdm/core/include/lock.h

@@ -35,16 +35,23 @@ class Lock {
 };
 
 // Manages the lock automatically. It will be locked when AutoLock
-// is constructed and release when AutoLock goes out of scope
+// is constructed and release when AutoLock goes out of scope.
 class AutoLock {
  public:
-  explicit AutoLock(Lock& lock);
-  explicit AutoLock(Lock* lock);
-  ~AutoLock();
+  explicit AutoLock(Lock& lock) : lock_(&lock) {
+    lock_->Acquire();
+  }
+
+  explicit AutoLock(Lock* lock) : lock_(lock) {
+    lock_->Acquire();
+  }
+
+  ~AutoLock() {
+    lock_->Release();
+  }
 
  private:
-  class Impl;
-  Impl *impl_;
+  Lock *lock_;
 
   CORE_DISALLOW_COPY_AND_ASSIGN(AutoLock);
 };

libwvdrmengine/cdm/core/include/policy_engine.h

@@ -101,9 +101,6 @@ class PolicyEngine {
   int64_t next_renewal_time_;
   int64_t policy_max_duration_seconds_;
 
-  bool properties_valid_;
-  bool begin_license_usage_when_received_;
-
   Clock* clock_;
 
   // For testing

libwvdrmengine/cdm/core/include/properties.h

@@ -11,39 +11,62 @@
 
 namespace wvcdm {
 
-typedef std::map<std::string, bool> CdmBooleanPropertiesMap;
-
-struct CdmBooleanProperties {
-  std::string name;
-  bool value;
-};
-
 // This class saves information about features and properties enabled
-// for a given platform. At initialization it reads in properties from
+// for a given platform. At initialization it initializes properties from
 // property_configuration.h. That file specifies features selected for each
-// platform. Core CDM can then query enabled features though the GetProperty
-// method and tailor its behaviour in a non-platform specific way.
-//
-// Additional features can be added at runtime as long as the key names do
-// not clash. Also, only boolean properties are supported at this time, though
-// it should be trivial to in support for other datatypes.
+// platform. Core CDM can then query enabled features though specific getter
+// methods.
+// Setter methods are provided but their only planned use is for testing.
 class Properties {
  public:
-  static Properties* GetInstance();
+  static void Init();
+
+  static inline bool begin_license_usage_when_received() {
+    return begin_license_usage_when_received_;
+  }
+  static inline bool require_explicit_renew_request() {
+    return require_explicit_renew_request_;
+  }
+  static inline bool oem_crypto_use_secure_buffers() {
+    return oem_crypto_use_secure_buffers_;
+  }
+  static inline bool oem_crypto_use_fifo() {
+    return oem_crypto_use_fifo_;
+  }
+  static inline bool oem_crypto_use_userspace_buffers() {
+    return oem_crypto_use_userspace_buffers_;
+  }
+  static inline bool use_certificates_as_identification() {
+    return use_certificates_as_identification_;
+  }
 
-  // value argument is only set if the property was found (true is returned)
-  bool GetProperty(std::string& key, bool& value);
 
  private:
-  Properties();
-  ~Properties() {}
+  static void set_begin_license_usage_when_received(bool flag) {
+    begin_license_usage_when_received_ = flag;
+  }
+  static void set_require_explicit_renew_request(bool flag) {
+    require_explicit_renew_request_ = flag;
+  }
+  static void set_oem_crypto_use_secure_buffers(bool flag) {
+    oem_crypto_use_secure_buffers_ = flag;
+  }
+  static void set_oem_crypto_use_fifo(bool flag) {
+    oem_crypto_use_fifo_ = flag;
+  }
+  static void set_oem_crypto_use_userspace_buffers(bool flag) {
+    oem_crypto_use_userspace_buffers_ = flag;
+  }
+  static void set_use_certificates_as_identification(bool flag) {
+    use_certificates_as_identification_ = flag;
+  }
 
-  void SetProperty(std::string& key, bool value);
-
-  static Properties* instance_;
-  static Lock properties_lock_;
-
-  CdmBooleanPropertiesMap boolean_properties_;
+  static bool begin_license_usage_when_received_;
+  static bool require_explicit_renew_request_;
+  static bool oem_crypto_use_secure_buffers_;
+  static bool oem_crypto_use_fifo_;
+  static bool oem_crypto_use_userspace_buffers_;
+  static bool use_certificates_as_identification_;
 
   CORE_DISALLOW_COPY_AND_ASSIGN(Properties);
 };

libwvdrmengine/cdm/core/include/wv_cdm_constants.h

@@ -16,24 +16,6 @@ static const size_t KEY_PAD_SIZE = 16;
 static const size_t KEY_SIZE = 16;
 static const size_t MAC_KEY_SIZE = 32;
 
-// define boolean property keys here
-// If false begin license usage on first playback
-static std::string kPropertyKeyBeginLicenseUsageWhenReceived =
-    "WVBeginLicenseUsageWhenReceived";
-// If false, calls to Generate Key request, after the first one,
-// will result in a renewal request being generated
-static std::string kPropertyKeyRequireExplicitRenewRequest =
-    "WVRequireExplicitRenewRequest";
-// Set only one of the three below to true. If secure buffer
-// is selected, fallback to userspace buffers may occur
-// if L1/L2 OEMCrypto APIs fail
-static std::string kPropertyKeyOemCryptoUseSecureBuffers =
-    "WVBeginLicenseOemCryptoUseSecureBuffer";
-static std::string kPropertyKeyOemCryptoUseFifo =
-    "WVBeginLicenseOemCryptoUseFifo";
-static std::string kPropertyKeyOemCryptoUseUserSpaceBuffers =
-    "WVBeginLicenseOemCryptoUseUserSpaceBuffers";
-
 // define query keys, values here
 static const std::string QUERY_KEY_LICENSE_TYPE = "LicenseType";
                                                     // "Streaming", "Offline"
@@ -49,8 +31,12 @@ static const std::string QUERY_KEY_PLAYBACK_DURATION_REMAINING =
     "PlaybackDurationRemaining";                    // non-negative integer
 static const std::string QUERY_KEY_RENEWAL_SERVER_URL = "RenewalServerUrl";
                                                     // url
+static const std::string QUERY_KEY_OEMCRYPTO_SESSION_ID = "OemCryptoSessionId";
+                                                    // session id
 static const std::string QUERY_KEY_SECURITY_LEVEL = "SecurityLevel";
                                                     // "L1", "L3"
+static const std::string QUERY_KEY_DEVICE_ID = "DeviceID";
+                                               // device unique id
 
 static const std::string QUERY_VALUE_TRUE = "True";
 static const std::string QUERY_VALUE_FALSE = "False";

libwvdrmengine/cdm/core/include/wv_cdm_types.h

@@ -35,6 +35,8 @@ enum CdmResponseType {
   KEY_MESSAGE,
   NEED_KEY,
   KEY_CANCELED,
+  NEED_PROVISIONING,
+  DEVICE_REVOKED,
 };
 
 #define CORE_DISALLOW_COPY_AND_ASSIGN(TypeName) \

libwvdrmengine/cdm/core/src/cdm_engine.cpp

@@ -7,7 +7,10 @@
 #include "buffer_reader.h"
 #include "cdm_session.h"
 #include "crypto_engine.h"
+#include "license_protocol.pb.h"
 #include "log.h"
+#include "properties.h"
+#include "string_conversions.h"
 #include "wv_cdm_constants.h"
 #include "wv_cdm_event_listener.h"
 
@@ -17,7 +20,17 @@
 
 namespace wvcdm {
 
-typedef std::map<CdmSessionId,CdmSession*>::iterator CdmSessionIter;
+// Protobuf generated classes.
+using video_widevine_server::sdk::ClientIdentification;
+using video_widevine_server::sdk::ProvisioningRequest;
+using video_widevine_server::sdk::ProvisioningResponse;
+using video_widevine_server::sdk::SignedProvisioningMessage;
+
+typedef std::map<CdmSessionId,CdmSession*>::const_iterator CdmSessionIter;
+
+CdmEngine::CdmEngine() {
+  Properties::Init();
+}
 
 CdmEngine::~CdmEngine() {
   CancelSessions();
@@ -57,10 +70,11 @@ CdmResponseType CdmEngine::OpenSession(
 
   CdmSessionId new_session_id = new_session->session_id();
 
-  if (!new_session->Init()) {
+  CdmResponseType sts = new_session->Init();
+  if (sts != NO_ERROR) {
     LOGE("CdmEngine::OpenSession: bad session init");
     delete(new_session);
-    return UNKNOWN_ERROR;
+    return sts;
   }
 
   sessions_[new_session_id] = new_session;
@@ -68,7 +82,7 @@ CdmResponseType CdmEngine::OpenSession(
   return NO_ERROR;
 }
 
-CdmResponseType CdmEngine::CloseSession(CdmSessionId& session_id) {
+CdmResponseType CdmEngine::CloseSession(const CdmSessionId& session_id) {
   LOGI("CdmEngine::CloseSession");
 
   CdmSessionIter iter = sessions_.find(session_id);
@@ -123,6 +137,8 @@ CdmResponseType CdmEngine::GenerateKeyRequest(
 
   // TODO(edwinwong, rfrias): need to pass in license type and app parameters
   CdmResponseType sts = iter->second->GenerateKeyRequest(extracted_pssh,
+                                                         license_type,
+                                                         app_parameters,
                                                          key_request);
 
   if (KEY_MESSAGE != sts) {
@@ -168,7 +184,7 @@ CdmResponseType CdmEngine::AddKey(
   if (KEY_ADDED != sts) {
     LOGE("CdmEngine::AddKey: keys not added, result = %d", (int)sts);
   }
-
+  EnablePolicyTimer();
   return sts;
 }
 
@@ -195,7 +211,7 @@ CdmResponseType CdmEngine::CancelKeyRequest(
   }
 
   // TODO(edwinwong, rfrias): unload keys here
-
+  DisablePolicyTimer();
   return NO_ERROR;
 }
 
@@ -299,6 +315,8 @@ CdmResponseType CdmEngine::QueryStatus(CdmQueryMap* key_info) {
       return KEY_ERROR;
   }
 
+  (*key_info)[QUERY_KEY_DEVICE_ID] = crypto_engine->GetDeviceUniqueId();
+
   return NO_ERROR;
 }
 
@@ -314,16 +332,313 @@ CdmResponseType CdmEngine::QueryKeyStatus(
   return iter->second->QueryKeyStatus(key_info);
 }
 
+CdmResponseType CdmEngine::QueryKeyControlInfo(
+    const CdmSessionId& session_id,
+    CdmQueryMap* key_info) {
+  LOGI("CdmEngine::QueryKeyControlInfo");
+  CdmSessionIter iter = sessions_.find(session_id);
+  if (iter == sessions_.end()) {
+    LOGE("CdmEngine::QueryKeyControlInfo: session_id not found = %s", session_id.c_str());
+    return KEY_ERROR;
+  }
+  return iter->second->QueryKeyControlInfo(key_info);
+}
+
+void CdmEngine::CleanupProvisioingSessions(
+    CdmSession* cdm_session,
+    CryptoEngine* crypto_engine,
+    const CdmSessionId& cdm_session_id) {
+  if (NULL == cdm_session) return;
+
+  cdm_session->DestroySession();
+  if (crypto_engine) crypto_engine->DestroySession(cdm_session_id);
+  delete cdm_session;
+}
+
+/*
+ * This function converts message and signature into base64 format.
+ * It then wraps it in JSON format expected by the Apiary frontend.
+ * Apiary requires the base64 encoding to replace '+' with minus '-',
+ * and '/' with underscore '_'; opposite to stubby's.
+ *
+ * Returns the JSON formated string in *request.
+ * The JSON formated request takes the following format:
+ * {
+ *   'signedRequest': {
+ *     'message': 'base64 encoded message',
+ *     'signature': 'base64 encoded signature'
+ *   }
+ * }
+ */
+void CdmEngine::ComposeJsonRequest(
+    const std::string& message,
+    const std::string& signature,
+    CdmProvisioningRequest* request) {
+
+  // performs base64 encoding for message
+  std::vector<uint8_t> message_vector(message.begin(), message.end());
+  std::string message_b64 = Base64SafeEncode(message_vector);
+  LOGD("b64 serialized req:\r\n%s", message_b64.data());
+
+  // performs base64 encoding for signature
+  std::vector<uint8_t> signature_vector(signature.begin(), signature.end());
+  std::string signature_b64 = Base64SafeEncode(signature_vector);
+  LOGD("b64 signature:\r\n%s", signature_b64.data());
+
+  // TODO(edwinwong): write a function to escape JSON output
+  request->assign("{'signedRequest':{'message':'");
+  request->append(message_b64);
+  request->append("','signature':'");
+  request->append(signature_b64);
+  request->append("'}}");
+  LOGD("json str:\r\n%s", request->c_str());
+
+}
+
+/*
+ * Composes a device provisioning request and output the request in JSON format
+ * in *request. It also returns the default url for the provisioning server
+ * in *default_url.
+ *
+ * Returns NO_ERROR for success and UNKNOWN_ERROR if fails.
+ */
 CdmResponseType CdmEngine::GetProvisioningRequest(
     CdmProvisioningRequest* request,
     std::string* default_url) {
-  // TODO(edwinwong, rfrias): add implementation
+  if (!request || !default_url) {
+    LOGE("CdmEngine::GetProvisioningRequest: invalid input parameters");
+    return UNKNOWN_ERROR;
+  }
+
+  //
+  //---------------------------------------------------------------------------
+  // This function can be called before a cdm session is created.
+  // First creates a cdm session, then creates a crypto session.
+  //
+  CdmSession* cdm_session = new CdmSession();
+  if (!cdm_session) {
+    LOGE("CdmEngine::GetProvisioningRequest: fails to create a cdm session");
+    return UNKNOWN_ERROR;
+  }
+
+  if (cdm_session->session_id().empty()) {
+    LOGE("CdmEngine::GetProvisioningRequest: fails to generate session ID");
+    delete cdm_session;
+    return UNKNOWN_ERROR;
+  }
+
+  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
+  if (!crypto_engine) {
+    LOGE("CdmEngine::GetProvisioningRequest: fails to create a crypto engine");
+    delete cdm_session;
+    return UNKNOWN_ERROR;
+  }
+
+  CdmSessionId cdm_session_id = cdm_session->session_id();
+  CryptoSession* crypto_session = crypto_engine->CreateSession(cdm_session_id);
+  if (!crypto_session) {
+    LOGE("CdmEngine::GetProvisioningRequest: fails to create a crypto session");
+    delete cdm_session;
+    return UNKNOWN_ERROR;
+  }
+
+  //
+  //---------------------------------------------------------------------------
+  // Prepares device provisioning request.
+  //
+  ProvisioningRequest provisioning_request;
+  ClientIdentification* client_id = provisioning_request.mutable_client_id();
+  client_id->set_type(ClientIdentification::KEYBOX);
+  std::string token;
+  if (!crypto_engine->GetToken(&token)) {
+    LOGE("CdmEngine::GetProvisioningRequest: fails to get token");
+    CleanupProvisioingSessions(cdm_session, crypto_engine, cdm_session_id);
+    return UNKNOWN_ERROR;
+  }
+  client_id->set_token(token);
+
+  uint32_t nonce;
+  if (!crypto_session->GenerateNonce(&nonce)) {
+    LOGE("CdmEngine::GetProvisioningRequest: fails to generate a nonce");
+    crypto_engine->DestroySession(cdm_session_id);
+    CleanupProvisioingSessions(cdm_session, crypto_engine, cdm_session_id);
+    return UNKNOWN_ERROR;
+  }
+  provisioning_request.set_nonce(UintToString(nonce));
+
+  // Serializes the provisioning request.
+  std::string serialized_request;
+  provisioning_request.SerializeToString(&serialized_request);
+
+  // Derives signing and encryption keys and constructs signature.
+  std::string request_signature;
+  if (!crypto_session->PrepareRequest(serialized_request, &request_signature)) {
+    request->clear();
+    CleanupProvisioingSessions(cdm_session, crypto_engine, cdm_session_id);
+    return UNKNOWN_ERROR;
+  }
+
+  if (request_signature.empty()) {
+    request->clear();
+    CleanupProvisioingSessions(cdm_session, crypto_engine, cdm_session_id);
+    return UNKNOWN_ERROR;
+  }
+
+  // converts request into JSON string
+  ComposeJsonRequest(serialized_request, request_signature, request);
+
+  // TODO(edwinwong): returns default provisioning server url
+  default_url->clear();
+
+  //
+  //---------------------------------------------------------------------------
+  // Closes the cdm session.
+  //
+  CleanupProvisioingSessions(cdm_session, crypto_engine, cdm_session_id);
   return NO_ERROR;
 }
 
+/*
+ * Parses the input json_str and locates substring using start_substr and
+ * end_stubstr. The found base64 substring is then decoded and returns
+ * in *result.
+ *
+ * Returns true for success and false if fails.
+ */
+bool CdmEngine::ParseJsonResponse(
+    const CdmProvisioningResponse& json_str,
+    const std::string& start_substr,
+    const std::string& end_substr,
+    std::string* result) {
+  std::string b64_string;
+  size_t start = json_str.find(start_substr);
+  if (start == json_str.npos) {
+    LOGE("ParseJsonResponse: cannot find start substring");
+    return false;
+  } else {
+    size_t end = json_str.find(end_substr, start + start_substr.length());
+    if (end == json_str.npos) {
+      LOGE("ParseJsonResponse cannot locate end substring");
+      return false;
+    }
+
+    size_t b64_string_size = end - start - start_substr.length();
+    b64_string.assign(json_str, start + start_substr.length(), b64_string_size);
+
+    // Due to the size of the message, debug string cannot dump out the
+    // entire string. Dump the beginning and end to verify instead.
+    LOGD("size=%u, b64_string start=%s, end=%s", b64_string.length(),
+         b64_string.substr(0, 16).c_str(),
+         b64_string.substr(b64_string_size - 16).c_str());
+  }
+
+  // Decodes base64 substring and returns it in *result
+  std::vector<uint8_t> result_vector = Base64SafeDecode(b64_string);
+  result->assign(result_vector.begin(), result_vector.end());
+
+  return true;
+}
+
+/*
+ * The response message consists of a device certificate and the device RSA key.
+ * The device RSA key is stored in the T.E.E. The device certificate is stored
+ * in the device.
+ *
+ * Returns NO_ERROR for success and UNKNOWN_ERROR if fails.
+ */
 CdmResponseType CdmEngine::HandleProvisioningResponse(
     CdmProvisioningResponse& response) {
-  // TODO(edwinwong, rfrias): add implementation
+  if (response.empty()) {
+    LOGE("CdmEngine::HandleProvisioningResponse: Empty provisioning response.");
+    return UNKNOWN_ERROR;
+  }
+
+  //---------------------------------------------------------------------------
+  // Extracts response from JSON string, decodes base64 signed message
+  const std::string kMessageStart = "\"message\": \"";
+  const std::string kMessageEnd = "\",";
+  std::string signed_message;
+  if (!ParseJsonResponse(response, kMessageStart, kMessageEnd, &signed_message)) {
+    LOGE("Fails to extract signed message from JSON response");
+    return UNKNOWN_ERROR;
+  }
+
+  // Extracts signature from JSON string, decodes base64 signature
+  const std::string kSignatureStart = "\"signature\": \"";
+  const std::string kSignatureEnd = "\"";
+  std::string signature;
+  if (!ParseJsonResponse(response, kSignatureStart, kSignatureEnd, &signature)) {
+    LOGE("Fails to extract signature from JSON response");
+    return UNKNOWN_ERROR;
+  }
+
+  //
+  //---------------------------------------------------------------------------
+  // First creates a cdm session, then creates a crypto session.
+  //
+  CdmSession* cdm_session = new CdmSession();
+  if (!cdm_session) {
+    LOGE("CdmEngine::HandleProvisioningResponse: fails to create a cdm session");
+    return UNKNOWN_ERROR;
+  }
+
+  if (cdm_session->session_id().empty()) {
+    LOGE("CdmEngine::HandleProvisioningResponse: fails to generate session ID");
+    delete cdm_session;
+    return UNKNOWN_ERROR;
+  }
+
+  CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
+  if (!crypto_engine) {
+    LOGE("CdmEngine::HandleProvisioningResponse: fails to create a crypto engine");
+    delete cdm_session;
+    return UNKNOWN_ERROR;
+  }
+
+  CdmSessionId cdm_session_id = cdm_session->session_id();
+  CryptoSession* crypto_session = crypto_engine->CreateSession(cdm_session_id);
+  if (!crypto_session) {
+    LOGE("CdmEngine::HandleProvisioningResponse: fails to create a crypto session");
+    delete cdm_session;
+    return UNKNOWN_ERROR;
+  }
+
+  //---------------------------------------------------------------------------
+  // Authenticates provisioning response using D1s (server key derived from
+  // the provisioing request's input). Validate provisioning response and
+  // stores private device RSA key and certificate.
+  ProvisioningResponse provisioning_response;
+  if (!provisioning_response.ParseFromString(signed_message)) {
+    LOGE("CdmEngine::HandleProvisioningResponse: fails to parse signed message");
+    CleanupProvisioingSessions(cdm_session, crypto_engine, cdm_session_id);
+    return UNKNOWN_ERROR;
+  }
+  const std::string& enc_rsa_key = provisioning_response.device_rsa_key();
+  const std::string& enc_rsa_key_iv = provisioning_response.device_rsa_key_iv();
+  uint32_t nonce = strtoul(provisioning_response.nonce().data(), NULL, 10);
+  std::vector<uint8_t> wrapped_rsa_key;
+  size_t wrapped_rsa_key_length = 0;
+  if (!crypto_session->RewrapDeviceRSAKey(response,
+                                     &nonce,
+                                     reinterpret_cast<const uint8_t*>(enc_rsa_key.data()),
+                                     enc_rsa_key.length(),
+                                     reinterpret_cast<const uint8_t*>(enc_rsa_key_iv.data()),
+                                     &wrapped_rsa_key[0],
+                                     &wrapped_rsa_key_length)) {
+    LOGE("CdmEngine::HandleProvisioningResponse: RewrapDeviceRSAKey fails");
+    CleanupProvisioingSessions(cdm_session, crypto_engine, cdm_session_id);
+    return UNKNOWN_ERROR;
+  }
+
+  // TODO(edwinwong): stores private device RSA key and cert
+  const std::string&  device_certificate = provisioning_response.device_certificate();
+
+  //
+  //---------------------------------------------------------------------------
+  // Closes the cdm session.
+  //
+  CleanupProvisioingSessions(cdm_session, crypto_engine, cdm_session_id);
+
   return NO_ERROR;
 }
 
@@ -371,7 +686,7 @@ bool CdmEngine::IsKeyValid(const KeyId& key_id) {
 }
 
 bool CdmEngine::AttachEventListener(
-    CdmSessionId& session_id,
+    const CdmSessionId& session_id,
     WvCdmEventListener* listener) {
 
   CdmSessionIter iter = sessions_.find(session_id);
@@ -383,7 +698,7 @@ bool CdmEngine::AttachEventListener(
 }
 
 bool CdmEngine::DetachEventListener(
-    CdmSessionId& session_id,
+    const CdmSessionId& session_id,
     WvCdmEventListener* listener) {
 
   CdmSessionIter iter = sessions_.find(session_id);

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -4,6 +4,7 @@
 #include "cdm_session.h"
 
 #include <iostream>
+#include <sstream>
 
 #include "clock.h"
 #include "crypto_engine.h"
@@ -16,31 +17,32 @@ namespace wvcdm {
 
 typedef std::set<WvCdmEventListener*>::iterator CdmEventListenerIter;
 
-bool CdmSession::Init() {
+CdmResponseType CdmSession::Init() {
   CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
   if (!crypto_engine) {
     LOGE("CdmSession::Init failed to get CryptoEngine instance.");
-    return false;
+    return UNKNOWN_ERROR;
   }
 
   crypto_session_ = crypto_engine->CreateSession(session_id_);
   if (!crypto_session_) {
-    return false;
+    return UNKNOWN_ERROR;
   }
 
   std::string token;
-  if (!crypto_engine->GetToken(&token)) return false;
-
-  if (!Properties::GetInstance()->GetProperty(
-      kPropertyKeyRequireExplicitRenewRequest,
-      require_explicit_renew_request_)) {
-    LOGE("CdmSession::Init: Unable to access property - require explicit renew");
+  if (Properties::use_certificates_as_identification()) {
+    if (!LoadDeviceCertificate(&token, &wrapped_key_))
+      return NEED_PROVISIONING;
   }
   else {
-    properties_valid_ = true;
+    if (!crypto_engine->GetToken(&token))
+      return UNKNOWN_ERROR;
   }
 
-  return license_parser_.Init(token, crypto_session_, &policy_engine_);
+  if (license_parser_.Init(token, crypto_session_, &policy_engine_))
+    return NO_ERROR;
+  else
+    return UNKNOWN_ERROR;
 }
 
 bool CdmSession::DestroySession() {
@@ -58,13 +60,11 @@ bool CdmSession::VerifySession(const CdmKeySystem& key_system,
   return true;
 }
 
-CdmResponseType CdmSession::GenerateKeyRequest(const CdmInitData& init_data,
-                                               CdmKeyMessage* key_request) {
-  if (!properties_valid_) {
-    LOGW("CdmSession::GenerateKeyRequest: Unable to access properties");
-    return UNKNOWN_ERROR;
-  }
-
+CdmResponseType CdmSession::GenerateKeyRequest(
+    const CdmInitData& pssh_data,
+    const CdmLicenseType license_type,
+    CdmAppParameterMap& app_parameters,
+    CdmKeyMessage* key_request) {
   if (!crypto_session_) {
     LOGW("CdmSession::GenerateKeyRequest: Invalid crypto session");
     return UNKNOWN_ERROR;
@@ -76,11 +76,19 @@ CdmResponseType CdmSession::GenerateKeyRequest(const CdmInitData& init_data,
   }
 
   if (license_received_) {
-    return require_explicit_renew_request_ ?
+    return Properties::require_explicit_renew_request() ?
         UNKNOWN_ERROR : GenerateRenewalRequest(key_request);
   }
   else {
-    if(!license_parser_.PrepareKeyRequest(init_data, key_request)) {
+    if (Properties::use_certificates_as_identification()) {
+      if (!crypto_session_->LoadCertificatePrivateKey(wrapped_key_))
+        return NEED_PROVISIONING;
+    }
+
+    if (!license_parser_.PrepareKeyRequest(pssh_data,
+                                           license_type,
+                                           app_parameters,
+                                           key_request)) {
       return KEY_ERROR;
     } else {
       return KEY_MESSAGE;
@@ -101,16 +109,16 @@ CdmResponseType CdmSession::AddKey(const CdmKeyResponse& key_response) {
   }
 
   if (license_received_) {
-    return require_explicit_renew_request_ ?
+    return Properties::require_explicit_renew_request() ?
         UNKNOWN_ERROR : RenewKey(key_response);
   }
   else {
-    if (!license_parser_.HandleKeyResponse(key_response)) {
-      return KEY_ERROR;
-    } else {
+    CdmResponseType sts = license_parser_.HandleKeyResponse(key_response);
+
+    if (sts == KEY_ADDED)
       license_received_ = true;
-      return KEY_ADDED;
-    }
+
+    return sts;
   }
 }
 
@@ -118,6 +126,16 @@ CdmResponseType CdmSession::QueryKeyStatus(CdmQueryMap* key_info) {
   return policy_engine_.Query(key_info);
 }
 
+CdmResponseType CdmSession::QueryKeyControlInfo(CdmQueryMap* key_info) {
+  if ((!crypto_session_) || (!crypto_session_->IsOpen()))
+    return UNKNOWN_ERROR;
+
+  std::stringstream ss;
+  ss << crypto_session_->oec_session_id();
+  (*key_info)[QUERY_KEY_OEMCRYPTO_SESSION_ID] = ss.str();
+  return NO_ERROR;
+}
+
 // CancelKeyRequest() - Cancel session.
 CdmResponseType CdmSession::CancelKeyRequest() {
   // TODO(gmorgan): cancel and clean up session
@@ -144,12 +162,12 @@ CdmResponseType CdmSession::Decrypt(bool is_encrypted,
         key_id_ = key_id;
       }
       else {
-        return UNKNOWN_ERROR;
+        return NEED_KEY;
       }
     }
   }
 
-  return crypto_session_->Decrypt(is_encrypted, encrypt_buffer, encrypt_length, 
+  return crypto_session_->Decrypt(is_encrypted, encrypt_buffer, encrypt_length,
                                   iv, block_offset, decrypt_buffer, is_video);
 }
 
@@ -157,7 +175,7 @@ CdmResponseType CdmSession::Decrypt(bool is_encrypted,
 // GenerateRenewalRequest() - Construct valid renewal request for the current
 // session keys.
 CdmResponseType CdmSession::GenerateRenewalRequest(CdmKeyMessage* key_request) {
-  if(!license_parser_.PrepareKeyRenewalRequest(key_request)) {
+  if (!license_parser_.PrepareKeyRenewalRequest(key_request)) {
     return KEY_ERROR;
   } else {
     return KEY_MESSAGE;
@@ -166,11 +184,7 @@ CdmResponseType CdmSession::GenerateRenewalRequest(CdmKeyMessage* key_request) {
 
 // RenewKey() - Accept renewal response and update key info.
 CdmResponseType CdmSession::RenewKey(const CdmKeyResponse& key_response) {
-  if (!license_parser_.HandleKeyRenewalResponse(key_response)) {
-    return KEY_ERROR;
-  } else {
-    return KEY_ADDED;
-  }
+  return license_parser_.HandleKeyRenewalResponse(key_response);
 }
 
 bool CdmSession::IsKeyValid(const KeyId& key_id) {
@@ -187,6 +201,12 @@ CdmSessionId CdmSession::GenerateSessionId() {
   return kSessionPrefix + IntToString(++session_num);
 }
 
+bool CdmSession::LoadDeviceCertificate(std::string* certificate,
+                                       std::string* wrapped_key) {
+  // TODO(edwingwong,rfrias): Need to read in the private key
+  return false;
+}
+
 bool CdmSession::AttachEventListener(WvCdmEventListener* listener) {
   std::pair<CdmEventListenerIter, bool> result = listeners_.insert(listener);
   return result.second;

libwvdrmengine/cdm/core/src/certificate_provisioning.proto

@@ -1,43 +0,0 @@
-// Copyright 2013 Google Inc. All Rights Reserved.
-// Author: tinskip@google.com (Thomas Inskip)
-//
-// Description:
-//   Public protocol buffer definitions for Widevine Device Certificate
-//   Provisioning protocol.
-
-syntax = "proto2";
-
-package video_widevine_server.sdk;
-
-import "vendor/widevine/libwvdrmengine/cdm/core/src/client_identification.proto";
-option optimize_for = LITE_RUNTIME;
-
-// Provisioning request sent by client devices to provisioning service.
-message ProvisioningRequest {
-  // Device root of trust and other client identification. Required.
-  optional ClientIdentification client_id = 1;
-  // Nonce value used to prevent replay attacks. Required.
-  optional bytes nonce = 2;
-}
-
-// Provisioning response sent by the provisioning server to client devices.
-message ProvisioningResponse {
-  // AES-128 encrypted device private RSA key. PKCS#1 ASN.1 DER-encoded.
-  // Required.
-  optional bytes device_rsa_key = 1;
-  // Initialization vector used to encrypt device_rsa_key. Required.
-  optional bytes device_rsa_key_iv = 2;
-  // Serialized DeviceCertificate. Required.
-  optional bytes device_certificate = 3;
-  // Nonce value matching nonce in ProvisioningRequest. Required.
-  optional bytes nonce = 4;
-}
-
-// Serialized ProvisioningRequest or ProvisioningResponse signed with
-// The message authentication key.
-message SignedProvisioningMessage {
-  // Serialized ProvisioningRequest or ProvisioningResponse. Required.
-  optional bytes message = 1;
-  // HMAC-SHA256 signature of message. Required.
-  optional bytes signature = 2;
-}

libwvdrmengine/cdm/core/src/client_files.proto

@@ -0,0 +1,27 @@
+// ----------------------------------------------------------------------------
+// client_files.proto
+// ----------------------------------------------------------------------------
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Description:
+//   Format of various files stored at the device.
+//
+syntax = "proto2";
+
+package video_widevine_client.sdk;
+
+// need this if we are using libprotobuf-cpp-2.3.0-lite
+option optimize_for = LITE_RUNTIME;
+
+message DeviceCertificateFileFormat {
+  optional int32 version = 1;
+  optional bytes certificate = 2;
+  optional bytes wrapped_private_key = 3;
+}
+
+message LicenseFileFormat {
+  optional int32 version = 1;
+  optional bytes key_set_id = 2;
+  optional bytes license_request = 3;
+  optional bytes license = 4;
+}

libwvdrmengine/cdm/core/src/client_identification.proto

@@ -1,30 +0,0 @@
-// Copyright 2013 Google Inc. All Rights Reserved.
-// Author: tinskip@google.com (Thomas Inskip)
-//
-// Description:
-//   ClientIdentification message used by provisioning and license protocols.
-
-syntax = "proto2";
-
-package video_widevine_server.sdk;
-option java_outer_classname = "ClientIdentificationProtos";
-option optimize_for = LITE_RUNTIME;
-
-// ClientIdentification message used to authenticate the client device.
-message ClientIdentification {
-  enum TokenType {
-    KEYBOX = 0;
-  }
-
-  message NameValue {
-    optional string name = 1;
-    optional string value = 2;
-  }
-
-  // Type of factory-provisioned device root of trust. Optional.
-  optional TokenType type = 1 [default = KEYBOX];
-  // Factory-provisioned device root of trust. Required.
-  optional bytes token = 2;
-  // Optional client information name/value pairs.
-  repeated NameValue client_info = 3;
-}

libwvdrmengine/cdm/core/src/crypto_engine.cpp

@@ -6,6 +6,7 @@
 #include "crypto_engine.h"
 
 #include <iostream>
+#include <vector>
 
 #include "log.h"
 #include "OEMCryptoCENC.h"
@@ -24,11 +25,7 @@ Lock CryptoEngine::crypto_engine_lock_;
 
 // CryptoEngine methods
 
-CryptoEngine::CryptoEngine() : initialized_(false),
-                               properties_valid_(false),
-                               oem_crypto_use_secure_buffers_(false),
-                               oem_crypto_use_fifo_(false),
-                               oem_crypto_use_userspace_buffers_(false) {}
+CryptoEngine::CryptoEngine() : initialized_(false) {}
 
 CryptoEngine::~CryptoEngine() {
   if (initialized_) {
@@ -66,29 +63,6 @@ void CryptoEngine::DeleteInstance() {
 }
 
 bool CryptoEngine::Init() {
-  properties_valid_ = true;
-
-  if (!Properties::GetInstance()->GetProperty(
-      kPropertyKeyOemCryptoUseSecureBuffers,
-      oem_crypto_use_secure_buffers_)) {
-    LOGW("CryptoEngine::CryptoEngine: Unable to access property - oemcrypto use secure buffers");
-    properties_valid_ = false;
-  }
-
-  if (!Properties::GetInstance()->GetProperty(
-      kPropertyKeyOemCryptoUseFifo,
-      oem_crypto_use_fifo_)) {
-    LOGW("CryptoEngine::CryptoEngine: Unable to access property - oemcrypto use fifos");
-    properties_valid_ = false;
-  }
-
-  if (!Properties::GetInstance()->GetProperty(
-      kPropertyKeyOemCryptoUseUserSpaceBuffers,
-      oem_crypto_use_userspace_buffers_)) {
-    LOGW("CryptoEngine::CryptoEngine: Unable to access property - oemcrypto use userspace buffers");
-    properties_valid_ = false;
-  }
-
   LOGV("CryptoEngine::Init: Lock");
   AutoLock auto_lock(crypto_lock_);
   if (!initialized_) {
@@ -221,4 +195,19 @@ CryptoEngine::SecurityLevel CryptoEngine::GetSecurityLevel() {
   return kSecurityLevelUnknown;
 }
 
+std::string CryptoEngine::GetDeviceUniqueId() {
+  std::vector<uint8_t> id;
+  size_t idLength = 32;
+
+  id.resize(idLength);
+
+  OEMCryptoResult sts = OEMCrypto_GetDeviceID(&id[0], &idLength);
+
+  if (OEMCrypto_SUCCESS != sts) {
+    return std::string();
+  }
+
+  return std::string(reinterpret_cast<const char*>(&id[0]));
+}
+
 };  // namespace wvcdm

libwvdrmengine/cdm/core/src/crypto_session.cpp

@@ -11,6 +11,7 @@
 #include "log.h"
 // TODO(gmorgan,jtinker): decide if OEMCryptoCENC is needed here.
 #include "OEMCryptoCENC.h"
+#include "properties.h"
 #include "string_conversions.h"
 #include "wv_cdm_constants.h"
 
@@ -114,39 +115,18 @@ bool CryptoSession::PrepareRequest(const std::string& message,
     return false;
   }
 
-  uint8_t signature_buf[32];
-  size_t length = 32;
   OEMCryptoResult sts;
 
-  std::string mac_deriv_message;
-  std::string enc_deriv_message;
-  GenerateMacContext(message, &mac_deriv_message);
-  GenerateEncryptContext(message, &enc_deriv_message);
-
-  LOGV("GenerateDerivedKeys: id=%ld", (uint32_t) oec_session_id_);
-  sts = OEMCrypto_GenerateDerivedKeys(
-      oec_session_id_,
-      reinterpret_cast<const uint8_t*>(mac_deriv_message.data()),
-      mac_deriv_message.size(),
-      reinterpret_cast<const uint8_t*>(enc_deriv_message.data()),
-      enc_deriv_message.size());
-  if (OEMCrypto_SUCCESS != sts) {
-    return false;
+  if (!Properties::use_certificates_as_identification()) {
+    if (!GenerateDerivedKeys(message)) {
+      return false;
+    }
   }
 
-  LOGV("GenerateSignature: id=%ld", (uint32_t) oec_session_id_);
-  sts = OEMCrypto_GenerateSignature(
-      oec_session_id_,
-      reinterpret_cast<const uint8_t*>(message.data()),
-      message.size(),
-      signature_buf,
-      &length);
-  if (OEMCrypto_SUCCESS != sts) {
+  if (!GenerateSignature(message, signature)) {
     return false;
   }
 
-  signature->assign(reinterpret_cast<const char*>(signature_buf), length);
-
   return true;
 }
 
@@ -155,17 +135,15 @@ bool CryptoSession::PrepareRenewalRequest(const std::string& message,
   LOGV("CryptoSession::PrepareRenewalRequest: Lock");
   CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
   AutoLock auto_lock(crypto_engine->crypto_lock_);
-  uint8_t signature_buf[32];
-  size_t length = 32;
 
-  OEMCryptoResult sts = OEMCrypto_GenerateSignature(
-      oec_session_id_, reinterpret_cast<const uint8_t*>(message.data()),
-      message.size(), signature_buf, &length);
-  if (OEMCrypto_SUCCESS != sts) {
+  if (!signature) {
+    LOGE("CryptoSession::PrepareRenewalRequest : No output destination provided.");
     return false;
   }
 
-  signature->assign(reinterpret_cast<const char*>(signature_buf), length);
+  if (!GenerateSignature(message, signature)) {
+    return false;
+  }
 
   return true;
 }
@@ -255,6 +233,25 @@ bool CryptoSession::LoadKeys(const std::string& message,
       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_);
+
+  LOGV("LoadDeviceRSAKey: id=%ld", (uint32_t) oec_session_id_);
+  OEMCryptoResult sts = OEMCrypto_LoadDeviceRSAKey(
+      oec_session_id_,
+      reinterpret_cast<const uint8_t*>(wrapped_key.data()),
+      wrapped_key.size());
+
+  if (OEMCrypto_SUCCESS != sts) {
+    LOGD("LoadCertificatePrivateKey: OEMCrypto_LoadDeviceRSAKey error=%d", sts);
+    return false;
+  }
+
+  return true;
+}
+
 bool CryptoSession::RefreshKeys(const std::string& message,
                                 const std::string& signature,
                                 int num_keys,
@@ -310,6 +307,85 @@ bool CryptoSession::SelectKey(const std::string& key_id) {
   return true;
 }
 
+bool CryptoSession::GenerateDerivedKeys(const std::string& message) {
+  std::string mac_deriv_message;
+  std::string enc_deriv_message;
+  GenerateMacContext(message, &mac_deriv_message);
+  GenerateEncryptContext(message, &enc_deriv_message);
+
+  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()),
+      mac_deriv_message.size(),
+      reinterpret_cast<const uint8_t*>(enc_deriv_message.data()),
+      enc_deriv_message.size());
+
+  if (OEMCrypto_SUCCESS != sts) {
+    LOGD("GenerateDerivedKeys: OEMCrypto_GenerateDerivedKeys error=%d", sts);
+    return false;
+  }
+
+  return true;
+}
+
+bool CryptoSession::GenerateDerivedKeys(const std::string& message,
+                                        const std::string& session_key) {
+  std::string mac_deriv_message;
+  std::string enc_deriv_message;
+  GenerateMacContext(message, &mac_deriv_message);
+  GenerateEncryptContext(message, &enc_deriv_message);
+
+  LOGV("GenerateDerivedKeys: id=%ld", (uint32_t) oec_session_id_);
+  OEMCryptoResult sts = OEMCrypto_DeriveKeysFromSessionKey(
+      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(),
+      reinterpret_cast<const uint8_t*>(enc_deriv_message.data()),
+      enc_deriv_message.size());
+
+  if (OEMCrypto_SUCCESS != sts) {
+    LOGD("GenerateDerivedKeys: OEMCrypto_DeriveKeysFromSessionKey err=%d", sts);
+    return false;
+  }
+
+  return true;
+}
+
+bool CryptoSession::GenerateSignature(const std::string& message,
+                                      std::string* signature) {
+  LOGV("GenerateSignature: id=%ld", (uint32_t) oec_session_id_);
+  uint8_t signature_buf[32];
+  uint32_t length = 32;
+  OEMCryptoResult sts;
+  if (Properties::use_certificates_as_identification()) {
+    sts = OEMCrypto_GenerateRSASignature(
+        oec_session_id_,
+        reinterpret_cast<const uint8_t*>(message.data()),
+        message.size(),
+        signature_buf,
+        &length);
+  }
+  else {
+    sts = OEMCrypto_GenerateSignature(
+        oec_session_id_,
+        reinterpret_cast<const uint8_t*>(message.data()),
+        message.size(),
+        signature_buf,
+        &length);
+  }
+
+  if (OEMCrypto_SUCCESS != sts) {
+    LOGD("GenerateSignature: OEMCrypto_GenerateSignature err=%d", sts);
+    return false;
+  }
+
+  signature->assign(reinterpret_cast<const char*>(signature_buf), length);
+  return true;
+}
+
 CdmResponseType CryptoSession::Decrypt(bool is_encrypted,
                                        const uint8_t* encrypt_buffer,
                                        size_t encrypt_length,
@@ -370,10 +446,7 @@ bool CryptoSession::GenerateNonce(uint32_t* nonce) {
 bool CryptoSession::SetDestinationBufferType() {
   CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
 
-  if (!crypto_engine->properties_valid())
-    return false;
-
-  if (crypto_engine->oem_crypto_use_secure_buffers()) {
+  if (Properties::oem_crypto_use_secure_buffers()) {
     if (crypto_engine->GetSecurityLevel() == CryptoEngine::kSecurityLevelL1) {
       destination_buffer_type_ = OEMCrypto_BufferType_Secure;
     }
@@ -381,10 +454,10 @@ bool CryptoSession::SetDestinationBufferType() {
       destination_buffer_type_ = OEMCrypto_BufferType_Clear;
     }
   }
-  else if (crypto_engine->oem_crypto_use_fifo()) {
+  else if (Properties::oem_crypto_use_fifo()) {
     destination_buffer_type_ = OEMCrypto_BufferType_Direct;
   }
-  else if (crypto_engine->oem_crypto_use_userspace_buffers()) {
+  else if (Properties::oem_crypto_use_userspace_buffers()) {
     destination_buffer_type_ = OEMCrypto_BufferType_Clear;
   }
   else {
@@ -395,4 +468,47 @@ bool CryptoSession::SetDestinationBufferType() {
   return true;
 }
 
+bool CryptoSession::RewrapDeviceRSAKey(const std::string& message,
+                                       const uint32_t* nonce,
+                                       const uint8_t* enc_rsa_key,
+                                       size_t enc_rsa_key_length,
+                                       const uint8_t* enc_rsa_key_iv,
+                                       uint8_t* wrapped_rsa_key,
+                                       size_t* wrapped_rsa_key_length) {
+  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_));
+
+  // HMAC-SHA256 signature
+  uint8_t signature[kSignatureSize];
+  size_t signature_length = kSignatureSize;
+  OEMCryptoResult status = OEMCrypto_GenerateSignature(
+      oec_session_id_,
+      reinterpret_cast<const uint8_t*>(message.data()),
+      message.size(),
+      signature,
+      &signature_length);
+  if (OEMCrypto_SUCCESS != status) {
+    LOGE("CryptoSession::RewrapDeviceRSAKey: GenerateSiganture failed");
+    return false;
+  }
+
+  status = OEMCrypto_RewrapDeviceRSAKey(
+      oec_session_id_,
+      reinterpret_cast<const uint8_t*>(message.data()), message.length(),
+      signature, signature_length,
+      nonce,
+      enc_rsa_key, enc_rsa_key_length,
+      enc_rsa_key_iv,
+      wrapped_rsa_key,
+      wrapped_rsa_key_length);
+
+  if (OEMCrypto_SUCCESS != status) {
+    return false;
+  }
+  return true;
+}
+
 };  // namespace wvcdm

libwvdrmengine/cdm/core/src/device_certificate.proto

@@ -1,117 +0,0 @@
-// Copyright 2013 Google Inc. All Rights Reserved.
-// Author: tinskip@google.com (Thomas Inskip)
-//
-// Description:
-//   Device certificate and certificate status list format definitions.
-
-syntax = "proto2";
-
-package video_widevine_server.sdk;
-
-option optimize_for = LITE_RUNTIME;
-option java_outer_classname = "DeviceCertificateProtos";
-option java_package = "com.google.video.widevine.protos";
-
-// Certificate definition for user devices, intermediate, and root certificates.
-message DeviceCertificate {
-  enum CertificateType {
-    ROOT = 0;
-    INTERMEDIATE = 1;
-    USER_DEVICE = 2;
-  }
-
-  // Type of certificate. Required.
-  optional CertificateType type = 1;
-  // 128-bit globally unique serial number of certificate.
-  // Value is 0 for root certificate. Required.
-  optional bytes serial_number = 2;
-  // POSIX time, in seconds, when the certificate was created. Required.
-  optional uint32 creation_time_seconds = 3;
-  // Device public key. PKCS#1 ASN.1 DER-encoded. Required.
-  optional bytes public_key = 4;
-  // Widevine system ID for the device. Required for intermediate and
-  // user device certificates.
-  optional uint32 system_id = 5;
-  // True if the certificate corresponds to a test (non production) device.
-  // Optional.
-  optional bool test_device = 6 [default = false];
-}
-
-// DeviceCertificate signed with intermediate or root certificate private key.
-message SignedDeviceCertificate {
-  // Serialized DeviceCertificate. Required.
-  optional bytes device_certificate = 1;
-  // Signature of device_certificate. Signed with root or intermediate
-  // certificate private key using RSASSA-PSS. Required.
-  optional bytes signature = 2;
-  // Intermediate signing certificate. Present only for user device
-  // certificates. All others signed with root certificate private key.
-  optional SignedDeviceCertificate signer = 3;
-}
-
-// Contains device model information for a provisioned device.
-message ProvisionedDeviceInfo {
-  enum WvSecurityLevel {
-    // Defined in Widevine Security Integration Guide for DASH on Android:
-    // https://docs.google.com/a/google.com/document/d/1Zum-fcJeoIw6KG1kDP_KepIE5h9gAZg0PaMtemBvk9c/edit#heading=h.1t3h5sf
-    LEVEL_UNSPECIFIED = 0;
-    LEVEL_1 = 1;
-    LEVEL_2 = 2;
-    LEVEL_3 = 3;
-  }
-
-  // Widevine system ID for the device. Mandatory.
-  optional uint32 system_id = 1;
-  // Name of system-on-a-chip. Optional.
-  optional string soc = 2;
-  // Name of manufacturer. Optional.
-  optional string manufacturer = 3;
-  // Manufacturer's model name. Matches "brand" in device metadata. Optional.
-  optional string model = 4;
-  // Type of device (Phone, Tablet, TV, etc).
-  optional string device_type = 5;
-  // Device model year. Optional.
-  optional uint32 model_year = 6;
-  // Widevine-defined security level. Optional.
-  optional WvSecurityLevel security_level = 7 [default = LEVEL_UNSPECIFIED];
-  // True if the certificate corresponds to a test (non production) device.
-  // Optional.
-  optional bool test_device = 8 [default = false];
-}
-
-// Contains the status of the root or an intermediate DeviceCertificate.
-message DeviceCertificateStatus {
-  enum CertificateStatus {
-    VALID = 0;
-    REVOKED = 1;
-  };
-
-  // Serial number of the DeviceCertificate to which this message refers.
-  // Required.
-  optional bytes serial_number = 1;
-  // Status of the certificate. Optional.
-  optional CertificateStatus status = 2 [default = VALID];
-  // Current version of a valid certificate. Present only if status = VALID.
-  optional uint32 current_certificate_version = 3;
-  // Device model information about the device to which the certificate
-  // corresponds. Required.
-  optional ProvisionedDeviceInfo device_info = 4;
-}
-
-// List of DeviceCertificateStatus. Used to propagate certificate revocation and
-// update list.
-message DeviceCertificateStatusList {
-  // POSIX time, in seconds, when the list was created. Required.
-  optional uint32 creation_time_seconds = 1;
-  // DeviceCertificateStatus for each certifificate.
-  repeated DeviceCertificateStatus certificate_status = 2;
-}
-
-// Signed CertificateStatusList
-message SignedCertificateStatusList {
-  // Serialized CertificateStatusList. Required.
-  optional bytes certificate_status_list = 1;
-  // Signature of certificate_status_list. Signed with root certificate private
-  // key using RSASSA-PSS. Required.
-  optional bytes signature = 2;
-}

libwvdrmengine/cdm/core/src/license.cpp

@@ -2,26 +2,62 @@
 
 #include "license.h"
 
+#include <vector>
+
 #include "crypto_session.h"
 #include "log.h"
 #include "policy_engine.h"
+#include "properties.h"
 #include "string_conversions.h"
 #include "wv_cdm_constants.h"
 
 namespace wvcdm {
 
 // Protobuf generated classes.
+using video_widevine_server::sdk::ClientIdentification;
+using video_widevine_server::sdk::ClientIdentification_NameValue;
 using video_widevine_server::sdk::LicenseRequest;
-using video_widevine_server::sdk::LicenseRequest_ClientIdentification;
-using video_widevine_server::sdk::LicenseRequest_ClientIdentification_NameValue;
 using video_widevine_server::sdk::LicenseRequest_ContentIdentification;
 using video_widevine_server::sdk::LicenseRequest_ContentIdentification_CENC;
 using video_widevine_server::sdk::License;
 using video_widevine_server::sdk::License_KeyContainer;
+using video_widevine_server::sdk::LicenseError;
 using video_widevine_server::sdk::SignedMessage;
 using video_widevine_server::sdk::STREAMING;
 using video_widevine_server::sdk::LicenseRequest_ContentIdentification_ExistingLicense;
 
+static std::vector<CryptoKey> ExtractContentKeys(const License& license) {
+  std::vector<CryptoKey> key_array;
+
+  // Extract content key(s)
+  for (int i = 0; i < license.key_size(); ++i) {
+    // TODO(kqyang): Key ID size is not fixed in spec, but conventionally we
+    // always use 16 bytes key id. We'll need to update oemcrypto to support
+    // variable size key id.
+    if (license.key(i).id().size() == KEY_ID_SIZE &&
+        license.key(i).key().size() == KEY_SIZE + KEY_PAD_SIZE &&
+        license.key(i).type() == License_KeyContainer::CONTENT) {
+
+      CryptoKey key;
+      key.set_key_id(license.key(i).id());
+      // Strip off PKCS#5 padding
+      key.set_key_data(
+          license.key(i).key().substr(0, KEY_SIZE));
+      key.set_key_data_iv(license.key(i).iv());
+      if (license.key(i).has_key_control()) {
+        key.set_key_control(
+            license.key(i).key_control().key_control_block());
+        key.set_key_control_iv(
+            license.key(i).key_control().iv());
+      }
+
+      key_array.push_back(key);
+    }
+  }
+
+  return key_array;
+}
+
 CdmLicense::CdmLicense(): session_(NULL) {}
 
 CdmLicense::~CdmLicense() {}
@@ -40,6 +76,8 @@ bool CdmLicense::Init(const std::string& token,
 }
 
 bool CdmLicense::PrepareKeyRequest(const CdmInitData& init_data,
+                                   const CdmLicenseType license_type,
+                                   CdmAppParameterMap& app_parameters,
                                    CdmKeyMessage* signed_request) {
   if (!session_ ||
       token_.empty()) {
@@ -59,12 +97,22 @@ bool CdmLicense::PrepareKeyRequest(const CdmInitData& init_data,
   session_->GenerateRequestId(request_id);
 
   LicenseRequest license_request;
-  LicenseRequest_ClientIdentification* client_id =
-      license_request.mutable_client_id();
+  ClientIdentification* client_id = license_request.mutable_client_id();
 
-  client_id->set_type(LicenseRequest_ClientIdentification::KEYBOX);
+  if (Properties::use_certificates_as_identification())
+    client_id->set_type(ClientIdentification::DEVICE_CERTIFICATE);
+  else
+    client_id->set_type(ClientIdentification::KEYBOX);
   client_id->set_token(token_);
 
+  ClientIdentification_NameValue client_info;
+  CdmAppParameterMap::const_iterator iter;
+  for (iter = app_parameters.begin(); iter != app_parameters.end(); iter++) {
+    ClientIdentification_NameValue* client_info = client_id->add_client_info();
+    client_info->set_name(iter->first);
+    client_info->set_value(iter->second);
+  }
+
   // Content Identification may be a cenc_id, a webm_id or a license_id
   LicenseRequest_ContentIdentification* content_id =
       license_request.mutable_content_id();
@@ -115,6 +163,9 @@ bool CdmLicense::PrepareKeyRequest(const CdmInitData& init_data,
 
   signed_message.SerializeToString(signed_request);
 
+  if (Properties::use_certificates_as_identification())
+    key_request_ = *signed_request;
+
   return true;
 }
 
@@ -166,25 +217,39 @@ bool CdmLicense::PrepareKeyRenewalRequest(CdmKeyMessage* signed_request) {
   return true;
 }
 
-bool CdmLicense::HandleKeyResponse(const CdmKeyResponse& license_response) {
+CdmResponseType CdmLicense::HandleKeyResponse(
+    const CdmKeyResponse& license_response) {
   if (!session_) {
-    return false;
+    return KEY_ERROR;
   }
   if (license_response.empty()) {
     LOGE("CdmLicense::HandleKeyResponse : Empty license response.");
-    return false;
+    return KEY_ERROR;
   }
 
   SignedMessage signed_response;
   if (!signed_response.ParseFromString(license_response))
-    return false;
+    return KEY_ERROR;
+
+  if (signed_response.type() == SignedMessage::ERROR) {
+    return HandleKeyErrorResponse(signed_response);
+  }
 
   if (!signed_response.has_signature())
-    return false;
+    return KEY_ERROR;
 
   License license;
   if (!license.ParseFromString(signed_response.msg()))
-    return false;
+    return KEY_ERROR;
+
+  if (Properties::use_certificates_as_identification()) {
+    if (!signed_response.has_session_key())
+      return KEY_ERROR;
+
+    if (!session_->GenerateDerivedKeys(key_request_,
+                                       signed_response.session_key()))
+      return KEY_ERROR;
+  }
 
   // Extract mac key
   std::string mac_key_iv;
@@ -201,98 +266,105 @@ bool CdmLicense::HandleKeyResponse(const CdmKeyResponse& license_response) {
     }
 
     if (mac_key_iv.size() != KEY_IV_SIZE ||
-        mac_key.size() != MAC_KEY_SIZE)
-    {
-      return false;
+        mac_key.size() != MAC_KEY_SIZE) {
+      return KEY_ERROR;
     }
 
     // License Id should not be empty for renewable license
-    if (!license.has_id()) return false;
+    if (!license.has_id()) return KEY_ERROR;
 
     license_id_.CopyFrom(license.id());
   }
 
-  CryptoKey* key_array = new CryptoKey[license.key_size()];
-  if (key_array == NULL) return false;
-
-  // Extract content key(s)
-  int num_keys = 0;
-  for (int i = 0; i < license.key_size(); ++i) {
-    // TODO(kqyang): Key ID size is not fixed in spec, but conventionally we
-    // always use 16 bytes key id. We'll need to update oemcrypto to support
-    // variable size key id.
-    if (license.key(i).id().size() == KEY_ID_SIZE &&
-        license.key(i).key().size() == KEY_SIZE + KEY_PAD_SIZE &&
-        license.key(i).type() == License_KeyContainer::CONTENT) {
-
-      key_array[num_keys].set_key_id(license.key(i).id());
-
-      // Strip off PKCS#5 padding
-      key_array[num_keys].set_key_data(
-          license.key(i).key().substr(0, KEY_SIZE));
-      key_array[num_keys].set_key_data_iv(license.key(i).iv());
-      if (license.key(i).has_key_control()) {
-        key_array[num_keys].set_key_control(
-            license.key(i).key_control().struct_());
-        key_array[num_keys].set_key_control_iv(
-            license.key(i).key_control().iv());
-      }
-      num_keys++;
-    }
+  std::vector<CryptoKey> key_array = ExtractContentKeys(license);
+  if (!key_array.size()) {
+    LOGE("CdmLicense::HandleKeyResponse : No content keys.");
+    return KEY_ERROR;
   }
 
-  if (num_keys == 0) return false;
-
   policy_engine_->SetLicense(license);
 
-  bool status = session_->LoadKeys(signed_response.msg(),
-                                   signed_response.signature(),
-                                   mac_key_iv,
-                                   mac_key,
-                                   num_keys,
-                                   key_array);
-  delete[] key_array;
-  return status;
+  if (session_->LoadKeys(signed_response.msg(),
+                         signed_response.signature(),
+                         mac_key_iv,
+                         mac_key,
+                         key_array.size(),
+                         &key_array[0])) {
+    return KEY_ADDED;
+  }
+  else {
+    return KEY_ERROR;
+  }
 }
 
-bool CdmLicense::HandleKeyRenewalResponse(
+CdmResponseType CdmLicense::HandleKeyRenewalResponse(
     const CdmKeyResponse& license_response) {
   if (!session_) {
-    return false;
+    return KEY_ERROR;
   }
   if (license_response.empty()) {
     LOGE("CdmLicense::HandleKeyRenewalResponse : Empty license response.");
-    return false;
+    return KEY_ERROR;
   }
 
   SignedMessage signed_response;
   if (!signed_response.ParseFromString(license_response))
-    return false;
+    return KEY_ERROR;
+
+  if (signed_response.type() == SignedMessage::ERROR) {
+    return HandleKeyErrorResponse(signed_response);
+  }
 
   if (!signed_response.has_signature())
-    return false;
-
-  // TODO(jfore): refresh the keys in oemcrypto
+    return KEY_ERROR;
 
   License license;
   if (!license.ParseFromString(signed_response.msg()))
-    return false;
+    return KEY_ERROR;
 
-  if (!license.has_id()) return false;
+  if (!license.has_id()) return KEY_ERROR;
 
   if (license.id().version() > license_id_.version()) {
-    //This is the normal case.
+    // This is the normal case.
     license_id_.CopyFrom(license.id());
 
     policy_engine_->UpdateLicense(license);
-  } else {
-    // This isn't supposed to happen.
-    // TODO(jfore): Handle wrap? We can miss responses and that should be
-    // considered normal until retries are exhausted.
-    // policy_.set_can_play(false);
+
+    std::vector<CryptoKey> key_array = ExtractContentKeys(license);
+
+    if (session_->RefreshKeys(signed_response.msg(),
+                              signed_response.signature(),
+                              key_array.size(),
+                              &key_array[0])) {
+      return KEY_ADDED;
+    }
+    else {
+      return KEY_ERROR;
+    }
   }
 
-  return true;
+  // This isn't supposed to happen.
+  // TODO(jfore): Handle wrap? We can miss responses and that should be
+  // considered normal until retries are exhausted.
+  return KEY_ERROR;
+}
+
+CdmResponseType CdmLicense::HandleKeyErrorResponse(
+    const SignedMessage& signed_message) {
+
+  LicenseError license_error;
+  if (!license_error.ParseFromString(signed_message.msg()))
+    return KEY_ERROR;
+
+  switch (license_error.error_code()) {
+    case LicenseError::INVALID_CREDENTIALS:
+      return NEED_PROVISIONING;
+    case LicenseError::REVOKED_CREDENTIALS:
+      return DEVICE_REVOKED;
+    case LicenseError::SERVICE_UNAVAILABLE:
+    default:
+      return KEY_ERROR;
+  }
 }
 
 }  // namespace wvcdm

libwvdrmengine/cdm/core/src/license_protocol.proto

@@ -1,7 +1,18 @@
+// ----------------------------------------------------------------------------
+// license_protocol.proto
+// ----------------------------------------------------------------------------
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Description:
+//   Merges certificate_provisioning.proto and client_identification.proto
+//   inline to avoid having to hardcode the import path. This is a temporary
+//   workaround for not getting proto_path to work in Android build envionment.
+//
 syntax = "proto2";
 
 package video_widevine_server.sdk;
 
+// need this if we are using libprotobuf-cpp-2.3.0-lite
 option optimize_for = LITE_RUNTIME;
 
 enum LicenseType {
@@ -74,6 +85,8 @@ message License {
       // Exactly one key of this type must appear.
       SIGNING = 1;
       CONTENT = 2;
+      KEY_CONTROL = 3;
+      OPERATOR_SESSION = 4;
     }
 
     // The SecurityLevel enumeration allows the server to communicate the level
@@ -104,7 +117,7 @@ message License {
       // https://docs.google.com/a/google.com/document/d/17eDxzzGpPc2qSm7zW68_5ensuxbHErYCvD3IxSKETRo/edit#
       // If present, the key control must be communicated to the secure
       // environment prior to any usage.
-      optional bytes struct = 1;
+      optional bytes key_control_block = 1;
       optional bytes iv = 2;
     }
 
@@ -143,22 +156,12 @@ message License {
   optional int64 license_start_time = 4;
 }
 
+enum ProtocolVersion {
+  VERSION_2_0 = 20;
+  VERSION_2_1 = 21;
+}
+
 message LicenseRequest {
-  message ClientIdentification {
-    enum TokenType {
-      KEYBOX = 0;
-    }
-
-    message NameValue {
-      optional string name = 1;
-      optional string value = 2;
-    }
-
-    optional TokenType type = 1;
-    optional bytes token = 2;
-    repeated NameValue client_info = 3;
-  }
-
   message ContentIdentification {
     message CENC  {
       repeated bytes pssh = 1;
@@ -189,30 +192,46 @@ message LicenseRequest {
     RELEASE = 3;
   }
 
+  // The client_id provides information authenticating the calling device.  It
+  // contains the Widevine keybox token that was installed on the device at the
+  // factory.  This field is required for a valid license request.
   optional ClientIdentification client_id = 1;
   optional ContentIdentification content_id = 2;
   optional RequestType type = 3;
   optional int64 request_time = 4;
   optional bytes key_control_nonce = 5;
+  optional ProtocolVersion protocol_version = 6 [default = VERSION_2_0];
+}
+
+
+message LicenseError {
+  enum Error {
+    INVALID_CREDENTIALS = 1;
+    REVOKED_CREDENTIALS = 2;
+    SERVICE_UNAVAILABLE = 3;
+  }
+  optional Error error_code = 1;
 }
 
 message SignedMessage {
   enum MessageType {
     LICENSE_REQUEST = 1;
     LICENSE = 2;
+    ERROR = 3;
   }
 
   optional MessageType type = 1;
   optional bytes msg = 2;
   optional bytes signature = 3;
+  optional bytes session_key = 4;
 }
 
 // This message is used to pass optional data on initial license issuance.
 message SessionInit {
-  optional string session_id = 1;
-  optional string purchase_id = 2;
-  optional string master_signing_key = 3;
-  optional string signing_key = 4;
+  optional bytes session_id = 1;
+  optional bytes purchase_id = 2;
+  optional bytes master_signing_key = 3;
+  optional bytes signing_key = 4;
   optional int64 license_start_time = 5;
 }
 
@@ -222,3 +241,74 @@ message SessionState {
   optional bytes signing_key = 2;
   optional uint32 keybox_system_id = 3;
 }
+
+// ----------------------------------------------------------------------------
+// certificate_provisioning.proto
+// ----------------------------------------------------------------------------
+// Copyright 2013 Google Inc. All Rights Reserved.
+// Author: tinskip@google.com (Thomas Inskip)
+//
+// Description:
+//   Public protocol buffer definitions for Widevine Device Certificate
+//   Provisioning protocol.
+
+// Provisioning request sent by client devices to provisioning service.
+message ProvisioningRequest {
+  // Device root of trust and other client identification. Required.
+  optional ClientIdentification client_id = 1;
+  // Nonce value used to prevent replay attacks. Required.
+  optional bytes nonce = 2;
+}
+
+// Provisioning response sent by the provisioning server to client devices.
+message ProvisioningResponse {
+  // AES-128 encrypted device private RSA key. PKCS#1 ASN.1 DER-encoded.
+  // Required.
+  optional bytes device_rsa_key = 1;
+  // Initialization vector used to encrypt device_rsa_key. Required.
+  optional bytes device_rsa_key_iv = 2;
+  // Serialized DeviceCertificate. Required.
+  optional bytes device_certificate = 3;
+  // Nonce value matching nonce in ProvisioningRequest. Required.
+  optional bytes nonce = 4;
+}
+
+// Serialized ProvisioningRequest or ProvisioningResponse signed with
+// The message authentication key.
+message SignedProvisioningMessage {
+  // Serialized ProvisioningRequest or ProvisioningResponse. Required.
+  optional bytes message = 1;
+  // HMAC-SHA256 signature of message. Required.
+  optional bytes signature = 2;
+}
+
+// ----------------------------------------------------------------------------
+// client_identification.proto
+// ----------------------------------------------------------------------------
+// Copyright 2013 Google Inc. All Rights Reserved.
+// Author: tinskip@google.com (Thomas Inskip)
+//
+// Description:
+//   ClientIdentification message used by provisioning and license protocols.
+
+option java_outer_classname = "ClientIdentificationProtos";
+
+// ClientIdentification message used to authenticate the client device.
+message ClientIdentification {
+  enum TokenType {
+    KEYBOX = 0;
+    DEVICE_CERTIFICATE = 1;
+  }
+
+  message NameValue {
+    optional string name = 1;
+    optional string value = 2;
+  }
+
+  // Type of factory-provisioned device root of trust. Optional.
+  optional TokenType type = 1 [default = KEYBOX];
+  // Factory-provisioned device root of trust. Required.
+  optional bytes token = 2;
+  // Optional client information name/value pairs.
+  repeated NameValue client_info = 3;
+}

libwvdrmengine/cdm/core/src/policy_engine.cpp

@@ -10,9 +10,9 @@
 
 #include "log.h"
 #include "properties.h"
-#include "properties_configuration.h"
 #include "string_conversions.h"
 #include "clock.h"
+#include "wv_cdm_constants.h"
 
 namespace wvcdm {
 
@@ -38,14 +38,6 @@ void PolicyEngine::Init(Clock* clock) {
   next_renewal_time_ = 0;
   policy_max_duration_seconds_ = 0;
   clock_ = clock;
-  properties_valid_ = true;
-
-  if (!Properties::GetInstance()->GetProperty(
-      kPropertyKeyBeginLicenseUsageWhenReceived,
-      begin_license_usage_when_received_)) {
-    LOGW("PolicyEngine::PolicyEngine: Unable to access property - begin license usage");
-    properties_valid_ = false;
-  }
 }
 
 void PolicyEngine::OnTimerEvent(bool& event_occured, CdmEventType& event) {
@@ -114,8 +106,7 @@ void PolicyEngine::SetLicense(
 
 void PolicyEngine::UpdateLicense(
     const video_widevine_server::sdk::License& license) {
-  if (!license.has_policy() || kLicenseStateExpired == license_state_ ||
-      !properties_valid_)
+  if (!license.has_policy() || kLicenseStateExpired == license_state_)
     return;
 
   policy_.MergeFrom(license.policy());
@@ -180,11 +171,11 @@ void PolicyEngine::UpdateLicense(
         policy_max_duration_seconds_ = policy_.license_duration_seconds();
       }
 
-      if (begin_license_usage_when_received_)
+      if (Properties::begin_license_usage_when_received())
         playback_start_time_ = current_time;
 
       // Update state
-      if (begin_license_usage_when_received_) {
+      if (Properties::begin_license_usage_when_received()) {
         if (policy_.renew_with_usage()) {
           license_state_ = kLicenseStateNeedRenewal;
         }
@@ -209,7 +200,7 @@ void PolicyEngine::UpdateLicense(
 
 void PolicyEngine::BeginDecryption() {
   if ((playback_start_time_ == 0) &&
-      (!begin_license_usage_when_received_)) {
+      (!Properties::begin_license_usage_when_received())) {
     switch (license_state_) {
       case kLicenseStateInitialPendingUsage:
       case kLicenseStateNeedRenewal:

libwvdrmengine/cdm/core/src/properties.cpp

@@ -6,39 +6,21 @@
 
 namespace wvcdm {
 
-Properties* Properties::instance_ = NULL;
-Lock Properties::properties_lock_;
+bool Properties::begin_license_usage_when_received_;
+bool Properties::require_explicit_renew_request_;
+bool Properties::oem_crypto_use_secure_buffers_;
+bool Properties::oem_crypto_use_fifo_;
+bool Properties::oem_crypto_use_userspace_buffers_;
+bool Properties::use_certificates_as_identification_;
 
-Properties::Properties() {
-  // Read in static properties/features
-  uint32_t size = sizeof(kCdmBooleanProperties)/sizeof(CdmBooleanProperties);
-  for (uint32_t i = 0; i < size; i++) {
-    boolean_properties_[kCdmBooleanProperties[i].name] =
-        kCdmBooleanProperties[i].value;
-  }
-}
-
-Properties* Properties::GetInstance() {
-  AutoLock auto_lock(properties_lock_);
-  if (instance_ == NULL) {
-    instance_ = new Properties();
-  }
-  return instance_;
-}
-
-bool Properties::GetProperty(std::string& key, bool& value) {
-  CdmBooleanPropertiesMap::iterator itr = boolean_properties_.find(key);
-
-  if (itr == boolean_properties_.end()) {
-    return false;
-  }
-
-  value = itr->second;
-  return true;
-}
-
-void Properties::SetProperty(std::string& key, bool value) {
-  boolean_properties_[key] = value;
+void Properties::Init() {
+  begin_license_usage_when_received_ = kPropertyBeginLicenseUsageWhenReceived;
+  require_explicit_renew_request_ = kPropertyRequireExplicitRenewRequest;
+  oem_crypto_use_secure_buffers_ = kPropertyOemCryptoUseSecureBuffers;
+  oem_crypto_use_fifo_ = kPropertyOemCryptoUseFifo;
+  oem_crypto_use_userspace_buffers_ = kPropertyOemCryptoUseUserSpaceBuffers;
+  use_certificates_as_identification_ =
+      kPropertyUseCertificatesAsIdentification;
 }
 
 }  // namespace wvcdm

libwvdrmengine/cdm/core/test/cdm_engine_test.cpp

@@ -10,6 +10,7 @@
 #include "log.h"
 #include "string_conversions.h"
 #include "url_request.h"
+#include "wv_cdm_types.h"
 
 namespace {
 // Default license server, can be configured using --server command line option
@@ -21,6 +22,55 @@ std::string g_license_server;
 std::string g_port;
 wvcdm::KeyId g_wrong_key_id;
 int g_use_full_path = 0;  // cannot use boolean in getopt_long
+
+static wvcdm::CdmProvisioningResponse kJsonResponse =
+  "{\"signedResponse\": {"
+  "\"message\": \"CrAJYTyIdLPiA2jBzMskbE_gFQj69wv23VlJ2e3MBKtK4nJwKyNYGyyluqKo"
+  "TP751tvoADf86iLrf73mEzF58eSlaOjCpJRf2R3dojbNeSTy3JICmCc8vKtMjZRX9QWTvJbq_cg"
+  "yMB8FQC8enuYhOaw1yJDYyCFHgik34NrUVUfmvaKKdSKQimqAZmjXi6P0znAn-XdPtz2xJVRxZp"
+  "NH3QCD1bGcH_O1ercBW2JwF9KNalKFsxQrBhIwvyx-q-Ah4vf4r3M2HzY6JTHvcYGGc7dJNA3Xe"
+  "WfCrYIvg0SGCP_z7Y2wICIA36VMwR3gnwNZlKkx6WGCCgsaU6IbLm4HpRBZfajuiOlasoYN4z1R"
+  "lQ14Z32fdaFy8xOqLl-ZukxjWa7wv9zOSveH6JcHap1FS3R-RZ7E5WhfjxSTS0nWWZgmAjS2PkP"
+  "9g4GPNsnpsrVymI39j6R6jPoc3__2EGN6qAvmp4pFKR7lQyslgNn2vYLuE0Ps5mIXVkxNiZOO3T"
+  "jxgZyHaHOm1KmAZKI0EfddMATJCTt-UeLG3haqS_pYaBWcQ_xzWhoEHWU7_6ZaWrWemV8CVCg6s"
+  "OB1SRI5MrkRBBSV0r8UKddLJGthZVjuTG75KK72KE9yhe86mCadvfVYe5keJ5GOC-t1EiFzBo4c"
+  "4oqwkOCkkmYX_BEuZ3pOWztFp1_Br2Tl_fziw4O2vNIPCXB9yEewV6PkYPziTue3x4vRqD_mYjm"
+  "1ia8fxISQnEC0vrqvrFFs9fLAHPlsvaRFnhv_XKpRwFoBdfqWTakb3k6uRz0Oh2SJ8euzFIyQNB"
+  "efesMWk45DSrQjnlwlKXwZSiDKjAss0W2WwIb9F_x5LdB1Aa-CBudLVdxf62ggYaNZ57qx3YeHA"
+  "jkqMGIF7Fq09D4OxM0jRsnrmXbJWKleUpJi7nHJgQGZk2ifN95gjuTNcRaGfYXMOsDoWdkrNAq0"
+  "LScsPB06xEUR0DcO9vWx0zAEK7gsxxHziR7ZaYiIIkPysRR92r2NoLFPOUXf8j8ait-51jZmPKn"
+  "bD6adieLy6ujSl907QsUgyGvokLs1OCsYHZr-X6vnyMjdk4G3QfmWwRepD_CMyXGvtLbTNCto7E"
+  "L_M2yPZveAwYWwNlBtWK21gwIU2dgY298z7_S6jaQBc29f25sREjvN793ttYsPaeyom08qHYDnb"
+  "jae3XX-2qqde6AGXlv__jO8WDZ5od6DWu2ThqV10ijVGFfGniRsSruzq0iq8zuAqTOGhmA9Dw7b"
+  "rNlI95P4LpJA5pbjmNdnX7CQa2oHUuojmwlXRYuOA28PNEf-sc7ZPmMyFzedJi4EpkqzeQspEdH"
+  "yNMf23iEjK6GOff7dgAaxg9vYHyprhkEml4BdmFVYwCYQy8o6KRcA0NgJb8c3tg4d3aRXWp6L-F"
+  "sVhwqvq6FLOunSTNRIqhr2mOjRpU5w4mx-9GJRtk4XEcKT9YgUHGOUjGwfhQ5gBQDyZZVTddIUb"
+  "MOThsSg7zr38oUCfgXeZaai3X2foKo1Bt94Q_q18dw5xNAN5e7rSwfilltHL23zbZduuhWkvp8S"
+  "dag_NbO2C4IRMkzbjQBmiO9ixjXRhdqHlRRWcfR0wbQvEhD47egRVfnhKZ0W9G2-FGhyGuwJCq4"
+  "CCAISEAfZ_94TqpXBImeAUzYhNr0Y48SbiwUijgIwggEKAoIBAQDRigR9nFm4mfBUh1Y3SGyOcF"
+  "E-yK2NtfDiQe9l70KtkOeH4sB6MMB8g1QKPbUE8SBjPvXVJC_2DAWKjALzk4Aw-K-VmYe_Ag9CH"
+  "JiS-XcfUYEGgK4jVMxadEq3LufEEREKUZnzjgQlR39dzgjFqIrC1bwfy3_99RsjPt6QpWPg36PI"
+  "O4UKlmwBDTFzSOJB-4IV8Opy5Zv84BqPuyO9P5e3bXj_shRfy_XAGG2HGP_PpOCZWEfxuce0Iyu"
+  "vpTPLQpTOgNw-VvUBGCWMZFoERopmqp_pQwWZ2a-EwlT_vvYY4SkuNjflBskR70xz4QzEo9665g"
+  "k6I-HbHrTv29KEiAllAgMBAAEomSASgAIkKz1CSdFJVKcpO56jW0vsjKp92_cdqXBSEY3nuhzug"
+  "_LFluMJx_IqATUcCOY-w6w0yKn2ezfZGE0MDIaCngEgQFI_DRoaSOBNNeirF59uYM0sK3P2eGS9"
+  "G6F0l-OUXJdSO0b_LO8AbAK9LA3j7UHaajupJI1mdc4VtJfPRTsml2vIeKhDWXWaSvmeHgfF_tp"
+  "-OV7oPuk6Ub26xpCp2He2rEAblCYEl25Zlz97K4DhyTOV5_xuSdSt-KbTLY9cWM5i9ncND1RzCc"
+  "4qOixKarnMM5DdpZhs3B5xVj3yBAM1mVxPD2sZnqHSEN2EK7BMlHEnnyxhX0MGE36TQZR7P-I-G"
+  "rUFCq8CCAESEDAxMjM0NTY3ODlBQkNERUYYspIEIo4CMIIBCgKCAQEApwA2YGXcvVRaKkC04RWU"
+  "WBFPlFjd3qcfPCzgiAkpYVdnXlZ-7iePWTSaKqqdtE76p2rUyXpTwU6f4zT3PbfJEEdPKNo_zjF"
+  "7_QYQ6_e-kvmv-z5o2u4aZEzzKfJznjnY9m_YsoCCcY61pPLCPs0KyrYEzZoTi1RzVCVUjL6Yem"
+  "et2rNOs_qCqEpnmFZXVHHNEn_towHAaoskA5aIvpdmKrxTyYMGUVqIZRMY5Drta_FhW0zIHvTCr"
+  "gheLV_4En-i_LshGDDa_kD7AcouNw7O3XaHgkYLOnePwHIHLH-dHoZb7Scp3wOXYu9E01s925xe"
+  "G3s5tAttBGu7uyxfz7N6BQIDAQABKNKF2MwEEoADe9NAqNAxHpU13bMgz8LPySZJU8hY1RLwcfT"
+  "UM47Xb3m-F-s2cfI7w08668f79kD45uRRzkVc8GbRIlVyzVC0WgIvtxEkYRKfgF_J7snUe2J2NN"
+  "1FrkK7H3oYhcfPyYZH_SPZJr5HPoBFQTmS5A4l24U1dzQ6Z7_q-oS6uT0DiagTnzWhEg6AEnIkT"
+  "sJtK3cZuKGYq3NDefZ7nslPuLXxdXl6SAEOtrk-RvCY6EBqYOuPUXgxXOEPbyM289R6aHQyPPYw"
+  "qs9Pt9_E4BuMqCsbf5H5mLms9FA-wRx6mK2IaOboT4tf9_YObp3hVeL3WyxzXncETzJdE1GPGlO"
+  "t_x5S_MylgJKbiWQYSdmqs3fzYExunw3wvI4tPHT_O8A_xKjyTEAvE5cBuCkfjwT716qUOzFUzF"
+  "gZYLHnFiQLZekZUbUUlWY_CwU9Cv0UtxqQ6Oa835_Ug8_n1BwX6BPbmbcWe2Y19laSnDWg4JBNl"
+  "F2CyP9N75jPtW9rVfjUSqKEPOwaIgwzNDkyMjM3NDcAAAA=\","
+  "\"signature\": \"r-LpoZcbbr2KtoPaFnuWTVBh4Gup1k8vn0ClW2qm32A=\"}}";
 }  // namespace
 
 namespace wvcdm {
@@ -117,6 +167,15 @@ class WvCdmEngineTest : public testing::Test {
   std::string session_id_;
 };
 
+
+TEST_F(WvCdmEngineTest, ProvisioningTest) {
+  CdmProvisioningRequest prov_request;
+  std::string provisioning_server_url = "";
+
+  cdm_engine_.GetProvisioningRequest(&prov_request, &provisioning_server_url);
+  cdm_engine_.HandleProvisioningResponse(kJsonResponse);
+}
+
 TEST_F(WvCdmEngineTest, BaseMessageTest) {
   cdm_engine_.OpenSession(g_key_system, &session_id_);
   GenerateKeyRequest(g_key_system, g_key_id);

libwvdrmengine/cdm/core/test/license_unittest.cpp

@@ -78,20 +78,32 @@ TEST(LicenseTestSession, InitNullSession) {
 
 TEST_F(LicenseTest, PrepareKeyRequest) {
   std::string signed_request;
-  license_.PrepareKeyRequest(a2bs_hex(kInitData), &signed_request);
+  CdmAppParameterMap app_parameters;
+  license_.PrepareKeyRequest(a2bs_hex(kInitData),
+                             kLicenseTypeStreaming,
+                             app_parameters,
+                             &signed_request);
   EXPECT_EQ(signed_request, a2bs_hex(kSignedRequest));
 }
 
 TEST_F(LicenseTest, HandleKeyResponseValid) {
   std::string signed_request;
-  license_.PrepareKeyRequest(a2bs_hex(kInitData), &signed_request);
+  CdmAppParameterMap app_parameters;
+  license_.PrepareKeyRequest(a2bs_hex(kInitData),
+                             kLicenseTypeStreaming,
+                             app_parameters,
+                             &signed_request);
   EXPECT_EQ(signed_request, a2bs_hex(kSignedRequest));
   EXPECT_TRUE(license_.HandleKeyResponse(a2bs_hex(kValidResponse)));
 }
 
 TEST_F(LicenseTest, HandleKeyResponseInvalid) {
   std::string signed_request;
-  license_.PrepareKeyRequest(a2bs_hex(kInitData), &signed_request);
+  CdmAppParameterMap app_parameters;
+  license_.PrepareKeyRequest(a2bs_hex(kInitData),
+                             kLicenseTypeStreaming,
+                             app_parameters,
+                             &signed_request);
   EXPECT_EQ(signed_request, a2bs_hex(kSignedRequest));
   EXPECT_FALSE(license_.HandleKeyResponse(a2bs_hex(kInvalidResponse)));
 }

libwvdrmengine/cdm/core/test/url_request.cpp

@@ -49,7 +49,7 @@ void UrlRequest::AppendChunkToUpload(const std::string& data) {
 int UrlRequest::GetResponse(std::string& response) {
   response.clear();
 
-  const int kTimeoutInMs = 1000;
+  const int kTimeoutInMs = 1500;
   int bytes = 0;
   int total_bytes = 0;
   do {