Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit de0a90b0 authored by Kyle Zhang's avatar Kyle Zhang
Browse files

Create libmediadrmrkp as drm to irpc adapter library 

Bug: 286556950
Test: ./test_libmediadrmrkp
Change-Id: I25ff07026a62d613bdb415b983824ffaf61c97bb
parent d368c88a

drm/libmediadrmrkp/Android.bp

0 → 100644
+44 −0
Original line number Diff line number Diff line 
cc_library {

    name: "libmediadrmrkp",

    vendor_available: true,

    srcs: [

        "src/**/*.cpp",

    ],

    export_include_dirs: [

        "include"

    ],

    shared_libs: [

        "libbinder_ndk",

        "liblog",

        "android.hardware.drm-V1-ndk",

        "android.hardware.security.rkp-V3-ndk",

    ],

    defaults: [

        "keymint_use_latest_hal_aidl_ndk_shared",

    ],

    cflags: [

        "-Wall",

        "-Werror",

    ],

}



cc_binary {

    name: "test_libmediadrmrkp",

    srcs: [

        "test/*",

    ],

    shared_libs: [

        "libbinder_ndk",

        "liblog",

        "android.hardware.drm-V1-ndk",

        "android.hardware.security.rkp-V3-ndk",

    ],

    static_libs: [

        "libmediadrmrkp",

    ],

    vendor: true,

    cflags: [

        "-Wall",

        "-Werror",

    ],

}
 
 No newline at end of file

drm/libmediadrmrkp/include/DrmRemotelyProvisionedComponent.h

0 → 100644
+61 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2023 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.

 */



#ifndef DRM_RKP_COMPONENT_H_

#define DRM_RKP_COMPONENT_H_



#include <aidl/android/hardware/drm/IDrmPlugin.h>

#include <aidl/android/hardware/security/keymint/BnRemotelyProvisionedComponent.h>

#include <aidl/android/hardware/security/keymint/RpcHardwareInfo.h>



namespace android::mediadrm {



using ::aidl::android::hardware::drm::IDrmPlugin;

using ::aidl::android::hardware::security::keymint::BnRemotelyProvisionedComponent;

using ::aidl::android::hardware::security::keymint::DeviceInfo;

using ::aidl::android::hardware::security::keymint::MacedPublicKey;

using ::aidl::android::hardware::security::keymint::ProtectedData;

using ::aidl::android::hardware::security::keymint::RpcHardwareInfo;

using ::ndk::ScopedAStatus;



class DrmRemotelyProvisionedComponent : public BnRemotelyProvisionedComponent {

  public:

    DrmRemotelyProvisionedComponent(std::shared_ptr<IDrmPlugin> drm, std::string drmVendor,

                                    std::string drmDesc);

    ScopedAStatus getHardwareInfo(RpcHardwareInfo* info) override;



    ScopedAStatus generateEcdsaP256KeyPair(bool testMode, MacedPublicKey* macedPublicKey,

                                           std::vector<uint8_t>* privateKeyHandle) override;



    ScopedAStatus generateCertificateRequest(bool testMode,

                                             const std::vector<MacedPublicKey>& keysToSign,

                                             const std::vector<uint8_t>& endpointEncCertChain,

                                             const std::vector<uint8_t>& challenge,

                                             DeviceInfo* deviceInfo, ProtectedData* protectedData,

                                             std::vector<uint8_t>* keysToSignMac) override;



    ScopedAStatus generateCertificateRequestV2(const std::vector<MacedPublicKey>& keysToSign,

                                               const std::vector<uint8_t>& challenge,

                                               std::vector<uint8_t>* csr) override;



  private:

    std::shared_ptr<IDrmPlugin> mDrm;

    std::string mDrmVendor;

    std::string mDrmDesc;

};

}  // namespace android::mediadrm



#endif  // DRM_RKP_COMPONENT_H_
 
 No newline at end of file

drm/libmediadrmrkp/include/DrmRkpAdapter.h

0 → 100644
+31 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2023 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.

 */



#ifndef DRM_RKP_ADAPTER_H_

#define DRM_RKP_ADAPTER_H_



#include <aidl/android/hardware/security/keymint/BnRemotelyProvisionedComponent.h>

#include <map>

#include <string>



namespace android::mediadrm {

using IRemotelyProvisionedComponent =

        ::aidl::android::hardware::security::keymint::IRemotelyProvisionedComponent;

std::map<std::string, std::shared_ptr<IRemotelyProvisionedComponent>>

getDrmRemotelyProvisionedComponents();

}  // namespace android::mediadrm



#endif  // DRM_RKP_ADAPTER_H_
 
 No newline at end of file

drm/libmediadrmrkp/src/DrmRemotelyProvisionedComponent.cpp

0 → 100644
+70 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2023 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_TAG "DrmRemotelyProvisionedComponent"

#include "DrmRemotelyProvisionedComponent.h"

#include <log/log.h>



namespace android::mediadrm {

DrmRemotelyProvisionedComponent::DrmRemotelyProvisionedComponent(std::shared_ptr<IDrmPlugin> drm,

                                                                 std::string drmVendor,

                                                                 std::string drmDesc)

