Initial source release: v2.0.8-0-679

Change-Id: Idf6316a8faf4b4fdc54265aad12084e5aa60707a

core/include/buffer_reader.h

@@ -0,0 +1,68 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_BUFFER_READER_H_
+#define WVCDM_CORE_BUFFER_READER_H_
+
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+// Annotate a function indicating the caller must examine the return value.
+// Use like:
+//   int foo() WARN_UNUSED_RESULT;
+// To explicitly ignore a result, see |ignore_result()| in <base/basictypes.h>.
+#if defined(COMPILER_GCC)
+#define WARN_UNUSED_RESULT __attribute__((warn_unused_result))
+#else
+#define WARN_UNUSED_RESULT
+#endif
+
+class BufferReader {
+ public:
+  BufferReader(const uint8_t* buf, size_t size)
+    : buf_(buf), size_(size), pos_(0) {}
+
+  bool HasBytes(int count) { return (pos() + count <= size()); }
+
+  // Read a value from the stream, performing endian correction,
+  // and advance the stream pointer.
+  bool Read1(uint8_t* v)  WARN_UNUSED_RESULT;
+  bool Read2(uint16_t* v) WARN_UNUSED_RESULT;
+  bool Read2s(int16_t* v) WARN_UNUSED_RESULT;
+  bool Read4(uint32_t* v) WARN_UNUSED_RESULT;
+  bool Read4s(int32_t* v) WARN_UNUSED_RESULT;
+  bool Read8(uint64_t* v) WARN_UNUSED_RESULT;
+  bool Read8s(int64_t* v) WARN_UNUSED_RESULT;
+
+  bool ReadString(std::string* str, int count) WARN_UNUSED_RESULT;
+  bool ReadVec(std::vector<uint8_t>* t, int count) WARN_UNUSED_RESULT;
+
+  // These variants read a 4-byte integer of the corresponding signedness and
+  // store it in the 8-byte return type.
+  bool Read4Into8(uint64_t* v) WARN_UNUSED_RESULT;
+  bool Read4sInto8s(int64_t* v) WARN_UNUSED_RESULT;
+
+  // Advance the stream by this many bytes.
+  bool SkipBytes(int nbytes) WARN_UNUSED_RESULT;
+
+  const uint8_t* data() const { return buf_; }
+  size_t size() const { return size_; }
+  size_t pos() const { return pos_; }
+
+ protected:
+  const uint8_t* buf_;
+  size_t size_;
+  size_t pos_;
+
+  template<typename T> bool Read(T* t) WARN_UNUSED_RESULT;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(BufferReader);
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_BUFFER_READER_H_

core/include/cdm_client_property_set.h

@@ -0,0 +1,26 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_CDM_CLIENT_PROPERTY_SET_H_
+#define WVCDM_CORE_CDM_CLIENT_PROPERTY_SET_H_
+
+#include <string>
+#include <vector>
+#include <stdint.h>
+
+namespace wvcdm {
+
+class CdmClientPropertySet {
+ public:
+  virtual ~CdmClientPropertySet() {}
+
+  virtual std::string security_level() const = 0;
+  virtual bool use_privacy_mode() const = 0;
+  virtual std::vector<uint8_t> service_certificate() const = 0;
+  virtual bool is_session_sharing_enabled() const = 0;
+  virtual uint32_t session_sharing_id() const = 0;
+  virtual void set_session_sharing_id(uint32_t id) = 0;
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_CDM_CLIENT_PROPERTY_SET_H_

core/include/cdm_engine.h

@@ -0,0 +1,124 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_CDM_ENGINE_H_
+#define WVCDM_CORE_CDM_ENGINE_H_
+
+#include "certificate_provisioning.h"
+#include "oemcrypto_adapter.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+class CdmClientPropertySet;
+class CdmSession;
+class CryptoEngine;
+class WvCdmEventListener;
+
+typedef std::map<CdmSessionId, CdmSession*> CdmSessionMap;
+typedef std::map<CdmKeySetId, CdmSessionId> CdmReleaseKeySetMap;
+
+class CdmEngine {
+ public:
+  CdmEngine();
+  virtual ~CdmEngine();
+
+  // Session related methods
+  CdmResponseType OpenSession(const CdmKeySystem& key_system,
+                              const CdmClientPropertySet* property_set,
+                              CdmSessionId* session_id);
+  CdmResponseType CloseSession(const CdmSessionId& session_id);
+
+  CdmResponseType OpenKeySetSession(const CdmKeySetId& key_set_id);
+  CdmResponseType CloseKeySetSession(const CdmKeySetId& key_set_id);
+
+  // License related methods
+  // Construct a valid license request
+  CdmResponseType GenerateKeyRequest(const CdmSessionId& session_id,
+                                     const CdmKeySetId& key_set_id,
+                                     const CdmInitData& init_data,
+                                     const CdmLicenseType license_type,
+                                     CdmAppParameterMap& app_parameters,
+                                     CdmKeyMessage* key_request,
+                                     std::string* server_url);
+
+  // Accept license response and extract key info.
+  CdmResponseType AddKey(const CdmSessionId& session_id,
+                         const CdmKeyResponse& key_data,
+                         CdmKeySetId* key_set_id);
+
+  CdmResponseType RestoreKey(const CdmSessionId& session_id,
+                             const CdmKeySetId& key_set_id);
+
+  CdmResponseType CancelKeyRequest(const CdmSessionId& session_id);
+
+  // Construct valid renewal request for the current session keys.
+  CdmResponseType GenerateRenewalRequest(const CdmSessionId& session_id,
+                                         CdmKeyMessage* key_request,
+                                         std::string* server_url);
+
+  // Accept renewal response and update key info.
+  CdmResponseType RenewKey(const CdmSessionId& session_id,
+                           const CdmKeyResponse& key_data);
+
+  // Query system information
+  CdmResponseType QueryStatus(CdmQueryMap* info);
+
+  // Query session information
+  virtual CdmResponseType QuerySessionStatus(const CdmSessionId& session_id,
+                                             CdmQueryMap* key_info);
+
+  // Query license information
+  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);
+
+  CdmResponseType HandleProvisioningResponse(CdmProvisioningResponse& response);
+
+  // Decryption and key related methods
+  // Accept encrypted buffer and return decrypted data.
+  CdmResponseType Decrypt(const CdmSessionId& session_id,
+                          const CdmDecryptionParameters& parameters);
+
+  // Is the key known to any session?
+  bool IsKeyLoaded(const KeyId& key_id);
+  bool FindSessionForKey(const KeyId& key_id, CdmSessionId* sessionId);
+
+  // Event listener related methods
+  bool AttachEventListener(const CdmSessionId& session_id,
+                           WvCdmEventListener* listener);
+  bool DetachEventListener(const CdmSessionId& session_id,
+                           WvCdmEventListener* listener);
+
+  // Parse a blob of multiple concatenated PSSH atoms to extract the first
+  // widevine pssh
+  static bool ExtractWidevinePssh(const CdmInitData& init_data,
+                                  CdmInitData* output);
+
+  // Timer expiration method
+  void OnTimerEvent();
+
+ private:
+  // private methods
+  bool ValidateKeySystem(const CdmKeySystem& key_system);
+
+  void OnKeyReleaseEvent(const CdmKeySetId& key_set_id);
+
+  // instance variables
+  CdmSessionMap sessions_;
+  CdmReleaseKeySetMap release_key_sets_;
+  CertificateProvisioning cert_provisioning_;
+  SecurityLevel cert_provisioning_requested_security_level_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(CdmEngine);
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_CDM_ENGINE_H_

core/include/cdm_session.h

@@ -0,0 +1,130 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_CDM_SESSION_H_
+#define WVCDM_CORE_CDM_SESSION_H_
+
+#include <set>
+
+#include "crypto_session.h"
+#include "device_files.h"
+#include "license.h"
+#include "oemcrypto_adapter.h"
+#include "policy_engine.h"
+#include "scoped_ptr.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+class CdmClientPropertySet;
+class WvCdmEventListener;
+
+class CdmSession {
+ public:
+  explicit CdmSession(const CdmClientPropertySet* cdm_client_property_set);
+  ~CdmSession();
+
+  CdmResponseType Init();
+
+  CdmResponseType RestoreOfflineSession(const CdmKeySetId& key_set_id,
+                                        const CdmLicenseType license_type);
+
+  void set_key_system(const CdmKeySystem& ksystem) { key_system_ = ksystem; }
+  const CdmKeySystem& key_system() { return key_system_; }
+
+  const CdmSessionId& session_id() { return session_id_; }
+
+  CdmResponseType GenerateKeyRequest(const CdmInitData& init_data,
+                                     const CdmLicenseType license_type,
+                                     const CdmAppParameterMap& app_parameters,
+                                     CdmKeyMessage* key_request,
+                                     std::string* server_url);
+
+  // AddKey() - Accept license response and extract key info.
+  CdmResponseType AddKey(const CdmKeyResponse& key_response,
+                         CdmKeySetId* key_set_id);
+
+  // CancelKeyRequest() - Cancel session.
+  CdmResponseType CancelKeyRequest();
+
+  // Query session status
+  CdmResponseType QueryStatus(CdmQueryMap* key_info);
+
+  // 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(const CdmDecryptionParameters& parameters);
+
+  // License renewal
+  // GenerateRenewalRequest() - Construct valid renewal request for the current
+  // session keys.
+  CdmResponseType GenerateRenewalRequest(CdmKeyMessage* key_request,
+                                         std::string* server_url);
+
+  // RenewKey() - Accept renewal response and update key info.
+  CdmResponseType RenewKey(const CdmKeyResponse& key_response);
+
+  // License release
+  // GenerateReleaseRequest() - Construct valid release request for the current
+  // session keys.
+  CdmResponseType GenerateReleaseRequest(CdmKeyMessage* key_request,
+                                         std::string* server_url);
+
+  // ReleaseKey() - Accept response and release key.
+  CdmResponseType ReleaseKey(const CdmKeyResponse& key_response);
+
+  bool IsKeyLoaded(const KeyId& key_id);
+
+  bool AttachEventListener(WvCdmEventListener* listener);
+  bool DetachEventListener(WvCdmEventListener* listener);
+
+  void OnTimerEvent();
+  void OnKeyReleaseEvent(const CdmKeySetId& key_set_id);
+
+  SecurityLevel GetRequestedSecurityLevel();
+
+ private:
+
+  // Generate unique ID for each new session.
+  CdmSessionId GenerateSessionId();
+  bool GenerateKeySetId(CdmKeySetId* key_set_id);
+
+  bool StoreLicense(DeviceFiles::LicenseState state);
+
+  // instance variables
+  const CdmSessionId session_id_;
+  CdmKeySystem key_system_;
+  CdmLicense license_parser_;
+  scoped_ptr<CryptoSession> crypto_session_;
+  PolicyEngine policy_engine_;
+  bool license_received_;
+  bool reinitialize_session_;
+
+  CdmLicenseType license_type_;
+
+  // license type offline related information
+  CdmInitData offline_pssh_data_;
+  CdmKeyMessage offline_key_request_;
+  CdmKeyResponse offline_key_response_;
+  CdmKeyMessage offline_key_renewal_request_;
+  CdmKeyResponse offline_key_renewal_response_;
+  std::string offline_release_server_url_;
+
+  // license type release and offline related information
+  CdmKeySetId key_set_id_;
+
+  // Used for certificate based licensing
+  std::string wrapped_key_;
+  bool is_certificate_loaded_;
+
+  std::set<WvCdmEventListener*> listeners_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(CdmSession);
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_CDM_SESSION_H_

core/include/certificate_provisioning.h

@@ -0,0 +1,38 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_CERTIFICATE_PROVISIONING_H_
+#define WVCDM_CORE_CERTIFICATE_PROVISIONING_H_
+
+#include "crypto_session.h"
+#include "oemcrypto_adapter.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+class CdmSession;
+
+class CertificateProvisioning {
+ public:
+  CertificateProvisioning() {};
+  ~CertificateProvisioning() {};
+
+  // Provisioning related methods
+  CdmResponseType GetProvisioningRequest(SecurityLevel requested_security_level,
+                                         CdmProvisioningRequest* request,
+                                         std::string* default_url);
+  CdmResponseType HandleProvisioningResponse(CdmProvisioningResponse& response);
+
+ private:
+  void ComposeJsonRequestAsQueryString(const std::string& message,
+                                       CdmProvisioningRequest* request);
+  bool ParseJsonResponse(const CdmProvisioningResponse& json_str,
+                         const std::string& start_substr,
+                         const std::string& end_substr,
+                         std::string* result);
+  CryptoSession crypto_session_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(CertificateProvisioning);
+};
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_CERTIFICATE_PROVISIONING_H_

core/include/clock.h

@@ -0,0 +1,25 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Clock - Platform independent interface for a time library
+//
+#ifndef WVCDM_CORE_CLOCK_H_
+#define WVCDM_CORE_CLOCK_H_
+
+#include <stdint.h>
+
+namespace wvcdm {
+
+// Provides time related information. The implementation is platform dependent.
+class Clock {
+
+ public:
+  Clock() {}
+  virtual ~Clock() {}
+
+  // Provides the number of seconds since an epoch - 01/01/1970 00:00 UTC
+  virtual int64_t GetCurrentTime();
+};
+
+};  // namespace wvcdm
+
+#endif  // WVCDM_CORE_CLOCK_H_

core/include/crypto_key.h

@@ -0,0 +1,40 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_CRYPTO_KEY_H_
+#define WVCDM_CORE_CRYPTO_KEY_H_
+
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+class CryptoKey {
+public:
+  CryptoKey() {};
+  ~CryptoKey() {};
+
+  const std::string& key_id() const { return key_id_; }
+  const std::string& key_data() const { return key_data_; }
+  const std::string& key_data_iv() const { return key_data_iv_; }
+  const std::string& key_control() const { return key_control_; }
+  const std::string& key_control_iv() const { return key_control_iv_; }
+  void set_key_id(const std::string& key_id) { key_id_ = key_id; }
+  void set_key_data(const std::string& key_data) { key_data_ = key_data; }
+  void set_key_data_iv(const std::string& iv) { key_data_iv_ = iv; }
+  void set_key_control(const std::string& ctl) { key_control_ = ctl; }
+  void set_key_control_iv(const std::string& ctl_iv) {
+    key_control_iv_ = ctl_iv;
+  }
+
+  bool HasKeyControl() const { return key_control_.size() >= 16; }
+
+private:
+  std::string key_id_;
+  std::string key_data_iv_;
+  std::string key_data_;
+  std::string key_control_;
+  std::string key_control_iv_;
+};
+
+}; // namespace wvcdm
+
+#endif  // WVCDM_CORE_CRYPTO_KEY_H_

core/include/crypto_session.h

@@ -0,0 +1,104 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_CRYPTO_SESSSION_H_
+#define WVCDM_CORE_CRYPTO_SESSSION_H_
+
+#include <string>
+#include <map>
+
+#include "lock.h"
+#include "oemcrypto_adapter.h"
+#include "OEMCryptoCENC.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+class CryptoKey;
+typedef std::map<CryptoKeyId, CryptoKey*> CryptoKeyMap;
+
+class CryptoSession {
+ public:
+  CryptoSession();
+  ~CryptoSession();
+
+  bool ValidateKeybox();
+  bool GetToken(std::string* token);
+  CdmSecurityLevel GetSecurityLevel();
+  bool GetDeviceUniqueId(std::string* device_id);
+  bool GetSystemId(uint32_t* system_id);
+  bool GetProvisioningId(std::string* provisioning_id);
+
+  CdmResponseType Open() { return Open(kLevelDefault); }
+  CdmResponseType Open(SecurityLevel requested_security_level);
+  void Close();
+
+  bool IsOpen() { return open_; }
+  CryptoSessionId oec_session_id() { return oec_session_id_; }
+
+  // Key request/response
+  void GenerateRequestId(std::string& req_id_str);
+  bool PrepareRequest(const std::string& key_deriv_message,
+                      bool is_provisioning, std::string* signature);
+  bool PrepareRenewalRequest(const std::string& message,
+                             std::string* signature);
+  CdmResponseType LoadKeys(const std::string& message,
+                           const std::string& signature,
+                           const std::string& mac_key_iv,
+                           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 RewrapDeviceRSAKey(const std::string& message,
+                          const std::string& signature,
+                          const std::string& nonce,
+                          const std::string& enc_rsa_key,
+                          const std::string& rsa_key_iv,
+                          std::string* wrapped_rsa_key);
+
+  // Media data path
+  CdmResponseType Decrypt(const CdmDecryptionParameters& parameters);
+
+  bool GetRandom(size_t data_length, uint8_t* random_data);
+
+ private:
+  void Init();
+  void Terminate();
+  void GenerateMacContext(const std::string& input_context,
+                          std::string* deriv_context);
+  void GenerateEncryptContext(const std::string& input_context,
+                              std::string* deriv_context);
+  bool GenerateSignature(const std::string& message, bool use_rsa,
+                         std::string* signature);
+  size_t GetOffset(std::string message, std::string field);
+  bool SetDestinationBufferType();
+
+  bool SelectKey(const std::string& key_id);
+
+  static const size_t kSignatureSize = 32;  // size for HMAC-SHA256 signature
+  static Lock crypto_lock_;
+  static bool initialized_;
+  static int session_count_;
+
+  bool open_;
+  CryptoSessionId oec_session_id_;
+
+  OEMCryptoBufferType destination_buffer_type_;
+  bool is_destination_buffer_type_valid_;
+  SecurityLevel requested_security_level_;
+
+  KeyId key_id_;
+
+  uint64_t request_id_base_;
+  static uint64_t request_id_index_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(CryptoSession);
+};
+
+};  // namespace wvcdm
+
+#endif  // WVCDM_CORE_CRYPTO_SESSSION_H_

core/include/device_files.h

@@ -0,0 +1,76 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+#ifndef WVCDM_CORE_DEVICE_FILES_H_
+#define WVCDM_CORE_DEVICE_FILES_H_
+
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+class File;
+
+class DeviceFiles {
+ public:
+  typedef enum {
+    kLicenseStateActive,
+    kLicenseStateReleasing,
+    kLicenseStateUnknown,
+  } LicenseState;
+
+  DeviceFiles(): file_(NULL), security_level_(kSecurityLevelUninitialized),
+                 initialized_(false) {}
+  virtual ~DeviceFiles() {}
+
+  virtual bool Init(const File* handle, CdmSecurityLevel security_level);
+
+  virtual bool StoreCertificate(const std::string& certificate,
+                                const std::string& wrapped_private_key);
+  virtual bool RetrieveCertificate(std::string* certificate,
+                                   std::string* wrapped_private_key);
+
+  virtual bool StoreLicense(const std::string& key_set_id,
+                            const LicenseState state,
+                            const CdmInitData& pssh_data,
+                            const CdmKeyMessage& key_request,
+                            const CdmKeyResponse& key_response,
+                            const CdmKeyMessage& key_renewal_request,
+                            const CdmKeyResponse& key_renewal_response,
+                            const std::string& release_server_url);
+  virtual bool RetrieveLicense(const std::string& key_set_id,
+                               LicenseState* state,
+                               CdmInitData* pssh_data,
+                               CdmKeyMessage* key_request,
+                               CdmKeyResponse* key_response,
+                               CdmKeyMessage* key_renewal_request,
+                               CdmKeyResponse* key_renewal_response,
+                               std::string* release_server_url);
+  virtual bool DeleteLicense(const std::string& key_set_id);
+  virtual bool DeleteAllFiles();
+  virtual bool DeleteAllLicenses();
+  virtual bool LicenseExists(const std::string& key_set_id);
+
+  // For testing only
+  static std::string GetCertificateFileName();
+  static std::string GetLicenseFileNameExtension();
+
+ protected:
+  bool Hash(const std::string& data, std::string* hash);
+  bool StoreFile(const char* name, const std::string& data);
+  bool RetrieveFile(const char* name, std::string* data);
+
+ private:
+  // Certificate and offline licenses are now stored in security
+  // level specific directories. In an earlier version they were
+  // stored in a common directory and need to be copied over.
+  virtual void SecurityLevelPathBackwardCompatibility();
+
+  File* file_;
+  CdmSecurityLevel security_level_;
+  bool initialized_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(DeviceFiles);
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_DEVICE_FILES_H_

core/include/file_store.h

@@ -0,0 +1,51 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// File - Platform independent interface for a File class
+//
+#ifndef WVCDM_CORE_FILE_STORE_H_
+#define WVCDM_CORE_FILE_STORE_H_
+
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+// File class. The implementation is platform dependent.
+class File {
+ public:
+  class Impl;
+
+  // defines as bit flag
+  enum OpenFlags {
+    kNoFlags = 0,
+    kBinary = 1,
+    kCreate = 2,
+    kReadOnly = 4,  // defaults to read and write access
+    kTruncate = 8
+  };
+
+  File();
+  virtual ~File();
+
+  virtual bool Open(const std::string& file_path, int flags);
+  virtual ssize_t Read(char* buffer, size_t bytes);
+  virtual ssize_t Write(const char* buffer, size_t bytes);
+  virtual void Close();
+
+  virtual bool Exists(const std::string& file_path);
+  virtual bool Remove(const std::string& file_path);
+  virtual bool Copy(const std::string& old_path, const std::string& new_path);
+  virtual bool List(const std::string& path, std::vector<std::string>* files);
+  virtual bool CreateDirectory(const std::string dir_path);
+  virtual bool IsDirectory(const std::string& dir_path);
+  virtual bool IsRegularFile(const std::string& file_path);
+  virtual ssize_t FileSize(const std::string& file_path);
+
+ private:
+  Impl *impl_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(File);
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_FILE_STORE_H_

core/include/license.h

@@ -0,0 +1,74 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_LICENSE_H_
+#define WVCDM_CORE_LICENSE_H_
+
+#include <set>
+
+#include "wv_cdm_types.h"
+
+namespace video_widevine_server {
+namespace sdk {
+class SignedMessage;
+}
+}  // namespace video_widevine_server
+
+namespace wvcdm {
+
+class CryptoSession;
+class PolicyEngine;
+
+class CdmLicense {
+ public:
+
+  CdmLicense() : session_(NULL), initialized_(false) {}
+  ~CdmLicense() {}
+
+  bool Init(const std::string& token, CryptoSession* session,
+            PolicyEngine* policy_engine);
+
+  bool PrepareKeyRequest(const CdmInitData& pssh_data,
+                         const CdmLicenseType license_type,
+                         const CdmAppParameterMap& app_parameters,
+                         const CdmSessionId& session_id,
+                         CdmKeyMessage* signed_request,
+                         std::string* server_url);
+  bool PrepareKeyUpdateRequest(bool is_renewal, CdmKeyMessage* signed_request,
+                               std::string* server_url);
+  CdmResponseType HandleKeyResponse(const CdmKeyResponse& license_response);
+  CdmResponseType HandleKeyUpdateResponse(
+      bool is_renewal, const CdmKeyResponse& license_response);
+
+  bool RestoreOfflineLicense(CdmKeyMessage& license_request,
+                             CdmKeyResponse& license_response,
+                             CdmKeyResponse& license_renewal_response);
+  bool HasInitData() { return !init_data_.empty(); }
+  bool IsKeyLoaded(const KeyId& key_id);
+
+ private:
+  bool PrepareServiceCertificateRequest(CdmKeyMessage* signed_request,
+                                        std::string* server_url);
+  CdmResponseType HandleServiceCertificateResponse(
+      const video_widevine_server::sdk::SignedMessage& signed_message);
+
+  CdmResponseType HandleKeyErrorResponse(
+      const video_widevine_server::sdk::SignedMessage& signed_message);
+
+  CryptoSession* session_;
+  PolicyEngine* policy_engine_;
+  std::string server_url_;
+  std::string token_;
+  std::string service_certificate_;
+  std::string init_data_;
+  bool initialized_;
+  std::set<KeyId> loaded_keys_;
+
+  // Used for certificate based licensing
+  CdmKeyMessage key_request_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(CdmLicense);
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_LICENSE_H_

core/include/lock.h

@@ -0,0 +1,61 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Lock - Platform independent interface for a Mutex class
+//
+#ifndef WVCDM_CORE_LOCK_H_
+#define WVCDM_CORE_LOCK_H_
+
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+// Simple lock class. The implementation is platform dependent.
+//
+// The lock must be unlocked by the thread that locked it.
+// The lock is also not recursive (ie. cannot be taken multiple times).
+class Lock {
+ public:
+  Lock();
+  ~Lock();
+
+  void Acquire();
+  void Release();
+
+  // Acquires a lock if not held and returns true.
+  // Returns false if the lock is held by another thread.
+  bool Try();
+
+  friend class AutoLock;
+
+ private:
+  class Impl;
+  Impl *impl_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(Lock);
+};
+
+// Manages the lock automatically. It will be locked when AutoLock
+// is constructed and release when AutoLock goes out of scope.
+class AutoLock {
+ public:
+  explicit AutoLock(Lock& lock) : lock_(&lock) {
+    lock_->Acquire();
+  }
+
+  explicit AutoLock(Lock* lock) : lock_(lock) {
+    lock_->Acquire();
+  }
+
+  ~AutoLock() {
+    lock_->Release();
+  }
+
+ private:
+  Lock *lock_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(AutoLock);
+};
+
+};  // namespace wvcdm
+
+#endif  // WVCDM_CORE_LOCK_H_

core/include/log.h

@@ -0,0 +1,37 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Log - Platform independent interface for a Logging class
+//
+#ifndef WVCDM_CORE_LOG_H_
+#define WVCDM_CORE_LOG_H_
+
+namespace wvcdm {
+
+// Simple logging class. The implementation is platform dependent.
+
+typedef enum {
+  LOG_ERROR,
+  LOG_WARN,
+  LOG_INFO,
+  LOG_DEBUG,
+  LOG_VERBOSE
+} LogPriority;
+
+// Enable/disable verbose logging (LOGV).
+// This function is supplied for cases where the system layer does not
+// initialize logging.  This is also needed to initialize logging in
+// unit tests.
+void InitLogging(int argc, const char* const* argv);
+
+void Log(const char* file, int line, LogPriority level, const char* fmt, ...);
+
+// Log APIs
+#define LOGE(...) Log(__FILE__, __LINE__, wvcdm::LOG_ERROR, __VA_ARGS__)
+#define LOGW(...) Log(__FILE__, __LINE__, wvcdm::LOG_WARN, __VA_ARGS__)
+#define LOGI(...) Log(__FILE__, __LINE__, wvcdm::LOG_INFO, __VA_ARGS__)
+#define LOGD(...) Log(__FILE__, __LINE__, wvcdm::LOG_DEBUG, __VA_ARGS__)
+#define LOGV(...) Log(__FILE__, __LINE__, wvcdm::LOG_VERBOSE, __VA_ARGS__)
+
+};  // namespace wvcdm
+
+#endif  // WVCDM_CORE_LOG_H_

core/include/oemcrypto_adapter.h

@@ -0,0 +1,31 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+#ifndef WVCDM_CORE_OEMCRYPTO_ADAPTER_H_
+#define WVCDM_CORE_OEMCRYPTO_ADAPTER_H_
+
+#include "OEMCryptoCENC.h"
+
+namespace wvcdm {
+
+enum SecurityLevel {
+  kLevelDefault,
+  kLevel3
+};
+
+/* This attempts to open a session at the desired security level.
+   If one level is not available, the other will be used instead. */
+OEMCryptoResult OEMCrypto_OpenSession(OEMCrypto_SESSION* session,
+                                      SecurityLevel level);
+OEMCryptoResult OEMCrypto_IsKeyboxValid(SecurityLevel level);
+OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID, size_t* idLength,
+                                      SecurityLevel level);
+OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData, size_t* keyDataLength,
+                                     SecurityLevel level);
+OEMCryptoResult OEMCrypto_InstallKeybox(const uint8_t* keybox,
+                                        size_t keyBoxLength,
+                                        SecurityLevel level);
+uint32_t OEMCrypto_APIVersion(SecurityLevel level);
+const char* OEMCrypto_SecurityLevel(SecurityLevel level);
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_OEMCRYPTO_ADAPTER_H_

core/include/policy_engine.h

@@ -0,0 +1,121 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_POLICY_ENGINE_H_
+#define WVCDM_CORE_POLICY_ENGINE_H_
+
+#include <string>
+
+#include "license_protocol.pb.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+class Clock;
+class PolicyEngineTest;
+
+// This acts as an oracle that basically says "Yes(true) you may still decrypt
+// or no(false) you may not decrypt this data anymore."
+class PolicyEngine {
+ public:
+  PolicyEngine();
+  ~PolicyEngine();
+
+  // The value returned should be taken as a hint rather than an absolute
+  // status. It is computed during the last call to either SetLicense/
+  // UpdateLicense/OnTimerEvent/BeginDecryption and may be out of sync
+  // depending on the amount of time elapsed. The current decryption
+  // status is not calculated to avoid overhead in the decryption path.
+  inline bool can_decrypt() { return can_decrypt_; }
+
+  // OnTimerEvent is called when a timer fires. It notifies the Policy Engine
+  // that the timer has fired and that it should check whether any events have
+  // occurred since the last timer event. If so, it sets event_occurred to true
+  // and sets event to point to the event that occurred. If not, it sets
+  // event_occurred to false.
+  void OnTimerEvent(bool* event_occurred, CdmEventType* event);
+
+  // SetLicense is used in handling the initial license response. It stores
+  // an exact copy of the policy information stored in the license.
+  // The license state transitions to kLicenseStateCanPlay if the license
+  // permits playback.
+  void SetLicense(const video_widevine_server::sdk::License& license);
+
+  // Call this on first decrypt to set the start of playback. This is
+  // for cases where usage begins not when the license is received,
+  // but at the start of playback
+  void BeginDecryption(void);
+
+  // UpdateLicense is used in handling a license response for a renewal request.
+  // The response may only contain any policy fields that have changed. In this
+  // case an exact copy is not what we want to happen. We also will receive an
+  // updated license_start_time from the server. The license will transition to
+  // kLicenseStateCanPlay if the license permits playback.
+  void UpdateLicense(const video_widevine_server::sdk::License& license);
+
+  CdmResponseType Query(CdmQueryMap* key_info);
+
+  const video_widevine_server::sdk::LicenseIdentification& license_id() {
+    return license_id_;
+  }
+
+  bool IsLicenseDurationExpired(int64_t current_time);
+  bool IsPlaybackDurationExpired(int64_t current_time);
+
+ private:
+  typedef enum {
+    kLicenseStateInitial,
+    kLicenseStateInitialPendingUsage,
+    kLicenseStateCanPlay,
+    kLicenseStateNeedRenewal,
+    kLicenseStateWaitingLicenseUpdate,
+    kLicenseStateExpired
+  } LicenseState;
+
+  void Init(Clock* clock);
+
+  bool IsRenewalDelayExpired(int64_t current_time);
+  bool IsRenewalRecoveryDurationExpired(int64_t current_time);
+  bool IsRenewalRetryIntervalExpired(int64_t current_time);
+
+  void UpdateRenewalRequest(int64_t current_time);
+
+  LicenseState license_state_;
+  bool can_decrypt_;
+
+  // This is the current policy information for this license. This gets updated
+  // as license renewals occur.
+  video_widevine_server::sdk::License::Policy policy_;
+
+  // This is the license id field from server response. This data gets passed
+  // back to the server in each renewal request. When we get a renewal response
+  // from the license server we will get an updated id field.
+  video_widevine_server::sdk::LicenseIdentification license_id_;
+
+  // This is the license start time that gets sent from the server in each
+  // license request or renewal.
+  int64_t license_start_time_;
+
+  // This is the time at which the license was received and playback was
+  // started. These times are based off the local clock in case there is a
+  // discrepency between local and server time.
+  int64_t license_received_time_;
+  int64_t playback_start_time_;
+
+  // This is used as a reference point for policy management. This value
+  // represents an offset from license_received_time_. This is used to
+  // calculate the time where renewal retries should occur.
+  int64_t next_renewal_time_;
+  int64_t policy_max_duration_seconds_;
+
+  Clock* clock_;
+
+  // For testing
+  friend class PolicyEngineTest;
+  PolicyEngine(Clock* clock);
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(PolicyEngine);
+};
+
+}  // wvcdm
+
+#endif  // WVCDM_CORE_POLICY_ENGINE_H_

core/include/privacy_crypto.h

@@ -0,0 +1,74 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Description:
+//   Declaration of classes representing AES and RSA public keys used
+//   for signature verification and encryption.
+//
+// AES encryption details:
+//   Algorithm: AES-CBC
+//
+// RSA signature details:
+//   Algorithm: RSASSA-PSS
+//   Hash algorithm: SHA1
+//   Mask generation function: mgf1SHA1
+//   Salt length: 20 bytes
+//   Trailer field: 0xbc
+//
+// RSA encryption details:
+//   Algorithm: RSA-OAEP
+//   Mask generation function: mgf1SHA1
+//   Label (encoding paramter): empty string
+//
+#ifndef WVCDM_CORE_PRIVACY_CRYPTO_H_
+#define WVCDM_CORE_PRIVACY_CRYPTO_H_
+
+#include <string>
+
+#include "openssl/evp.h"
+#include "openssl/rsa.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+class AesCbcKey {
+ public:
+  AesCbcKey() : initialized_(false) {};
+  ~AesCbcKey() {};
+
+  bool Init(const std::string& key);
+  bool Encrypt(const std::string& in, std::string* out, std::string* iv);
+
+ private:
+  EVP_CIPHER_CTX ctx_;
+  bool initialized_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(AesCbcKey);
+};
+
+class RsaPublicKey {
+ public:
+  RsaPublicKey() : key_(NULL) {}
+  ~RsaPublicKey();
+
+  // Initializes an RsaPublicKey object using a DER encoded PKCS#1 RSAPublicKey
+  bool Init(const std::string& serialized_key);
+
+  // Encrypt a message using RSA-OAEP. Caller retains ownership of all
+  // parameters. Returns true if successful, false otherwise.
+  bool Encrypt(const std::string& plaintext,
+               std::string* ciphertext);
+
+  // Verify RSSASSA-PSS signature. Caller retains ownership of all parameters.
+  // Returns true if validation succeeds, false otherwise.
+  bool VerifySignature(const std::string& message,
+                       const std::string& signature);
+
+ private:
+  RSA* key_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(RsaPublicKey);
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_PRIVACY_CRYPTO_H_

core/include/properties.h

@@ -0,0 +1,121 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_PROPERTIES_H_
+#define WVCDM_CORE_PROPERTIES_H_
+
+#include <map>
+#include <string>
+
+#include "cdm_client_property_set.h"
+#include "lock.h"
+#include "scoped_ptr.h"
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+typedef std::map<CdmSessionId, const CdmClientPropertySet*>
+    CdmClientPropertySetMap;
+
+// This class saves information about features and properties enabled
+// 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 specific getter
+// methods.
+// Setter methods are provided but their only planned use is for testing.
+class Properties {
+ public:
+  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_;
+  }
+  static inline bool extract_pssh_data() { return extract_pssh_data_; }
+  static inline bool decrypt_with_empty_session_support() {
+    return decrypt_with_empty_session_support_;
+  }
+  static inline bool security_level_path_backward_compatibility_support() {
+    return security_level_path_backward_compatibility_support_;
+  }
+  static bool GetCompanyName(std::string* company_name);
+  static bool GetModelName(std::string* model_name);
+  static bool GetArchitectureName(std::string* arch_name);
+  static bool GetDeviceName(std::string* device_name);
+  static bool GetProductName(std::string* product_name);
+  static bool GetBuildInfo(std::string* build_info);
+  static bool GetDeviceFilesBasePath(CdmSecurityLevel security_level,
+                                     std::string* base_path);
+  static bool GetFactoryKeyboxPath(std::string* keybox);
+  static bool GetOEMCryptoPath(std::string* library_name);
+  static bool GetSecurityLevelDirectories(std::vector<std::string>* dirs);
+  static const std::string GetSecurityLevel(const CdmSessionId& session_id);
+  static const std::vector<uint8_t> GetServiceCertificate(
+      const CdmSessionId& session_id);
+  static bool UsePrivacyMode(const CdmSessionId& session_id);
+  static uint32_t GetSessionSharingId(const CdmSessionId& session_id);
+
+  static bool AddSessionPropertySet(const CdmSessionId& session_id,
+                                    const CdmClientPropertySet* property_set);
+  static bool RemoveSessionPropertySet(const CdmSessionId& session_id);
+
+ private:
+  static const CdmClientPropertySet* GetCdmClientPropertySet(
+      const CdmSessionId& session_id);
+  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;
+  }
+  static void set_extract_pssh_data(bool flag) { extract_pssh_data_ = flag; }
+
+  static void set_decrypt_with_empty_session_support(bool flag) {
+    decrypt_with_empty_session_support_ = flag;
+  }
+  static void set_security_level_path_backward_compatibility_support(
+      bool flag) {
+    security_level_path_backward_compatibility_support_ = flag;
+  }
+
+ private:
+  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_;
+  static bool extract_pssh_data_;
+  static bool decrypt_with_empty_session_support_;
+  static bool security_level_path_backward_compatibility_support_;
+  static scoped_ptr<CdmClientPropertySetMap> session_property_set_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(Properties);
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_PROPERTIES_H_

core/include/scoped_ptr.h

@@ -0,0 +1,64 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// A simple and partial implementation of scoped_ptr class.
+// The implementation is copied from gtest/include/gtest/internal/gtest-port.h.
+//
+#ifndef WVCDM_CORE_SCOPED_PTR_H_
+#define WVCDM_CORE_SCOPED_PTR_H_
+
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+// A scoped_ptr<T> is like a T*, except that the destructor of scoped_ptr<T>
+// automatically deletes the pointer it holds (if any).
+// That is, scoped_ptr<T> owns the T object that it points to.
+// Like a T*, a scoped_ptr<T> may hold either NULL or a pointer to a T object.
+// Also like T*, scoped_ptr<T> is thread-compatible, and once you
+// dereference it, you get the thread safety guarantees of T.
+//
+// The size of scoped_ptr is small. On most compilers, sizeof(scoped_ptr<T>)
+// == sizeof(T*).
+//
+// Current implementation targets having a strict subset of  C++11's
+// unique_ptr<> features. Known deficiencies include not supporting move-only
+// deleteres, function pointers as deleters, and deleters with reference
+// types.
+
+// This implementation of scoped_ptr is PARTIAL, e.g. it does not support move,
+// custom deleter etc.
+template <typename T>
+class scoped_ptr {
+ public:
+  typedef T element_type;
+
+  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
+  ~scoped_ptr() { reset(); }
+
+  T& operator*() const { return *ptr_; }
+  T* operator->() const { return ptr_; }
+  T* get() const { return ptr_; }
+
+  T* release() {
+    T* const ptr = ptr_;
+    ptr_ = NULL;
+    return ptr;
+  }
+
+  void reset(T* p = NULL) {
+    if (p != ptr_) {
+      if (sizeof(T) > 0) {  // Makes sure T is a complete type.
+        delete ptr_;
+      }
+      ptr_ = p;
+    }
+  }
+ private:
+  T* ptr_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(scoped_ptr);
+};
+
+};  // namespace wvcdm
+
+#endif  // WVCDM_CORE_SCOPED_PTR_H_

core/include/string_conversions.h

@@ -0,0 +1,26 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_STRING_CONVERSIONS_H_
+#define WVCDM_CORE_STRING_CONVERSIONS_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+namespace wvcdm {
+
+std::vector<uint8_t> a2b_hex(const std::string& b);
+std::string a2bs_hex(const std::string& b);
+std::string b2a_hex(const std::vector<uint8_t>& b);
+std::string b2a_hex(const std::string& b);
+std::string Base64SafeEncode(const std::vector<uint8_t>& bin_input);
+std::string Base64SafeEncodeNoPad(const std::vector<uint8_t>& bin_input);
+std::vector<uint8_t> Base64SafeDecode(const std::string& bin_input);
+std::string HexEncode(const uint8_t* bytes, unsigned size);
+std::string IntToString(int value);
+std::string UintToString(unsigned int value);
+
+};  // namespace wvcdm
+
+#endif  // WVCDM_CORE_STRING_CONVERSIONS_H_

core/include/timer.h

@@ -0,0 +1,51 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Timer - Platform independent interface for a Timer class
+//
+#ifndef WVCDM_CORE_TIMER_H_
+#define WVCDM_CORE_TIMER_H_
+
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+// Timer Handler class.
+//
+// Derive from this class if you wish to receive events when the timer
+// expires. Provide the handler when setting up a new Timer.
+
+class TimerHandler {
+ public:
+  TimerHandler() {};
+  virtual ~TimerHandler() {};
+
+  virtual void OnTimerEvent() = 0;
+};
+
+// Timer class. The implementation is platform dependent.
+//
+// This class provides a simple recurring timer API. The class receiving
+// timer expiry events should derive from TimerHandler.
+// Specify the receiver class and the periodicty of timer events when
+// the timer is initiated by calling Start.
+
+class Timer {
+ public:
+  class Impl;
+
+  Timer();
+  ~Timer();
+
+  bool Start(TimerHandler *handler, uint32_t time_in_secs);
+  void Stop();
+  bool IsRunning();
+
+ private:
+  Impl *impl_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(Timer);
+};
+
+};  // namespace wvcdm
+
+#endif  // WVCDM_CORE_TIMER_H_

