blob: a99b1d11897ee273efb30a03cfd66a28f6f065c7 [file] [log] [blame]
/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "DrmUtils"
#include <android/binder_manager.h>
#include <android/hardware/drm/1.0/ICryptoFactory.h>
#include <android/hardware/drm/1.0/ICryptoPlugin.h>
#include <android/hardware/drm/1.0/IDrmFactory.h>
#include <android/hardware/drm/1.0/IDrmPlugin.h>
#include <android/hardware/drm/1.1/ICryptoFactory.h>
#include <android/hardware/drm/1.1/IDrmFactory.h>
#include <android/hardware/drm/1.2/ICryptoFactory.h>
#include <android/hardware/drm/1.2/IDrmFactory.h>
#include <android/hardware/drm/1.3/ICryptoFactory.h>
#include <android/hardware/drm/1.3/IDrmFactory.h>
#include <android/hardware/drm/1.4/ICryptoFactory.h>
#include <android/hardware/drm/1.4/IDrmFactory.h>
#include <android/hidl/manager/1.2/IServiceManager.h>
#include <hidl/HidlSupport.h>
#include <json/json.h>
#include <cutils/properties.h>
#include <utils/Errors.h>
#include <utils/Log.h>
#include <utils/String16.h>
#include <mediadrm/CryptoHal.h>
#include <mediadrm/DrmHal.h>
#include <mediadrm/DrmUtils.h>
#include <mediadrm/ICrypto.h>
#include <mediadrm/IDrm.h>
#include <map>
#include <string>
using HServiceManager = ::android::hidl::manager::V1_2::IServiceManager;
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using namespace ::android::hardware::drm;
namespace android {
namespace DrmUtils {
namespace {
template <typename Hal, typename... Ts>
Hal* MakeObject(status_t* pstatus, Ts... args) {
status_t err = OK;
status_t& status = pstatus ? *pstatus : err;
auto obj = new Hal(args...);
status = obj->initCheck();
if (status != OK && status != NO_INIT) {
return NULL;
}
return obj;
}
template <typename Hal, typename V, typename M>
void MakeHidlFactories(const uint8_t uuid[16], V& factories, M& instances) {
sp<HServiceManager> serviceManager = HServiceManager::getService();
if (serviceManager == nullptr) {
LOG2BE("Failed to get service manager");
return;
}
serviceManager->listManifestByInterface(
Hal::descriptor, [&](const hidl_vec<hidl_string>& registered) {
for (const auto& instance : registered) {
auto factory = Hal::getService(instance);
if (factory != nullptr) {
instances[instance.c_str()] = Hal::descriptor;
if (!uuid) {
factories.push_back(factory);
continue;
}
auto supported = factory->isCryptoSchemeSupported(uuid);
if (!supported.isOk()) {
LOG2BE(uuid, "isCryptoSchemeSupported txn failed: %s",
supported.description().c_str());
continue;
}
if (supported) {
factories.push_back(factory);
}
}
}
});
}
template <typename Hal, typename V>
void MakeHidlFactories(const uint8_t uuid[16], V& factories) {
std::map<std::string, std::string> instances;
MakeHidlFactories<Hal>(uuid, factories, instances);
}
hidl_vec<uint8_t> toHidlVec(const void* ptr, size_t size) {
hidl_vec<uint8_t> vec(size);
if (ptr != nullptr) {
memcpy(vec.data(), ptr, size);
}
return vec;
}
hidl_array<uint8_t, 16> toHidlArray16(const uint8_t* ptr) {
if (ptr == nullptr) {
return hidl_array<uint8_t, 16>();
}
return hidl_array<uint8_t, 16>(ptr);
}
sp<::V1_0::IDrmPlugin> MakeDrmPlugin(const sp<::V1_0::IDrmFactory>& factory, const uint8_t uuid[16],
const char* appPackageName) {
sp<::V1_0::IDrmPlugin> plugin;
auto err = factory->createPlugin(
toHidlArray16(uuid), hidl_string(appPackageName),
[&](::V1_0::Status status, const sp<::V1_0::IDrmPlugin>& hPlugin) {
if (status != ::V1_0::Status::OK) {
LOG2BE(uuid, "MakeDrmPlugin failed: %d", status);
return;
}
plugin = hPlugin;
});
if (err.isOk()) {
return plugin;
} else {
LOG2BE(uuid, "MakeDrmPlugin txn failed: %s", err.description().c_str());
return nullptr;
}
}
sp<::V1_0::ICryptoPlugin> MakeCryptoPlugin(const sp<::V1_0::ICryptoFactory>& factory,
const uint8_t uuid[16], const void* initData,
size_t initDataSize) {
sp<::V1_0::ICryptoPlugin> plugin;
auto err = factory->createPlugin(
toHidlArray16(uuid), toHidlVec(initData, initDataSize),
[&](::V1_0::Status status, const sp<::V1_0::ICryptoPlugin>& hPlugin) {
if (status != ::V1_0::Status::OK) {
LOG2BE(uuid, "MakeCryptoPlugin failed: %d", status);
return;
}
plugin = hPlugin;
});
if (err.isOk()) {
return plugin;
} else {
LOG2BE(uuid, "MakeCryptoPlugin txn failed: %s", err.description().c_str());
return nullptr;
}
}
} // namespace
bool UseDrmService() {
return property_get_bool("mediadrm.use_mediadrmserver", true);
}
std::vector<std::shared_ptr<IDrmFactoryAidl>> makeDrmFactoriesAidl() {
std::vector<std::shared_ptr<IDrmFactoryAidl>> factories;
AServiceManager_forEachDeclaredInstance(
IDrmFactoryAidl::descriptor, static_cast<void*>(&factories),
[](const char* instance, void* context) {
auto fullName = std::string(IDrmFactoryAidl::descriptor) + "/" + std::string(instance);
auto factory = IDrmFactoryAidl::fromBinder(
::ndk::SpAIBinder(AServiceManager_waitForService(fullName.c_str())));
if (factory == nullptr) {
ALOGE("not found IDrmFactory. Instance name:[%s]", fullName.c_str());
return;
}
ALOGI("found IDrmFactory. Instance name:[%s]", fullName.c_str());
static_cast<std::vector<std::shared_ptr<IDrmFactoryAidl>>*>(context)->emplace_back(
factory);
});
return factories;
}
sp<IDrm> MakeDrm(IDrmFrontend frontend, status_t* pstatus) {
return MakeObject<DrmMetricsLogger>(pstatus, frontend);
}
sp<ICrypto> MakeCrypto(status_t* pstatus) {
return MakeObject<CryptoHal>(pstatus);
}
std::vector<sp<::V1_0::IDrmFactory>> MakeDrmFactories(const uint8_t uuid[16]) {
std::vector<sp<::V1_0::IDrmFactory>> drmFactories;
std::map<std::string, std::string> instances;
MakeHidlFactories<::V1_0::IDrmFactory>(uuid, drmFactories, instances);
MakeHidlFactories<::V1_1::IDrmFactory>(uuid, drmFactories, instances);
MakeHidlFactories<::V1_2::IDrmFactory>(uuid, drmFactories, instances);
MakeHidlFactories<::V1_3::IDrmFactory>(uuid, drmFactories, instances);
MakeHidlFactories<::V1_4::IDrmFactory>(uuid, drmFactories, instances);
for (auto const& entry : instances) {
LOG2BI("found instance=%s version=%s", entry.first.c_str(), entry.second.c_str());
}
return drmFactories;
}
std::vector<sp<::V1_0::IDrmPlugin>> MakeDrmPlugins(const uint8_t uuid[16],
const char* appPackageName) {
std::vector<sp<::V1_0::IDrmPlugin>> plugins;
for (const auto& factory : MakeDrmFactories(uuid)) {
plugins.push_back(MakeDrmPlugin(factory, uuid, appPackageName));
}
return plugins;
}
std::vector<sp<::V1_0::ICryptoFactory>> MakeCryptoFactories(const uint8_t uuid[16]) {
std::vector<sp<::V1_0::ICryptoFactory>> cryptoFactories;
MakeHidlFactories<::V1_0::ICryptoFactory>(uuid, cryptoFactories);
MakeHidlFactories<::V1_1::ICryptoFactory>(uuid, cryptoFactories);
MakeHidlFactories<::V1_2::ICryptoFactory>(uuid, cryptoFactories);
MakeHidlFactories<::V1_3::ICryptoFactory>(uuid, cryptoFactories);
MakeHidlFactories<::V1_4::ICryptoFactory>(uuid, cryptoFactories);
return cryptoFactories;
}
std::vector<sp<::V1_0::ICryptoPlugin>> MakeCryptoPlugins(const uint8_t uuid[16],
const void* initData,
size_t initDataSize) {
std::vector<sp<::V1_0::ICryptoPlugin>> plugins;
for (const auto& factory : MakeCryptoFactories(uuid)) {
plugins.push_back(MakeCryptoPlugin(factory, uuid, initData, initDataSize));
}
return plugins;
}
status_t toStatusT_1_4(::V1_4::Status status) {
switch (status) {
case ::V1_4::Status::OK:
return OK;
case ::V1_4::Status::BAD_VALUE:
return BAD_VALUE;
case ::V1_4::Status::ERROR_DRM_CANNOT_HANDLE:
return ERROR_DRM_CANNOT_HANDLE;
case ::V1_4::Status::ERROR_DRM_DECRYPT:
return ERROR_DRM_DECRYPT;
case ::V1_4::Status::ERROR_DRM_DEVICE_REVOKED:
return ERROR_DRM_DEVICE_REVOKED;
case ::V1_4::Status::ERROR_DRM_FRAME_TOO_LARGE:
return ERROR_DRM_FRAME_TOO_LARGE;
case ::V1_4::Status::ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION:
return ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION;
case ::V1_4::Status::ERROR_DRM_INSUFFICIENT_SECURITY:
return ERROR_DRM_INSUFFICIENT_SECURITY;
case ::V1_4::Status::ERROR_DRM_INVALID_STATE:
return ERROR_DRM_INVALID_STATE;
case ::V1_4::Status::ERROR_DRM_LICENSE_EXPIRED:
return ERROR_DRM_LICENSE_EXPIRED;
case ::V1_4::Status::ERROR_DRM_NO_LICENSE:
return ERROR_DRM_NO_LICENSE;
case ::V1_4::Status::ERROR_DRM_NOT_PROVISIONED:
return ERROR_DRM_NOT_PROVISIONED;
case ::V1_4::Status::ERROR_DRM_RESOURCE_BUSY:
return ERROR_DRM_RESOURCE_BUSY;
case ::V1_4::Status::ERROR_DRM_RESOURCE_CONTENTION:
return ERROR_DRM_RESOURCE_CONTENTION;
case ::V1_4::Status::ERROR_DRM_SESSION_LOST_STATE:
return ERROR_DRM_SESSION_LOST_STATE;
case ::V1_4::Status::ERROR_DRM_SESSION_NOT_OPENED:
return ERROR_DRM_SESSION_NOT_OPENED;
// New in S / drm@1.4:
case ::V1_4::Status::CANNOT_DECRYPT_ZERO_SUBSAMPLES:
return ERROR_DRM_ZERO_SUBSAMPLES;
case ::V1_4::Status::CRYPTO_LIBRARY_ERROR:
return ERROR_DRM_CRYPTO_LIBRARY;
case ::V1_4::Status::GENERAL_OEM_ERROR:
return ERROR_DRM_GENERIC_OEM;
case ::V1_4::Status::GENERAL_PLUGIN_ERROR:
return ERROR_DRM_GENERIC_PLUGIN;
case ::V1_4::Status::INIT_DATA_INVALID:
return ERROR_DRM_INIT_DATA;
case ::V1_4::Status::KEY_NOT_LOADED:
return ERROR_DRM_KEY_NOT_LOADED;
case ::V1_4::Status::LICENSE_PARSE_ERROR:
return ERROR_DRM_LICENSE_PARSE;
case ::V1_4::Status::LICENSE_POLICY_ERROR:
return ERROR_DRM_LICENSE_POLICY;
case ::V1_4::Status::LICENSE_RELEASE_ERROR:
return ERROR_DRM_LICENSE_RELEASE;
case ::V1_4::Status::LICENSE_REQUEST_REJECTED:
return ERROR_DRM_LICENSE_REQUEST_REJECTED;
case ::V1_4::Status::LICENSE_RESTORE_ERROR:
return ERROR_DRM_LICENSE_RESTORE;
case ::V1_4::Status::LICENSE_STATE_ERROR:
return ERROR_DRM_LICENSE_STATE;
case ::V1_4::Status::MALFORMED_CERTIFICATE:
return ERROR_DRM_CERTIFICATE_MALFORMED;
case ::V1_4::Status::MEDIA_FRAMEWORK_ERROR:
return ERROR_DRM_MEDIA_FRAMEWORK;
case ::V1_4::Status::MISSING_CERTIFICATE:
return ERROR_DRM_CERTIFICATE_MISSING;
case ::V1_4::Status::PROVISIONING_CERTIFICATE_ERROR:
return ERROR_DRM_PROVISIONING_CERTIFICATE;
case ::V1_4::Status::PROVISIONING_CONFIGURATION_ERROR:
return ERROR_DRM_PROVISIONING_CONFIG;
case ::V1_4::Status::PROVISIONING_PARSE_ERROR:
return ERROR_DRM_PROVISIONING_PARSE;
case ::V1_4::Status::PROVISIONING_REQUEST_REJECTED:
return ERROR_DRM_PROVISIONING_REQUEST_REJECTED;
case ::V1_4::Status::RETRYABLE_PROVISIONING_ERROR:
return ERROR_DRM_PROVISIONING_RETRY;
case ::V1_4::Status::SECURE_STOP_RELEASE_ERROR:
return ERROR_DRM_SECURE_STOP_RELEASE;
case ::V1_4::Status::STORAGE_READ_FAILURE:
return ERROR_DRM_STORAGE_READ;
case ::V1_4::Status::STORAGE_WRITE_FAILURE:
return ERROR_DRM_STORAGE_WRITE;
case ::V1_4::Status::ERROR_DRM_UNKNOWN:
default:
return ERROR_DRM_UNKNOWN;
}
return ERROR_DRM_UNKNOWN;
}
namespace {
char logPriorityToChar(::V1_4::LogPriority priority) {
char p = 'U';
switch (priority) {
case ::V1_4::LogPriority::VERBOSE:
p = 'V';
break;
case ::V1_4::LogPriority::DEBUG:
p = 'D';
break;
case ::V1_4::LogPriority::INFO:
p = 'I';
break;
case ::V1_4::LogPriority::WARN:
p = 'W';
break;
case ::V1_4::LogPriority::ERROR:
p = 'E';
break;
case ::V1_4::LogPriority::FATAL:
p = 'F';
break;
default:
p = 'U';
break;
}
return p;
}
} // namespace
std::string GetExceptionMessage(const DrmStatus &err, const char* defaultMsg,
const Vector<::V1_4::LogMessage>& logs) {
std::string ruler("==============================");
std::string header("Beginning of DRM Plugin Log");
std::string footer("End of DRM Plugin Log");
std::string msg(err.getErrorMessage());
String8 msg8;
if (!msg.empty()) {
msg8 += msg.c_str();
msg8 += ": ";
} else if (defaultMsg) {
msg8 += defaultMsg;
msg8 += ": ";
}
msg8 += StrCryptoError(err).c_str();
msg8 += String8::format("\ncdm err: %d, oem err: %d, ctx: %d",
err.getCdmErr(), err.getOemErr(), err.getContext());
msg8 += String8::format("\n%s %s %s", ruler.c_str(), header.c_str(), ruler.c_str());
for (auto log : logs) {
time_t seconds = log.timeMs / 1000;
int ms = log.timeMs % 1000;
char buf[64] = {0};
std::string timeStr = "00-00 00:00:00";
if (strftime(buf, sizeof buf, "%m-%d %H:%M:%S", std::localtime(&seconds))) {
timeStr = buf;
}
char p = logPriorityToChar(log.priority);
msg8 += String8::format("\n %s.%03d %c %s", timeStr.c_str(), ms, p, log.message.c_str());
}
msg8 += String8::format("\n%s %s %s", ruler.c_str(), footer.c_str(), ruler.c_str());
return msg8.c_str();
}
void LogBuffer::addLog(const ::V1_4::LogMessage& log) {
std::unique_lock<std::mutex> lock(mMutex);
mBuffer.push_back(log);
while (mBuffer.size() > MAX_CAPACITY) {
mBuffer.pop_front();
}
}
Vector<::V1_4::LogMessage> LogBuffer::getLogs() {
std::unique_lock<std::mutex> lock(mMutex);
Vector<::V1_4::LogMessage> logs;
for (auto log : mBuffer) {
logs.push_back(log);
}
return logs;
}
DrmStatus statusAidlToDrmStatus(::ndk::ScopedAStatus& statusAidl) {
if (statusAidl.isOk()) return OK;
if (statusAidl.getExceptionCode() != EX_SERVICE_SPECIFIC) return DEAD_OBJECT;
auto astatus = static_cast<StatusAidl>(statusAidl.getServiceSpecificError());
status_t status{};
switch (astatus) {
case StatusAidl::OK:
status = OK;
break;
case StatusAidl::BAD_VALUE:
status = BAD_VALUE;
break;
case StatusAidl::ERROR_DRM_CANNOT_HANDLE:
status = ERROR_DRM_CANNOT_HANDLE;
break;
case StatusAidl::ERROR_DRM_DECRYPT:
status = ERROR_DRM_DECRYPT;
break;
case StatusAidl::ERROR_DRM_DEVICE_REVOKED:
status = ERROR_DRM_DEVICE_REVOKED;
break;
case StatusAidl::ERROR_DRM_FRAME_TOO_LARGE:
status = ERROR_DRM_FRAME_TOO_LARGE;
break;
case StatusAidl::ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION:
status = ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION;
break;
case StatusAidl::ERROR_DRM_INSUFFICIENT_SECURITY:
status = ERROR_DRM_INSUFFICIENT_SECURITY;
break;
case StatusAidl::ERROR_DRM_INVALID_STATE:
status = ERROR_DRM_INVALID_STATE;
break;
case StatusAidl::ERROR_DRM_LICENSE_EXPIRED:
status = ERROR_DRM_LICENSE_EXPIRED;
break;
case StatusAidl::ERROR_DRM_NO_LICENSE:
status = ERROR_DRM_NO_LICENSE;
break;
case StatusAidl::ERROR_DRM_NOT_PROVISIONED:
status = ERROR_DRM_NOT_PROVISIONED;
break;
case StatusAidl::ERROR_DRM_RESOURCE_BUSY:
status = ERROR_DRM_RESOURCE_BUSY;
break;
case StatusAidl::ERROR_DRM_RESOURCE_CONTENTION:
status = ERROR_DRM_RESOURCE_CONTENTION;
break;
case StatusAidl::ERROR_DRM_SESSION_LOST_STATE:
status = ERROR_DRM_SESSION_LOST_STATE;
break;
case StatusAidl::ERROR_DRM_SESSION_NOT_OPENED:
status = ERROR_DRM_SESSION_NOT_OPENED;
break;
// New in S / drm@1.4:
case StatusAidl::CANNOT_DECRYPT_ZERO_SUBSAMPLES:
status = ERROR_DRM_ZERO_SUBSAMPLES;
break;
case StatusAidl::CRYPTO_LIBRARY_ERROR:
status = ERROR_DRM_CRYPTO_LIBRARY;
break;
case StatusAidl::GENERAL_OEM_ERROR:
status = ERROR_DRM_GENERIC_OEM;
break;
case StatusAidl::GENERAL_PLUGIN_ERROR:
status = ERROR_DRM_GENERIC_PLUGIN;
break;
case StatusAidl::INIT_DATA_INVALID:
status = ERROR_DRM_INIT_DATA;
break;
case StatusAidl::KEY_NOT_LOADED:
status = ERROR_DRM_KEY_NOT_LOADED;
break;
case StatusAidl::LICENSE_PARSE_ERROR:
status = ERROR_DRM_LICENSE_PARSE;
break;
case StatusAidl::LICENSE_POLICY_ERROR:
status = ERROR_DRM_LICENSE_POLICY;
break;
case StatusAidl::LICENSE_RELEASE_ERROR:
status = ERROR_DRM_LICENSE_RELEASE;
break;
case StatusAidl::LICENSE_REQUEST_REJECTED:
status = ERROR_DRM_LICENSE_REQUEST_REJECTED;
break;
case StatusAidl::LICENSE_RESTORE_ERROR:
status = ERROR_DRM_LICENSE_RESTORE;
break;
case StatusAidl::LICENSE_STATE_ERROR:
status = ERROR_DRM_LICENSE_STATE;
break;
case StatusAidl::MALFORMED_CERTIFICATE:
status = ERROR_DRM_CERTIFICATE_MALFORMED;
break;
case StatusAidl::MEDIA_FRAMEWORK_ERROR:
status = ERROR_DRM_MEDIA_FRAMEWORK;
break;
case StatusAidl::MISSING_CERTIFICATE:
status = ERROR_DRM_CERTIFICATE_MISSING;
break;
case StatusAidl::PROVISIONING_CERTIFICATE_ERROR:
status = ERROR_DRM_PROVISIONING_CERTIFICATE;
break;
case StatusAidl::PROVISIONING_CONFIGURATION_ERROR:
status = ERROR_DRM_PROVISIONING_CONFIG;
break;
case StatusAidl::PROVISIONING_PARSE_ERROR:
status = ERROR_DRM_PROVISIONING_PARSE;
break;
case StatusAidl::PROVISIONING_REQUEST_REJECTED:
status = ERROR_DRM_PROVISIONING_REQUEST_REJECTED;
break;
case StatusAidl::RETRYABLE_PROVISIONING_ERROR:
status = ERROR_DRM_PROVISIONING_RETRY;
break;
case StatusAidl::SECURE_STOP_RELEASE_ERROR:
status = ERROR_DRM_SECURE_STOP_RELEASE;
break;
case StatusAidl::STORAGE_READ_FAILURE:
status = ERROR_DRM_STORAGE_READ;
break;
case StatusAidl::STORAGE_WRITE_FAILURE:
status = ERROR_DRM_STORAGE_WRITE;
break;
case StatusAidl::ERROR_DRM_UNKNOWN:
default:
status = ERROR_DRM_UNKNOWN;
break;
}
return DrmStatus(status, statusAidl.getMessage());
}
LogBuffer gLogBuf;
} // namespace DrmUtils
} // namespace android