Home | History | Annotate | Download | only in libmediadrm 
      1 /*
      2  * Copyright (C) 2017 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 //#define LOG_NDEBUG 0
     18 #define LOG_TAG "CryptoHal"
     19 #include <utils/Log.h>
     20 
     21 #include <android/hardware/drm/1.0/types.h>
     22 #include <android/hidl/manager/1.0/IServiceManager.h>
     23 
     24 #include <binder/IMemory.h>
     25 #include <cutils/native_handle.h>
     26 #include <media/CryptoHal.h>
     27 #include <media/hardware/CryptoAPI.h>
     28 #include <media/stagefright/foundation/ADebug.h>
     29 #include <media/stagefright/foundation/AString.h>
     30 #include <media/stagefright/foundation/hexdump.h>
     31 #include <media/stagefright/MediaErrors.h>
     32 
     33 using ::android::hardware::drm::V1_0::BufferType;
     34 using ::android::hardware::drm::V1_0::DestinationBuffer;
     35 using ::android::hardware::drm::V1_0::ICryptoFactory;
     36 using ::android::hardware::drm::V1_0::ICryptoPlugin;
     37 using ::android::hardware::drm::V1_0::Mode;
     38 using ::android::hardware::drm::V1_0::Pattern;
     39 using ::android::hardware::drm::V1_0::SharedBuffer;
     40 using ::android::hardware::drm::V1_0::Status;
     41 using ::android::hardware::drm::V1_0::SubSample;
     42 using ::android::hardware::hidl_array;
     43 using ::android::hardware::hidl_handle;
     44 using ::android::hardware::hidl_memory;
     45 using ::android::hardware::hidl_string;
     46 using ::android::hardware::hidl_vec;
     47 using ::android::hardware::Return;
     48 using ::android::hardware::Void;
     49 using ::android::hidl::manager::V1_0::IServiceManager;
     50 using ::android::sp;
     51 
     52 
     53 namespace android {
     54 
     55 static status_t toStatusT(Status status) {
     56     switch (status) {
     57     case Status::OK:
     58         return OK;
     59     case Status::ERROR_DRM_NO_LICENSE:
     60         return ERROR_DRM_NO_LICENSE;
     61     case Status::ERROR_DRM_LICENSE_EXPIRED:
     62         return ERROR_DRM_LICENSE_EXPIRED;
     63     case Status::ERROR_DRM_RESOURCE_BUSY:
     64         return ERROR_DRM_RESOURCE_BUSY;
     65     case Status::ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION:
     66         return ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION;
     67     case Status::ERROR_DRM_SESSION_NOT_OPENED:
     68         return ERROR_DRM_SESSION_NOT_OPENED;
     69     case Status::ERROR_DRM_CANNOT_HANDLE:
     70         return ERROR_DRM_CANNOT_HANDLE;
     71     case Status::ERROR_DRM_DECRYPT:
     72         return ERROR_DRM_DECRYPT;
     73     default:
     74         return UNKNOWN_ERROR;
     75     }
     76 }
     77 
     78 
     79 static hidl_vec<uint8_t> toHidlVec(const Vector<uint8_t> &vector) {
     80     hidl_vec<uint8_t> vec;
     81     vec.setToExternal(const_cast<uint8_t *>(vector.array()), vector.size());
     82     return vec;
     83 }
     84 
     85 static hidl_vec<uint8_t> toHidlVec(const void *ptr, size_t size) {
     86     hidl_vec<uint8_t> vec;
     87     vec.resize(size);
     88     memcpy(vec.data(), ptr, size);
     89     return vec;
     90 }
     91 
     92 static hidl_array<uint8_t, 16> toHidlArray16(const uint8_t *ptr) {
     93     if (!ptr) {
     94         return hidl_array<uint8_t, 16>();
     95     }
     96     return hidl_array<uint8_t, 16>(ptr);
     97 }
     98 
     99 
    100 static String8 toString8(hidl_string hString) {
    101     return String8(hString.c_str());
    102 }
    103 
    104 
    105 CryptoHal::CryptoHal()
    106     : mFactories(makeCryptoFactories()),
    107       mInitCheck((mFactories.size() == 0) ? ERROR_UNSUPPORTED : NO_INIT),
    108       mNextBufferId(0),
    109       mHeapSeqNum(0) {
    110 }
    111 
    112 CryptoHal::~CryptoHal() {
    113 }
    114 
    115 Vector<sp<ICryptoFactory>> CryptoHal::makeCryptoFactories() {
    116     Vector<sp<ICryptoFactory>> factories;
    117 
    118     auto manager = ::IServiceManager::getService();
    119     if (manager != NULL) {
    120         manager->listByInterface(ICryptoFactory::descriptor,
    121                 [&factories](const hidl_vec<hidl_string> &registered) {
    122                     for (const auto &instance : registered) {
    123                         auto factory = ICryptoFactory::getService(instance);
    124                         if (factory != NULL) {
    125                             factories.push_back(factory);
    126                             ALOGI("makeCryptoFactories: factory instance %s is %s",
    127                                     instance.c_str(),
    128                                     factory->isRemote() ? "Remote" : "Not Remote");
    129                         }
    130                     }
    131                 }
    132             );
    133     }
    134 
    135     if (factories.size() == 0) {
    136         // must be in passthrough mode, load the default passthrough service
    137         auto passthrough = ICryptoFactory::getService();
    138         if (passthrough != NULL) {
    139             ALOGI("makeCryptoFactories: using default crypto instance");
    140             factories.push_back(passthrough);
    141         } else {
    142             ALOGE("Failed to find any crypto factories");
    143         }
    144     }
    145     return factories;
    146 }
    147 
    148 sp<ICryptoPlugin> CryptoHal::makeCryptoPlugin(const sp<ICryptoFactory>& factory,
    149         const uint8_t uuid[16], const void *initData, size_t initDataSize) {
    150 
    151     sp<ICryptoPlugin> plugin;
    152     Return<void> hResult = factory->createPlugin(toHidlArray16(uuid),
    153             toHidlVec(initData, initDataSize),
    154             [&](Status status, const sp<ICryptoPlugin>& hPlugin) {
    155                 if (status != Status::OK) {
    156                     ALOGE("Failed to make crypto plugin");
    157                     return;
    158                 }
    159                 plugin = hPlugin;
    160             }
    161         );
    162     return plugin;
    163 }
    164 
    165 
    166 status_t CryptoHal::initCheck() const {
    167     return mInitCheck;
    168 }
    169 
    170 
    171 bool CryptoHal::isCryptoSchemeSupported(const uint8_t uuid[16]) {
    172     Mutex::Autolock autoLock(mLock);
    173 
    174     for (size_t i = 0; i < mFactories.size(); i++) {
    175         if (mFactories[i]->isCryptoSchemeSupported(uuid)) {
    176             return true;
    177         }
    178     }
    179     return false;
    180 }
    181 
    182 status_t CryptoHal::createPlugin(const uint8_t uuid[16], const void *data,
    183         size_t size) {
    184     Mutex::Autolock autoLock(mLock);
    185 
    186     for (size_t i = 0; i < mFactories.size(); i++) {
    187         if (mFactories[i]->isCryptoSchemeSupported(uuid)) {
    188             mPlugin = makeCryptoPlugin(mFactories[i], uuid, data, size);
    189         }
    190     }
    191 
    192     if (mPlugin == NULL) {
    193         mInitCheck = ERROR_UNSUPPORTED;
    194     } else {
    195         mInitCheck = OK;
    196     }
    197 
    198     return mInitCheck;
    199 }
    200 
    201 status_t CryptoHal::destroyPlugin() {
    202     Mutex::Autolock autoLock(mLock);
    203 
    204     if (mInitCheck != OK) {
    205         return mInitCheck;
    206     }
    207 
    208     mPlugin.clear();
    209     return OK;
    210 }
    211 
    212 bool CryptoHal::requiresSecureDecoderComponent(const char *mime) const {
    213     Mutex::Autolock autoLock(mLock);
    214 
    215     if (mInitCheck != OK) {
    216         return mInitCheck;
    217     }
    218 
    219     return mPlugin->requiresSecureDecoderComponent(hidl_string(mime));
    220 }
    221 
    222 
    223 /**
    224  * If the heap base isn't set, get the heap base from the IMemory
    225  * and send it to the HAL so it can map a remote heap of the same
    226  * size.  Once the heap base is established, shared memory buffers
    227  * are sent by providing an offset into the heap and a buffer size.
    228  */
    229 int32_t CryptoHal::setHeapBase(const sp<IMemoryHeap>& heap) {
    230     if (heap == NULL) {
    231         ALOGE("setHeapBase(): heap is NULL");
    232         return -1;
    233     }
    234     native_handle_t* nativeHandle = native_handle_create(1, 0);
    235     if (!nativeHandle) {
    236         ALOGE("setHeapBase(), failed to create native handle");
    237         return -1;
    238     }
    239 
    240     Mutex::Autolock autoLock(mLock);
    241 
    242     int32_t seqNum = mHeapSeqNum++;
    243     int fd = heap->getHeapID();
    244     nativeHandle->data[0] = fd;
    245     auto hidlHandle = hidl_handle(nativeHandle);
    246     auto hidlMemory = hidl_memory("ashmem", hidlHandle, heap->getSize());
    247     mHeapBases.add(seqNum, mNextBufferId);
    248     Return<void> hResult = mPlugin->setSharedBufferBase(hidlMemory, mNextBufferId++);
    249     ALOGE_IF(!hResult.isOk(), "setSharedBufferBase(): remote call failed");
    250     return seqNum;
    251 }
    252 
    253 void CryptoHal::clearHeapBase(int32_t seqNum) {
    254     Mutex::Autolock autoLock(mLock);
    255 
    256     mHeapBases.removeItem(seqNum);
    257 }
    258 
    259 status_t CryptoHal::toSharedBuffer(const sp<IMemory>& memory, int32_t seqNum, ::SharedBuffer* buffer) {
    260     ssize_t offset;
    261     size_t size;
    262 
    263     if (memory == NULL && buffer == NULL) {
    264         return UNEXPECTED_NULL;
    265     }
    266 
    267     sp<IMemoryHeap> heap = memory->getMemory(&offset, &size);
    268     if (heap == NULL) {
    269         return UNEXPECTED_NULL;
    270     }
    271 
    272     // memory must be in the declared heap
    273     CHECK(mHeapBases.indexOfKey(seqNum) >= 0);
    274 
    275     buffer->bufferId = mHeapBases.valueFor(seqNum);
    276     buffer->offset = offset >= 0 ? offset : 0;
    277     buffer->size = size;
    278     return OK;
    279 }
    280 
    281 ssize_t CryptoHal::decrypt(const uint8_t keyId[16], const uint8_t iv[16],
    282         CryptoPlugin::Mode mode, const CryptoPlugin::Pattern &pattern,
    283         const ICrypto::SourceBuffer &source, size_t offset,
    284         const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,
    285         const ICrypto::DestinationBuffer &destination, AString *errorDetailMsg) {
    286     Mutex::Autolock autoLock(mLock);
    287 
    288     if (mInitCheck != OK) {
    289         return mInitCheck;
    290     }
    291 
    292     Mode hMode;
    293     switch(mode) {
    294     case CryptoPlugin::kMode_Unencrypted:
    295         hMode = Mode::UNENCRYPTED ;
    296         break;
    297     case CryptoPlugin::kMode_AES_CTR:
    298         hMode = Mode::AES_CTR;
    299         break;
    300     case CryptoPlugin::kMode_AES_WV:
    301         hMode = Mode::AES_CBC_CTS;
    302         break;
    303     case CryptoPlugin::kMode_AES_CBC:
    304         hMode = Mode::AES_CBC;
    305         break;
    306     default:
    307         return UNKNOWN_ERROR;
    308     }
    309 
    310     Pattern hPattern;
    311     hPattern.encryptBlocks = pattern.mEncryptBlocks;
    312     hPattern.skipBlocks = pattern.mSkipBlocks;
    313 
    314     std::vector<SubSample> stdSubSamples;
    315     for (size_t i = 0; i < numSubSamples; i++) {
    316         SubSample subSample;
    317         subSample.numBytesOfClearData = subSamples[i].mNumBytesOfClearData;
    318         subSample.numBytesOfEncryptedData = subSamples[i].mNumBytesOfEncryptedData;
    319         stdSubSamples.push_back(subSample);
    320     }
    321     auto hSubSamples = hidl_vec<SubSample>(stdSubSamples);
    322 
    323     int32_t heapSeqNum = source.mHeapSeqNum;
    324     bool secure;
    325     ::DestinationBuffer hDestination;
    326     if (destination.mType == kDestinationTypeSharedMemory) {
    327         hDestination.type = BufferType::SHARED_MEMORY;
    328         status_t status = toSharedBuffer(destination.mSharedMemory, heapSeqNum,
    329                 &hDestination.nonsecureMemory);
    330         if (status != OK) {
    331             return status;
    332         }
    333         secure = false;
    334     } else {
    335         hDestination.type = BufferType::NATIVE_HANDLE;
    336         hDestination.secureMemory = hidl_handle(destination.mHandle);
    337         secure = true;
    338     }
    339 
    340     ::SharedBuffer hSource;
    341     status_t status = toSharedBuffer(source.mSharedMemory, heapSeqNum, &hSource);
    342     if (status != OK) {
    343         return status;
    344     }
    345 
    346     status_t err = UNKNOWN_ERROR;
    347     uint32_t bytesWritten = 0;
    348 
    349     Return<void> hResult = mPlugin->decrypt(secure, toHidlArray16(keyId), toHidlArray16(iv), hMode,
    350             hPattern, hSubSamples, hSource, offset, hDestination,
    351             [&](Status status, uint32_t hBytesWritten, hidl_string hDetailedError) {
    352                 if (status == Status::OK) {
    353                     bytesWritten = hBytesWritten;
    354                     *errorDetailMsg = toString8(hDetailedError);
    355                 }
    356                 err = toStatusT(status);
    357             }
    358         );
    359 
    360     if (!hResult.isOk()) {
    361         err = DEAD_OBJECT;
    362     }
    363 
    364     if (err == OK) {
    365         return bytesWritten;
    366     }
    367     return err;
    368 }
    369 
    370 void CryptoHal::notifyResolution(uint32_t width, uint32_t height) {
    371     Mutex::Autolock autoLock(mLock);
    372 
    373     if (mInitCheck != OK) {
    374         return;
    375     }
    376 
    377     mPlugin->notifyResolution(width, height);
    378 }
    379 
    380 status_t CryptoHal::setMediaDrmSession(const Vector<uint8_t> &sessionId) {
    381     Mutex::Autolock autoLock(mLock);
    382 
    383     if (mInitCheck != OK) {
    384         return mInitCheck;
    385     }
    386 
    387     return toStatusT(mPlugin->setMediaDrmSession(toHidlVec(sessionId)));
    388 }
    389 
    390 }  // namespace android
    391