widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Squashed commit of the following CDM changes:

Browse Source 
* Add additional parameters to CDM decryption API
  https://widevine-internal-review.googlesource.com/#/c/6500/

* Pass Length and Flags Parameters to Decrypt()
  https://widevine-internal-review.googlesource.com/#/c/6740/

* Remove core files from oemcrypto/mock
  https://widevine-internal-review.googlesource.com/#/c/6853/

Change-Id: I1c73f5454da20da99130b161543fb990e16e7130
This commit is contained in:
Jeff Tinker
2013-07-29 17:41:22 -07:00
parent 0190f99fb3
commit f4560f109f
24 changed files with 543 additions and 789 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
libwvdrmengine/cdm/core/include/cdm_engine.h
View File

@@ -85,16 +85,7 @@ class CdmEngine : public TimerHandler {
// Decryption and key related methods
// Accept encrypted buffer and return decrypted data.
virtual CdmResponseType Decrypt(const CdmSessionId& session_id,
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_offset,
bool is_video);
const CdmDecryptionParameters& parameters);
// Is the key known to any session?
virtual bool IsKeyValid(const KeyId& key_id);

6
libwvdrmengine/cdm/core/include/cdm_session.h
View File

@@ -59,11 +59,7 @@ class CdmSession {
CdmResponseType QueryKeyControlInfo(CdmQueryMap* key_info);
// Decrypt() - Accept encrypted buffer and return decrypted data.
CdmResponseType Decrypt(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_offset, bool is_video);
CdmResponseType Decrypt(const CdmDecryptionParameters& parameters);
// License renewal
// GenerateRenewalRequest() - Construct valid renewal request for the current

10
libwvdrmengine/cdm/core/include/crypto_session.h
View File

@@ -68,15 +68,7 @@ class CryptoSession {
// Media data path
bool SelectKey(const std::string& key_id);
CdmResponseType Decrypt(bool is_encrypted,
bool is_secure,
const uint8_t* encrypt_buffer,
size_t encrypt_length,
const std::vector<uint8_t>& iv,
size_t block_offset,
void* decrypt_buffer,
size_t decrypt_buffer_offset,
bool is_video);
CdmResponseType Decrypt(const CdmDecryptionParameters& parameters);
bool GetRandom(uint8_t* random_data, size_t data_length);

46
libwvdrmengine/cdm/core/include/wv_cdm_types.h
View File

@@ -41,7 +41,7 @@ enum CdmResponseType {
};
#define CORE_DISALLOW_COPY_AND_ASSIGN(TypeName) \
TypeName(const TypeName&); \
TypeName(const TypeName&); \
void operator=(const TypeName&)
enum CdmEventType {
@@ -55,6 +55,50 @@ enum CdmLicenseType {
kLicenseTypeRelease
};
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;

36
libwvdrmengine/cdm/core/src/cdm_engine.cpp
View File

@@ -458,26 +458,34 @@ CdmResponseType CdmEngine::ReleaseSecureStops(
CdmResponseType CdmEngine::Decrypt(
const CdmSessionId& session_id,
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_offset,
bool is_video) {
const CdmDecryptionParameters& parameters) {
if (parameters.key_id == NULL) {
LOGE("CdmEngine::Decrypt: no key_id");
return KEY_ERROR;
}
if (parameters.encrypt_buffer == NULL) {
LOGE("CdmEngine::Decrypt: no src encrypt buffer");
return KEY_ERROR;
}
if (parameters.iv == NULL) {
LOGE("CdmEngine::Decrypt: no iv");
return KEY_ERROR;
}
if (parameters.decrypt_buffer == NULL) {
LOGE("CdmEngine::Decrypt: no dest decrypt buffer");
return KEY_ERROR;
}
CdmSessionMap::iterator iter = sessions_.find(session_id);
if (iter == sessions_.end()) {
LOGW("CdmEngine::Decrypt: session_id not found = %s", session_id.c_str());
return KEY_ERROR;
}
return iter->second->Decrypt(is_encrypted, is_secure, key_id, encrypt_buffer,
encrypt_length, iv, block_offset,
decrypt_buffer, decrypt_buffer_offset,
is_video);
return iter->second->Decrypt(parameters);
}
bool CdmEngine::IsKeyValid(const KeyId& key_id) {

27
libwvdrmengine/cdm/core/src/cdm_session.cpp
View File

@@ -217,8 +217,15 @@ CdmResponseType CdmSession::QueryKeyStatus(CdmQueryMap* key_info) {
}
CdmResponseType CdmSession::QueryKeyControlInfo(CdmQueryMap* key_info) {
if (crypto_session_.get() == NULL || !crypto_session_->IsOpen())
if (crypto_session_.get() == NULL) {
LOGW("CdmSession::QueryKeyControlInfo: Invalid crypto session");
return UNKNOWN_ERROR;
}
if (!crypto_session_->IsOpen()) {
LOGW("CdmSession::QueryKeyControlInfo: Crypto session not open");
return UNKNOWN_ERROR;
}
std::stringstream ss;
ss << crypto_session_->oec_session_id();
@@ -234,28 +241,22 @@ CdmResponseType CdmSession::CancelKeyRequest() {
}
// Decrypt() - Accept encrypted buffer and return decrypted data.
CdmResponseType CdmSession::Decrypt(
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_offset, bool is_video) {
CdmResponseType CdmSession::Decrypt(const CdmDecryptionParameters& params) {
if (crypto_session_.get() == NULL || !crypto_session_->IsOpen())
return UNKNOWN_ERROR;
// Check if key needs to be selected
if (is_encrypted) {
if (key_id_.compare(key_id) != 0) {
if (crypto_session_->SelectKey(key_id)) {
key_id_ = key_id;
if (params.is_encrypted) {
if (key_id_.compare(*params.key_id) != 0) {
if (crypto_session_->SelectKey(*params.key_id)) {
key_id_ = *params.key_id;
} else {
return NEED_KEY;
}
}
}
return crypto_session_->Decrypt(
is_encrypted, is_secure, encrypt_buffer, encrypt_length, iv, block_offset,
decrypt_buffer, decrypt_buffer_offset, is_video);
return crypto_session_->Decrypt(params);
}
// License renewal

30
libwvdrmengine/cdm/core/src/crypto_session.cpp
View File

@@ -529,39 +529,41 @@ bool CryptoSession::GenerateSignature(const std::string& message, bool use_rsa,
return true;
}
CdmResponseType CryptoSession::Decrypt(
bool is_encrypted, bool is_secure, const uint8_t* encrypt_buffer,
size_t encrypt_length, const std::vector<uint8_t>& iv, size_t block_offset,
void* decrypt_buffer, size_t decrypt_buffer_offset, bool is_video) {
CdmResponseType CryptoSession::Decrypt(const CdmDecryptionParameters& params) {
if (!is_destination_buffer_type_valid_) {
if (!SetDestinationBufferType()) return UNKNOWN_ERROR;
}
OEMCrypto_DestBufferDesc buffer_descriptor;
buffer_descriptor.type =
is_secure ? destination_buffer_type_ : OEMCrypto_BufferType_Clear;
params.is_secure ? destination_buffer_type_ : OEMCrypto_BufferType_Clear;
switch (buffer_descriptor.type) {
case OEMCrypto_BufferType_Clear:
buffer_descriptor.buffer.clear.address =
static_cast<uint8_t*>(decrypt_buffer) + decrypt_buffer_offset;
buffer_descriptor.buffer.clear.max_length = encrypt_length;
static_cast<uint8_t*>(params.decrypt_buffer) + params.decrypt_buffer_offset;
buffer_descriptor.buffer.clear.max_length = params.decrypt_buffer_length;
break;
case OEMCrypto_BufferType_Secure:
buffer_descriptor.buffer.secure.handle = decrypt_buffer;
buffer_descriptor.buffer.secure.offset = decrypt_buffer_offset;
buffer_descriptor.buffer.secure.max_length = encrypt_length;
buffer_descriptor.buffer.secure.handle = params.decrypt_buffer;
buffer_descriptor.buffer.secure.offset = params.decrypt_buffer_offset;
buffer_descriptor.buffer.secure.max_length = params.decrypt_buffer_length;
break;
case OEMCrypto_BufferType_Direct:
buffer_descriptor.type = OEMCrypto_BufferType_Direct;
buffer_descriptor.buffer.direct.is_video = is_video;
buffer_descriptor.buffer.direct.is_video = params.is_video;
break;
}
OEMCryptoResult sts = OEMCrypto_DecryptCTR(
oec_session_id_, encrypt_buffer, encrypt_length, is_encrypted, &iv[0],
block_offset, &buffer_descriptor,
OEMCrypto_FirstSubsample | OEMCrypto_LastSubsample);
oec_session_id_,
params.encrypt_buffer,
params.encrypt_length,
params.is_encrypted,
&(*params.iv).front(),
params.block_offset,
&buffer_descriptor,
params.subsample_flags);
if (OEMCrypto_SUCCESS != sts) {
return UNKNOWN_ERROR;