    : mDrm(std::move(drm)), mDrmVendor(std::move(drmVendor)), mDrmDesc(std::move(drmDesc)) {}

ScopedAStatus DrmRemotelyProvisionedComponent::getHardwareInfo(RpcHardwareInfo* info) {

    info->versionNumber = 3;

    info->rpcAuthorName = mDrmVendor;

    info->supportedEekCurve = RpcHardwareInfo::CURVE_NONE;

    info->supportedNumKeysInCsr = RpcHardwareInfo::MIN_SUPPORTED_NUM_KEYS_IN_CSR;

    info->uniqueId = mDrmDesc;

    return ScopedAStatus::ok();

}



ScopedAStatus DrmRemotelyProvisionedComponent::generateEcdsaP256KeyPair(bool, MacedPublicKey*,

                                                                        std::vector<uint8_t>*) {

    return ScopedAStatus(AStatus_fromServiceSpecificErrorWithMessage(

            IRemotelyProvisionedComponent::STATUS_REMOVED,

            "generateEcdsaP256KeyPair not supported."));

}



ScopedAStatus DrmRemotelyProvisionedComponent::generateCertificateRequest(

        bool, const std::vector<MacedPublicKey>&, const std::vector<uint8_t>&,

        const std::vector<uint8_t>&, DeviceInfo*, ProtectedData*, std::vector<uint8_t>*) {

    return ScopedAStatus(AStatus_fromServiceSpecificErrorWithMessage(

            IRemotelyProvisionedComponent::STATUS_REMOVED,

            "generateCertificateRequest not supported."));

}



ScopedAStatus DrmRemotelyProvisionedComponent::generateCertificateRequestV2(

        const std::vector<MacedPublicKey>&, const std::vector<uint8_t>& challenge,

        std::vector<uint8_t>* csr) {

    // extract csr using setPropertyByteArray/getPropertyByteArray

    auto status = mDrm->setPropertyByteArray("certificateSigningRequestChallenge", challenge);

    if (!status.isOk()) {

        ALOGE("setPropertyByteArray certificateSigningRequestChallenge failed. Details: [%s].",

              status.getDescription().c_str());

        return status;

    }



    status = mDrm->getPropertyByteArray("certificateSigningRequest", csr);

    if (!status.isOk()) {

        ALOGE("getPropertyByteArray certificateSigningRequest failed. Details: [%s].",

              status.getDescription().c_str());

        return status;

    }



    return ScopedAStatus::ok();

}

}  // namespace android::mediadrm
 
 No newline at end of file

drm/libmediadrmrkp/src/DrmRkpAdapter.cpp

0 → 100644
+91 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2023 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_TAG "DrmRkpAdapter"

#include "DrmRkpAdapter.h"

#include <aidl/android/hardware/drm/IDrmFactory.h>

#include <aidl/android/hardware/drm/IDrmPlugin.h>

#include <aidl/android/hardware/security/keymint/BnRemotelyProvisionedComponent.h>

#include <android/binder_manager.h>

#include <log/log.h>

#include "DrmRemotelyProvisionedComponent.h"



namespace android::mediadrm {

using CryptoSchemes = ::aidl::android::hardware::drm::CryptoSchemes;

using IDrmFactory = ::aidl::android::hardware::drm::IDrmFactory;

using IDrmPlugin = ::aidl::android::hardware::drm::IDrmPlugin;



std::map<std::string, std::shared_ptr<IRemotelyProvisionedComponent>>

getDrmRemotelyProvisionedComponents() {

    std::map<std::string, std::shared_ptr<IRemotelyProvisionedComponent>> comps;

    AServiceManager_forEachDeclaredInstance(

            IDrmFactory::descriptor, &comps, [](const char* instance, void* context) {

                auto fullName = std::string(IDrmFactory::descriptor) + "/" + std::string(instance);

                auto factory = IDrmFactory::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());

                CryptoSchemes schemes{};

                auto status = factory->getSupportedCryptoSchemes(&schemes);

                if (!status.isOk()) {

                    ALOGE("getSupportedCryptoSchemes failed.Detail: [%s].",

                          status.getDescription().c_str());

                    return;

                }



                if (schemes.uuids.empty()) {

                    ALOGW("IDrmFactory Instance [%s] has empty supported schemes",

                          fullName.c_str());

                    return;

                }



                std::shared_ptr<IDrmPlugin> mDrm;

                status = factory->createDrmPlugin(schemes.uuids[0], "DrmRkpAdapter", &mDrm);

                if (!status.isOk()) {

                    ALOGE("createDrmPlugin failed.Detail: [%s].", status.getDescription().c_str());

                    return;

                }



                std::string drmVendor;

                status = mDrm->getPropertyString("vendor", &drmVendor);

                if (!status.isOk()) {

                    ALOGE("mDrm->getPropertyString(\"vendor\") failed.Detail: [%s].",

                          status.getDescription().c_str());

                    return;

                }



                std::string drmDesc;

                status = mDrm->getPropertyString("description", &drmDesc);

                if (!status.isOk()) {

                    ALOGE("mDrm->getPropertyString(\"description\") failed.Detail: [%s].",

                          status.getDescription().c_str());

                    return;

                }



                std::string compName = "DrmRemotelyProvisionedComponent_" + std::string(instance);

                auto comps = static_cast<

                        std::map<std::string, std::shared_ptr<IRemotelyProvisionedComponent>>*>(

                        context);

                (*comps)[compName] = ::ndk::SharedRefBase::make<DrmRemotelyProvisionedComponent>(

                        mDrm, drmVendor, drmDesc);

            });

    return comps;

}

}  // namespace android::mediadrm
 
 No newline at end of file