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 <hidlmemory/FrameworkUtils.h>
26 #include <media/hardware/CryptoAPI.h>
27 #include <media/stagefright/foundation/ADebug.h>
28 #include <media/stagefright/foundation/AString.h>
29 #include <media/stagefright/foundation/hexdump.h>
30 #include <media/stagefright/MediaErrors.h>
31 #include <mediadrm/CryptoHal.h>
32 
33 
34 using ::android::hardware::drm::V1_0::BufferType;
35 using ::android::hardware::drm::V1_0::DestinationBuffer;
36 using ::android::hardware::drm::V1_0::ICryptoFactory;
37 using ::android::hardware::drm::V1_0::ICryptoPlugin;
38 using ::android::hardware::drm::V1_0::Mode;
39 using ::android::hardware::drm::V1_0::Pattern;
40 using ::android::hardware::drm::V1_0::SharedBuffer;
41 using ::android::hardware::drm::V1_0::Status;
42 using ::android::hardware::drm::V1_0::SubSample;
43 using ::android::hardware::hidl_array;
44 using ::android::hardware::hidl_handle;
45 using ::android::hardware::hidl_memory;
46 using ::android::hardware::hidl_string;
47 using ::android::hardware::hidl_vec;
48 using ::android::hardware::Return;
49 using ::android::hardware::Void;
50 using ::android::hidl::manager::V1_0::IServiceManager;
51 using ::android::sp;
52 
53 
54 namespace android {
55 
toStatusT(Status status)56 static status_t toStatusT(Status status) {
57     switch (status) {
58     case Status::OK:
59         return OK;
60     case Status::ERROR_DRM_NO_LICENSE:
61         return ERROR_DRM_NO_LICENSE;
62     case Status::ERROR_DRM_LICENSE_EXPIRED:
63         return ERROR_DRM_LICENSE_EXPIRED;
64     case Status::ERROR_DRM_RESOURCE_BUSY:
65         return ERROR_DRM_RESOURCE_BUSY;
66     case Status::ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION:
67         return ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION;
68     case Status::ERROR_DRM_SESSION_NOT_OPENED:
69         return ERROR_DRM_SESSION_NOT_OPENED;
70     case Status::ERROR_DRM_CANNOT_HANDLE:
71         return ERROR_DRM_CANNOT_HANDLE;
72     case Status::ERROR_DRM_DECRYPT:
73         return ERROR_DRM_DECRYPT;
74     default:
75         return UNKNOWN_ERROR;
76     }
77 }
78 
79 
toHidlVec(const Vector<uint8_t> & vector)80 static hidl_vec<uint8_t> toHidlVec(const Vector<uint8_t> &vector) {
81     hidl_vec<uint8_t> vec;
82     vec.setToExternal(const_cast<uint8_t *>(vector.array()), vector.size());
83     return vec;
84 }
85 
toHidlVec(const void * ptr,size_t size)86 static hidl_vec<uint8_t> toHidlVec(const void *ptr, size_t size) {
87     hidl_vec<uint8_t> vec;
88     vec.resize(size);
89     memcpy(vec.data(), ptr, size);
90     return vec;
91 }
92 
toHidlArray16(const uint8_t * ptr)93 static hidl_array<uint8_t, 16> toHidlArray16(const uint8_t *ptr) {
94     if (!ptr) {
95         return hidl_array<uint8_t, 16>();
96     }
97     return hidl_array<uint8_t, 16>(ptr);
98 }
99 
100 
toString8(hidl_string hString)101 static String8 toString8(hidl_string hString) {
102     return String8(hString.c_str());
103 }
104 
105 
CryptoHal()106 CryptoHal::CryptoHal()
107     : mFactories(makeCryptoFactories()),
108       mInitCheck((mFactories.size() == 0) ? ERROR_UNSUPPORTED : NO_INIT),
109       mNextBufferId(0),
110       mHeapSeqNum(0) {
111 }
112 
~CryptoHal()113 CryptoHal::~CryptoHal() {
114 }
115 
makeCryptoFactories()116 Vector<sp<ICryptoFactory>> CryptoHal::makeCryptoFactories() {
117     Vector<sp<ICryptoFactory>> factories;
118 
119     auto manager = ::IServiceManager::getService();
120     if (manager != NULL) {
121         manager->listByInterface(drm::V1_0::ICryptoFactory::descriptor,
122                 [&factories](const hidl_vec<hidl_string> &registered) {
123                     for (const auto &instance : registered) {
124                         auto factory = drm::V1_0::ICryptoFactory::getService(instance);
125                         if (factory != NULL) {
126                             ALOGD("found drm@1.0 ICryptoFactory %s", instance.c_str());
127                             factories.push_back(factory);
128                         }
129                     }
130                 }
131             );
132         manager->listByInterface(drm::V1_1::ICryptoFactory::descriptor,
133                 [&factories](const hidl_vec<hidl_string> &registered) {
134                     for (const auto &instance : registered) {
135                         auto factory = drm::V1_1::ICryptoFactory::getService(instance);
136                         if (factory != NULL) {
137                             ALOGD("found drm@1.1 ICryptoFactory %s", instance.c_str());
138                             factories.push_back(factory);
139                         }
140                     }
141                 }
142             );
143     }
144 
145     if (factories.size() == 0) {
146         // must be in passthrough mode, load the default passthrough service
147         auto passthrough = ICryptoFactory::getService();
148         if (passthrough != NULL) {
149             ALOGI("makeCryptoFactories: using default passthrough crypto instance");
150             factories.push_back(passthrough);
151         } else {
152             ALOGE("Failed to find any crypto factories");
153         }
154     }
155     return factories;
156 }
157 
makeCryptoPlugin(const sp<ICryptoFactory> & factory,const uint8_t uuid[16],const void * initData,size_t initDataSize)158 sp<ICryptoPlugin> CryptoHal::makeCryptoPlugin(const sp<ICryptoFactory>& factory,
159         const uint8_t uuid[16], const void *initData, size_t initDataSize) {
160 
161     sp<ICryptoPlugin> plugin;
162     Return<void> hResult = factory->createPlugin(toHidlArray16(uuid),
163             toHidlVec(initData, initDataSize),
164             [&](Status status, const sp<ICryptoPlugin>& hPlugin) {
165                 if (status != Status::OK) {
166                     ALOGE("Failed to make crypto plugin");
167                     return;
168                 }
169                 plugin = hPlugin;
170             }
171         );
172     return plugin;
173 }
174 
175 
initCheck() const176 status_t CryptoHal::initCheck() const {
177     return mInitCheck;
178 }
179 
180 
isCryptoSchemeSupported(const uint8_t uuid[16])181 bool CryptoHal::isCryptoSchemeSupported(const uint8_t uuid[16]) {
182     Mutex::Autolock autoLock(mLock);
183 
184     for (size_t i = 0; i < mFactories.size(); i++) {
185         if (mFactories[i]->isCryptoSchemeSupported(uuid)) {
186             return true;
187         }
188     }
189     return false;
190 }
191 
createPlugin(const uint8_t uuid[16],const void * data,size_t size)192 status_t CryptoHal::createPlugin(const uint8_t uuid[16], const void *data,
193         size_t size) {
194     Mutex::Autolock autoLock(mLock);
195 
196     for (size_t i = 0; i < mFactories.size(); i++) {
197         if (mFactories[i]->isCryptoSchemeSupported(uuid)) {
198             mPlugin = makeCryptoPlugin(mFactories[i], uuid, data, size);
199         }
200     }
201 
202     if (mPlugin == NULL) {
203         mInitCheck = ERROR_UNSUPPORTED;
204     } else {
205         mInitCheck = OK;
206     }
207 
208     return mInitCheck;
209 }
210 
destroyPlugin()211 status_t CryptoHal::destroyPlugin() {
212     Mutex::Autolock autoLock(mLock);
213 
214     if (mInitCheck != OK) {
215         return mInitCheck;
216     }
217 
218     mPlugin.clear();
219     return OK;
220 }
221 
requiresSecureDecoderComponent(const char * mime) const222 bool CryptoHal::requiresSecureDecoderComponent(const char *mime) const {
223     Mutex::Autolock autoLock(mLock);
224 
225     if (mInitCheck != OK) {
226         return false;
227     }
228 
229     Return<bool> hResult = mPlugin->requiresSecureDecoderComponent(hidl_string(mime));
230     if (!hResult.isOk()) {
231         return false;
232     }
233     return hResult;
234 }
235 
236 
237 /**
238  * If the heap base isn't set, get the heap base from the IMemory
239  * and send it to the HAL so it can map a remote heap of the same
240  * size.  Once the heap base is established, shared memory buffers
241  * are sent by providing an offset into the heap and a buffer size.
242  */
setHeapBase(const sp<IMemoryHeap> & heap)243 int32_t CryptoHal::setHeapBase(const sp<IMemoryHeap>& heap) {
244     using ::android::hardware::fromHeap;
245     using ::android::hardware::HidlMemory;
246 
247     if (heap == NULL) {
248         ALOGE("setHeapBase(): heap is NULL");
249         return -1;
250     }
251 
252     Mutex::Autolock autoLock(mLock);
253 
254     int32_t seqNum = mHeapSeqNum++;
255     sp<HidlMemory> hidlMemory = fromHeap(heap);
256     mHeapBases.add(seqNum, HeapBase(mNextBufferId, heap->getSize()));
257     Return<void> hResult = mPlugin->setSharedBufferBase(*hidlMemory, mNextBufferId++);
258     ALOGE_IF(!hResult.isOk(), "setSharedBufferBase(): remote call failed");
259     return seqNum;
260 }
261 
clearHeapBase(int32_t seqNum)262 void CryptoHal::clearHeapBase(int32_t seqNum) {
263     Mutex::Autolock autoLock(mLock);
264 
265     /*
266      * Clear the remote shared memory mapping by setting the shared
267      * buffer base to a null hidl_memory.
268      *
269      * TODO: Add a releaseSharedBuffer method in a future DRM HAL
270      * API version to make this explicit.
271      */
272     ssize_t index = mHeapBases.indexOfKey(seqNum);
273     if (index >= 0) {
274         if (mPlugin != NULL) {
275             uint32_t bufferId = mHeapBases[index].getBufferId();
276             Return<void> hResult = mPlugin->setSharedBufferBase(hidl_memory(), bufferId);
277             ALOGE_IF(!hResult.isOk(), "setSharedBufferBase(): remote call failed");
278         }
279         mHeapBases.removeItem(seqNum);
280     }
281 }
282 
toSharedBuffer(const sp<IMemory> & memory,int32_t seqNum,::SharedBuffer * buffer)283 status_t CryptoHal::toSharedBuffer(const sp<IMemory>& memory, int32_t seqNum, ::SharedBuffer* buffer) {
284     ssize_t offset;
285     size_t size;
286 
287     if (memory == NULL && buffer == NULL) {
288         return UNEXPECTED_NULL;
289     }
290 
291     sp<IMemoryHeap> heap = memory->getMemory(&offset, &size);
292     if (heap == NULL) {
293         return UNEXPECTED_NULL;
294     }
295 
296     // memory must be in one of the heaps that have been set
297     if (mHeapBases.indexOfKey(seqNum) < 0) {
298         return UNKNOWN_ERROR;
299     }
300 
301     // heap must be the same size as the one that was set in setHeapBase
302     if (mHeapBases.valueFor(seqNum).getSize() != heap->getSize()) {
303         android_errorWriteLog(0x534e4554, "76221123");
304         return UNKNOWN_ERROR;
305      }
306 
307     // memory must be within the address space of the heap
308     if (memory->pointer() != static_cast<uint8_t *>(heap->getBase()) + memory->offset()  ||
309             heap->getSize() < memory->offset() + memory->size() ||
310             SIZE_MAX - memory->offset() < memory->size()) {
311         android_errorWriteLog(0x534e4554, "76221123");
312         return UNKNOWN_ERROR;
313     }
314 
315     buffer->bufferId = mHeapBases.valueFor(seqNum).getBufferId();
316     buffer->offset = offset >= 0 ? offset : 0;
317     buffer->size = size;
318     return OK;
319 }
320 
decrypt(const uint8_t keyId[16],const uint8_t iv[16],CryptoPlugin::Mode mode,const CryptoPlugin::Pattern & pattern,const ICrypto::SourceBuffer & source,size_t offset,const CryptoPlugin::SubSample * subSamples,size_t numSubSamples,const ICrypto::DestinationBuffer & destination,AString * errorDetailMsg)321 ssize_t CryptoHal::decrypt(const uint8_t keyId[16], const uint8_t iv[16],
322         CryptoPlugin::Mode mode, const CryptoPlugin::Pattern &pattern,
323         const ICrypto::SourceBuffer &source, size_t offset,
324         const CryptoPlugin::SubSample *subSamples, size_t numSubSamples,
325         const ICrypto::DestinationBuffer &destination, AString *errorDetailMsg) {
326     Mutex::Autolock autoLock(mLock);
327 
328     if (mInitCheck != OK) {
329         return mInitCheck;
330     }
331 
332     Mode hMode;
333     switch(mode) {
334     case CryptoPlugin::kMode_Unencrypted:
335         hMode = Mode::UNENCRYPTED ;
336         break;
337     case CryptoPlugin::kMode_AES_CTR:
338         hMode = Mode::AES_CTR;
339         break;
340     case CryptoPlugin::kMode_AES_WV:
341         hMode = Mode::AES_CBC_CTS;
342         break;
343     case CryptoPlugin::kMode_AES_CBC:
344         hMode = Mode::AES_CBC;
345         break;
346     default:
347         return UNKNOWN_ERROR;
348     }
349 
350     Pattern hPattern;
351     hPattern.encryptBlocks = pattern.mEncryptBlocks;
352     hPattern.skipBlocks = pattern.mSkipBlocks;
353 
354     std::vector<SubSample> stdSubSamples;
355     for (size_t i = 0; i < numSubSamples; i++) {
356         SubSample subSample;
357         subSample.numBytesOfClearData = subSamples[i].mNumBytesOfClearData;
358         subSample.numBytesOfEncryptedData = subSamples[i].mNumBytesOfEncryptedData;
359         stdSubSamples.push_back(subSample);
360     }
361     auto hSubSamples = hidl_vec<SubSample>(stdSubSamples);
362 
363     int32_t heapSeqNum = source.mHeapSeqNum;
364     bool secure;
365     ::DestinationBuffer hDestination;
366     if (destination.mType == kDestinationTypeSharedMemory) {
367         hDestination.type = BufferType::SHARED_MEMORY;
368         status_t status = toSharedBuffer(destination.mSharedMemory, heapSeqNum,
369                 &hDestination.nonsecureMemory);
370         if (status != OK) {
371             return status;
372         }
373         secure = false;
374     } else if (destination.mType == kDestinationTypeNativeHandle) {
375         hDestination.type = BufferType::NATIVE_HANDLE;
376         hDestination.secureMemory = hidl_handle(destination.mHandle);
377         secure = true;
378     } else {
379         android_errorWriteLog(0x534e4554, "70526702");
380         return UNKNOWN_ERROR;
381     }
382 
383     ::SharedBuffer hSource;
384     status_t status = toSharedBuffer(source.mSharedMemory, heapSeqNum, &hSource);
385     if (status != OK) {
386         return status;
387     }
388 
389     status_t err = UNKNOWN_ERROR;
390     uint32_t bytesWritten = 0;
391 
392     Return<void> hResult = mPlugin->decrypt(secure, toHidlArray16(keyId), toHidlArray16(iv), hMode,
393             hPattern, hSubSamples, hSource, offset, hDestination,
394             [&](Status status, uint32_t hBytesWritten, hidl_string hDetailedError) {
395                 if (status == Status::OK) {
396                     bytesWritten = hBytesWritten;
397                     *errorDetailMsg = toString8(hDetailedError);
398                 }
399                 err = toStatusT(status);
400             }
401         );
402 
403     if (!hResult.isOk()) {
404         err = DEAD_OBJECT;
405     }
406 
407     if (err == OK) {
408         return bytesWritten;
409     }
410     return err;
411 }
412 
notifyResolution(uint32_t width,uint32_t height)413 void CryptoHal::notifyResolution(uint32_t width, uint32_t height) {
414     Mutex::Autolock autoLock(mLock);
415 
416     if (mInitCheck != OK) {
417         return;
418     }
419 
420     mPlugin->notifyResolution(width, height);
421 }
422 
setMediaDrmSession(const Vector<uint8_t> & sessionId)423 status_t CryptoHal::setMediaDrmSession(const Vector<uint8_t> &sessionId) {
424     Mutex::Autolock autoLock(mLock);
425 
426     if (mInitCheck != OK) {
427         return mInitCheck;
428     }
429 
430     return toStatusT(mPlugin->setMediaDrmSession(toHidlVec(sessionId)));
431 }
432 
433 }  // namespace android
434