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> ®istered) {
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> ®istered) {
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