core/include/wv_cdm_constants.h

@@ -0,0 +1,58 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_WV_CDM_CONSTANTS_H_
+#define WVCDM_CORE_WV_CDM_CONSTANTS_H_
+
+#include <string>
+
+namespace wvcdm {
+static const size_t KEY_CONTROL_SIZE = 16;
+static const size_t KEY_ID_SIZE = 16;
+static const size_t KEY_IV_SIZE = 16;
+static const size_t KEY_PAD_SIZE = 16;
+static const size_t KEY_SIZE = 16;
+static const size_t MAC_KEY_SIZE = 32;
+static const size_t KEYBOX_KEY_DATA_SIZE = 72;
+
+static const char SESSION_ID_PREFIX[] = "sid";
+static const char KEY_SET_ID_PREFIX[] = "ksid";
+static const char KEY_SYSTEM[] = "com.widevine";
+
+// define query keys, values here
+static const std::string QUERY_KEY_LICENSE_TYPE = "LicenseType";
+                                                    // "Streaming", "Offline"
+static const std::string QUERY_KEY_PLAY_ALLOWED = "PlayAllowed";
+                                                    // "True", "False"
+static const std::string QUERY_KEY_PERSIST_ALLOWED = "PersistAllowed";
+                                                    // "True", "False"
+static const std::string QUERY_KEY_RENEW_ALLOWED = "RenewAllowed";
+                                                    // "True", "False"
+static const std::string QUERY_KEY_LICENSE_DURATION_REMAINING =
+    "LicenseDurationRemaining";                     // non-negative integer
+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_KEY_SYSTEM_ID = "SystemID";
+                                               // system id
+static const std::string QUERY_KEY_PROVISIONING_ID = "ProvisioningID";
+                                               // provisioning unique id
+
+static const std::string QUERY_VALUE_TRUE = "True";
+static const std::string QUERY_VALUE_FALSE = "False";
+static const std::string QUERY_VALUE_STREAMING = "Streaming";
+static const std::string QUERY_VALUE_OFFLINE = "Offline";
+static const std::string QUERY_VALUE_SECURITY_LEVEL_L1 = "L1";
+static const std::string QUERY_VALUE_SECURITY_LEVEL_L2 = "L2";
+static const std::string QUERY_VALUE_SECURITY_LEVEL_L3 = "L3";
+static const std::string QUERY_VALUE_SECURITY_LEVEL_UNKNOWN = "Unknown";
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_WV_CDM_CONSTANTS_H_

core/include/wv_cdm_event_listener.h

@@ -0,0 +1,28 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_WV_CDM_EVENT_LISTENER_H_
+#define WVCDM_CORE_WV_CDM_EVENT_LISTENER_H_
+
+#include "wv_cdm_types.h"
+
+namespace wvcdm {
+
+// Listener for events from the Content Decryption Module.
+// The caller of the CDM API must provide an implementation for OnEvent
+// and signal its intent by using the Attach/DetachEventListener methods
+// in the WvContentDecryptionModule class.
+class WvCdmEventListener {
+ public:
+  WvCdmEventListener() {}
+  virtual ~WvCdmEventListener() {}
+
+  virtual void OnEvent(const CdmSessionId& session_id,
+                       CdmEventType cdm_event) = 0;
+
+ private:
+  CORE_DISALLOW_COPY_AND_ASSIGN(WvCdmEventListener);
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_WV_CDM_EVENT_LISTENER_H_

core/include/wv_cdm_types.h

@@ -0,0 +1,121 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_CORE_WV_CDM_TYPES_H_
+#define WVCDM_CORE_WV_CDM_TYPES_H_
+
+#include <map>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+namespace wvcdm {
+
+typedef std::string CdmKeySystem;
+typedef std::string CdmInitData;
+typedef std::string CdmKeyMessage;
+typedef std::string CdmKeyResponse;
+typedef std::string KeyId;
+typedef std::string CdmSessionId;
+typedef std::string CdmKeySetId;
+typedef std::string RequestId;
+typedef uint32_t CryptoResult;
+typedef uint32_t CryptoSessionId;
+typedef std::string CryptoKeyId;
+typedef std::map<std::string, std::string> CdmAppParameterMap;
+typedef std::map<std::string, std::string> CdmQueryMap;
+typedef std::string CdmProvisioningRequest;
+typedef std::string CdmProvisioningResponse;
+
+// Types for shared host/cdm interface pairs used to shared vendor data.
+typedef std::pair<std::string, std::string> kStringPairs;
+typedef std::vector<uint8_t> kVectorBytes;
+typedef std::pair<std::string, kVectorBytes> kVectorPairs;
+
+enum CdmResponseType {
+  NO_ERROR,
+  UNKNOWN_ERROR,
+  KEY_ADDED,
+  KEY_ERROR,
+  KEY_MESSAGE,
+  NEED_KEY,
+  KEY_CANCELED,
+  NEED_PROVISIONING,
+  DEVICE_REVOKED,
+  INSUFFICIENT_CRYPTO_RESOURCES,
+};
+
+#define CORE_DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName&);                    \
+  void operator=(const TypeName&)
+
+enum CdmEventType {
+  LICENSE_EXPIRED_EVENT,
+  LICENSE_RENEWAL_NEEDED_EVENT
+};
+
+enum CdmLicenseType {
+  kLicenseTypeOffline,
+  kLicenseTypeStreaming,
+  kLicenseTypeRelease
+};
+
+enum CdmSecurityLevel {
+  kSecurityLevelUninitialized,
+  kSecurityLevelL1,
+  kSecurityLevelL2,
+  kSecurityLevelL3,
+  kSecurityLevelUnknown
+};
+
+struct CdmDecryptionParameters {
+  bool is_encrypted;
+  bool is_secure;
+  const KeyId* key_id;
+  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_length;
+  size_t decrypt_buffer_offset;
+  uint8_t subsample_flags;
+  bool is_video;
+  CdmDecryptionParameters()
+      : is_encrypted(true),
+        is_secure(true),
+        key_id(NULL),
+        encrypt_buffer(NULL),
+        encrypt_length(0),
+        iv(NULL),
+        block_offset(0),
+        decrypt_buffer(NULL),
+        decrypt_buffer_length(0),
+        decrypt_buffer_offset(0),
+        subsample_flags(0),
+        is_video(true) {}
+  CdmDecryptionParameters(const KeyId* key, const uint8_t* encrypted_buffer,
+                          size_t encrypted_length,
+                          const std::vector<uint8_t>* initialization_vector,
+                          size_t offset, void* decrypted_buffer)
+      : is_encrypted(true),
+        is_secure(true),
+        key_id(key),
+        encrypt_buffer(encrypted_buffer),
+        encrypt_length(encrypted_length),
+        iv(initialization_vector),
+        block_offset(offset),
+        decrypt_buffer(decrypted_buffer),
+        decrypt_buffer_length(encrypted_length),
+        decrypt_buffer_offset(0),
+        subsample_flags(0),
+        is_video(true) {}
+};
+
+// forward class references
+class KeyMessage;
+class Request;
+class Key;
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_CORE_WV_CDM_TYPES_H_