cast_auth/mediadrm/DrmPlugin.cpp

#define LOG_TAG "castkey-DrmPlugin"

#include <utils/Log.h>
#include <dlfcn.h>
#include <fstream>
#include <vector>
#include <stdlib.h>

#include "Utils.h"
#include "DrmPlugin.h"
#include "SessionLibrary.h"

namespace aidl {
namespace android {
namespace hardware {
namespace drm {
namespace castkey {

using namespace castkeydrm;

DrmPlugin::DrmPlugin() {};
DrmPlugin::~DrmPlugin() {};

constexpr char CAST_CRT_FILE[] = "/mnt/vendor/persist/nest/cast_auth.crt";
constexpr char CAST_ICA_FILE[] = "/vendor/etc/cert-chain.crt";
constexpr unsigned char kSha1Prefix[] = {0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e,
                            0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14};
constexpr unsigned char kSha256Prefix[] = {0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60,
                              0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02,
                              0x01, 0x05, 0x00, 0x04, 0x20};
constexpr int kSHA1Length = 20;
constexpr int kSHA256Length = 32;
constexpr int DigestInfoPrefixesSize = 2;

struct DigestInfoPrefix {
    const unsigned char* bytes;
    size_t size;
    size_t hash_size;
};

// Array of DigestInfoPrefixes that are currently supported (SHA1 and SHA256).
const DigestInfoPrefix kDigestInfoPrefixes[] = {
    {kSha1Prefix, sizeof(kSha1Prefix), kSHA1Length},
    {kSha256Prefix, sizeof(kSha256Prefix), kSHA256Length},
};

// If we find a raw hash, prepend the appropriate DER prefix.
std::vector<uint8_t> adjustHash(const std::vector<uint8_t>& hash) {
    std::vector<uint8_t> adjusted_hash(hash);
    for (size_t i = 0; i < DigestInfoPrefixesSize; i++) {
        const DigestInfoPrefix& prefix = kDigestInfoPrefixes[i];
        if (hash.size() == prefix.hash_size) {
            adjusted_hash.insert(adjusted_hash.begin(), prefix.bytes,
                       &prefix.bytes[prefix.size]);
            break;
    }
  }
  return adjusted_hash;
}

std::vector<uint8_t> readBinaryFile(const std::string& file_path) {
    std::ifstream fin(file_path, std::ios::in | std::ios::binary);
    fin >> std::noskipws;
    std::vector<uint8_t> buffer((std::istream_iterator<uint8_t>(fin)),
                                std::istream_iterator<uint8_t>());
    return buffer;
}

::ndk::ScopedAStatus DrmPlugin::openSession(
        ::aidl::android::hardware::drm::SecurityLevel in_securityLevel,
        std::vector<uint8_t>* _aidl_return) {
    UNUSED(in_securityLevel);
    std::vector<uint8_t> sessionId = SessionLibrary::get()->createSession();
    *_aidl_return = sessionId;
    return toNdkScopedAStatus(Status::OK);
}

::ndk::ScopedAStatus DrmPlugin::closeSession(const std::vector<uint8_t>& in_sessionId) {
    if (in_sessionId.size() == 0) {
        return toNdkScopedAStatus(Status::BAD_VALUE);
    }
    SessionLibrary::get()->closeSession(in_sessionId);
    return toNdkScopedAStatus(Status::OK);
}

::ndk::ScopedAStatus DrmPlugin::getPropertyByteArray(const std::string& in_propertyName,
                                                     std::vector<uint8_t>* _aidl_return) {
    Status status = Status::OK;
    std::string name(in_propertyName.c_str());
    std::vector<uint8_t> value;
    if (name == "castcert") {
        std::vector<uint8_t> device_cert = readBinaryFile(CAST_CRT_FILE);
        std::vector<uint8_t> ica = readBinaryFile(CAST_ICA_FILE);
        value = std::move(device_cert);
        value.insert(value.end(), ica.begin(), ica.end());
    } else {
        status = Status::ERROR_DRM_CANNOT_HANDLE;
        ALOGE("Unsupported Property: %s", in_propertyName.c_str());
    }
    *_aidl_return = value;
    return toNdkScopedAStatus(status);
}

::ndk::ScopedAStatus DrmPlugin::signRSA(const std::vector<uint8_t>& in_sessionId,
                                          const std::string& in_algorithm,
                                          const std::vector<uint8_t>& in_message,
                                          const std::vector<uint8_t>& in_wrappedkey,
                                          std::vector<uint8_t>* _aidl_return) {
    if (in_sessionId.size() == 0 || in_message.size() == 0) {
        return toNdkScopedAStatus(Status::BAD_VALUE);
    }
    UNUSED(in_algorithm);
    UNUSED(in_wrappedkey);
    Status status = Status::ERROR_DRM_CANNOT_HANDLE;
    std::vector<uint8_t> signature;
    *_aidl_return = std::vector<uint8_t>();
    void* cast_auth_handle = ::dlopen("libcast_auth.so", RTLD_LAZY);
    if (!cast_auth_handle) {
        ALOGE("Fail to get TA for signing");
        return toNdkScopedAStatus(status);
    }
    typedef bool (*func_type)(const std::vector<uint8_t>&,
                              std::vector<uint8_t>*);
    func_type sign_hash_func =
        reinterpret_cast<func_type>(::dlsym(cast_auth_handle, "SignHash"));
    if (!sign_hash_func) {
        ALOGE("Fail to apply signing method");
        dlclose(cast_auth_handle);
        return toNdkScopedAStatus(status);
    }
    const std::vector<uint8_t> msg = adjustHash(in_message);
    int res = sign_hash_func(msg, &signature);
    dlclose(cast_auth_handle);
    if (res == 0) {
        *_aidl_return = signature;
        return toNdkScopedAStatus(Status::OK);
    }
    ALOGE("Get empty result from TA");
    return toNdkScopedAStatus(status);
}

::ndk::ScopedAStatus DrmPlugin::decrypt(const std::vector<uint8_t>& in_sessionId,
                             const std::vector<uint8_t>& in_keyId,
                             const std::vector<uint8_t>& in_input,
                             const std::vector<uint8_t>& in_iv,
                             std::vector<uint8_t>* _aidl_return) {
    UNUSED(in_sessionId);
    UNUSED(in_keyId);
    UNUSED(in_input);
    UNUSED(in_iv);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::encrypt(const std::vector<uint8_t>& in_sessionId,
                             const std::vector<uint8_t>& in_keyId,
                             const std::vector<uint8_t>& in_input,
                             const std::vector<uint8_t>& in_iv,
                             std::vector<uint8_t>* _aidl_return) {
    UNUSED(in_sessionId);
    UNUSED(in_keyId);
    UNUSED(in_input);
    UNUSED(in_iv);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::getHdcpLevels(
    ::aidl::android::hardware::drm::HdcpLevels* _aidl_return) {
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::getKeyRequest(
    const std::vector<uint8_t>& in_scope,
    const std::vector<uint8_t>& in_initData,
    const std::string& in_mimeType,
    ::aidl::android::hardware::drm::KeyType in_keyType,
    const std::vector<::aidl::android::hardware::drm::KeyValue>& in_optionalParameters,
    ::aidl::android::hardware::drm::KeyRequest* _aidl_return) {
    UNUSED(in_scope);
    UNUSED(in_initData);
    UNUSED(in_mimeType);
    UNUSED(in_keyType);
    UNUSED(in_optionalParameters);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::getLogMessages(
    std::vector<::aidl::android::hardware::drm::LogMessage>* _aidl_return) {
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::getMetrics(
    std::vector<::aidl::android::hardware::drm::DrmMetricGroup>* _aidl_return) {
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::getNumberOfSessions(
    ::aidl::android::hardware::drm::NumberOfSessions* _aidl_return) {
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::getOfflineLicenseKeySetIds(
    std::vector<::aidl::android::hardware::drm::KeySetId>* _aidl_return) {
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::getOfflineLicenseState(
    const ::aidl::android::hardware::drm::KeySetId& in_keySetId,
    ::aidl::android::hardware::drm::OfflineLicenseState* _aidl_return) {
    UNUSED(in_keySetId);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::getPropertyString(const std::string& in_propertyName,
                                       std::string* _aidl_return) {
    UNUSED(in_propertyName);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::getProvisionRequest(
    const std::string& in_certificateType,
    const std::string& in_certificateAuthority,
    ::aidl::android::hardware::drm::ProvisionRequest* _aidl_return) {
    UNUSED(in_certificateType);
    UNUSED(in_certificateAuthority);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::getSecureStop(
    const ::aidl::android::hardware::drm::SecureStopId& in_secureStopId,
    ::aidl::android::hardware::drm::SecureStop* _aidl_return) {
    UNUSED(in_secureStopId);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::getSecureStopIds(
    std::vector<::aidl::android::hardware::drm::SecureStopId>* _aidl_return) {
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::getSecureStops(
    std::vector<::aidl::android::hardware::drm::SecureStop>* _aidl_return) {
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::getSecurityLevel(
    const std::vector<uint8_t>& in_sessionId,
    ::aidl::android::hardware::drm::SecurityLevel* _aidl_return) {
    UNUSED(in_sessionId);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::provideKeyResponse(
    const std::vector<uint8_t>& in_scope,
    const std::vector<uint8_t>& in_response,
    ::aidl::android::hardware::drm::KeySetId* _aidl_return) {
    UNUSED(in_scope);
    UNUSED(in_response);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::provideProvisionResponse(
    const std::vector<uint8_t>& in_response,
    ::aidl::android::hardware::drm::ProvideProvisionResponseResult* _aidl_return) {
    UNUSED(in_response);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::queryKeyStatus(
    const std::vector<uint8_t>& in_sessionId,
    std::vector<::aidl::android::hardware::drm::KeyValue>* _aidl_return) {
    UNUSED(in_sessionId);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::releaseAllSecureStops() {
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::releaseSecureStop(
    const ::aidl::android::hardware::drm::SecureStopId& in_secureStopId) {
    UNUSED(in_secureStopId);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::releaseSecureStops(
    const ::aidl::android::hardware::drm::OpaqueData& in_ssRelease) {
    UNUSED(in_ssRelease);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::removeAllSecureStops() {
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::removeKeys(const std::vector<uint8_t>& in_sessionId) {
    UNUSED(in_sessionId);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::removeOfflineLicense(
    const ::aidl::android::hardware::drm::KeySetId& in_keySetId) {
    UNUSED(in_keySetId);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::removeSecureStop(
    const ::aidl::android::hardware::drm::SecureStopId& in_secureStopId) {
    UNUSED(in_secureStopId);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::requiresSecureDecoder(
    const std::string& in_mime,
    ::aidl::android::hardware::drm::SecurityLevel in_level,
    bool* _aidl_return) {
    UNUSED(in_mime);
    UNUSED(in_level);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::restoreKeys(
    const std::vector<uint8_t>& in_sessionId,
    const ::aidl::android::hardware::drm::KeySetId& in_keySetId) {
    UNUSED(in_sessionId);
    UNUSED(in_keySetId);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::setCipherAlgorithm(const std::vector<uint8_t>& in_sessionId,
                                        const std::string& in_algorithm) {
    UNUSED(in_sessionId);
    UNUSED(in_algorithm);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::setListener(
     const std::shared_ptr<::aidl::android::hardware::drm::IDrmPluginListener>&
         in_listener) {
    UNUSED(in_listener);
    return toNdkScopedAStatus(Status::OK);
}

::ndk::ScopedAStatus DrmPlugin::setMacAlgorithm(const std::vector<uint8_t>& in_sessionId,
                                     const std::string& in_algorithm) {
    UNUSED(in_sessionId);
    UNUSED(in_algorithm);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::setPlaybackId(const std::vector<uint8_t>& in_sessionId,
                                   const std::string& in_playbackId) {
    UNUSED(in_sessionId);
    UNUSED(in_playbackId);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::setPropertyByteArray(const std::string& in_propertyName,
                                          const std::vector<uint8_t>& in_value) {
    UNUSED(in_propertyName);
    UNUSED(in_value);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::setPropertyString(const std::string& in_propertyName,
                                       const std::string& in_value) {
    UNUSED(in_propertyName);
    UNUSED(in_value);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::sign(const std::vector<uint8_t>& in_sessionId,
                          const std::vector<uint8_t>& in_keyId,
                          const std::vector<uint8_t>& in_message,
                          std::vector<uint8_t>* _aidl_return) {
    UNUSED(in_sessionId);
    UNUSED(in_keyId);
    UNUSED(in_message);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}

::ndk::ScopedAStatus DrmPlugin::verify(const std::vector<uint8_t>& in_sessionId,
                            const std::vector<uint8_t>& in_keyId,
                            const std::vector<uint8_t>& in_message,
                            const std::vector<uint8_t>& in_signature,
                            bool* _aidl_return) {
    UNUSED(in_sessionId);
    UNUSED(in_keyId);
    UNUSED(in_message);
    UNUSED(in_signature);
    UNUSED(_aidl_return);
    return toNdkScopedAStatus(Status::ERROR_DRM_CANNOT_HANDLE);
}


}  // namespace castkey
}  // namespace drm
}  // namespace hardware
}  // namespace android
}  // namespace aidl