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
toStatusT(Status status)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
toHidlVec(const Vector<uint8_t> & vector)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
toHidlVec(const void * ptr,size_t size)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
toHidlArray16(const uint8_t * ptr)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
toString8(hidl_string hString)100 static String8 toString8(hidl_string hString) {
101 return String8(hString.c_str());
102 }
103
104
CryptoHal()105 CryptoHal::CryptoHal()
106 : mFactories(makeCryptoFactories()),
107 mInitCheck((mFactories.size() == 0) ? ERROR_UNSUPPORTED : NO_INIT),
108 mNextBufferId(0),
109 mHeapSeqNum(0) {
110 }
111
~CryptoHal()112 CryptoHal::~CryptoHal() {
113 }
114
makeCryptoFactories()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> ®istered) {
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
makeCryptoPlugin(const sp<ICryptoFactory> & factory,const uint8_t uuid[16],const void * initData,size_t initDataSize)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
initCheck() const166 status_t CryptoHal::initCheck() const {
167 return mInitCheck;
168 }
169
170
isCryptoSchemeSupported(const uint8_t uuid[16])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
createPlugin(const uint8_t uuid[16],const void * data,size_t size)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
destroyPlugin()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
requiresSecureDecoderComponent(const char * mime) const212 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 */
setHeapBase(const sp<IMemoryHeap> & heap)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
clearHeapBase(int32_t seqNum)253 void CryptoHal::clearHeapBase(int32_t seqNum) {
254 Mutex::Autolock autoLock(mLock);
255
256 mHeapBases.removeItem(seqNum);
257 }
258
toSharedBuffer(const sp<IMemory> & memory,int32_t seqNum,::SharedBuffer * buffer)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
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)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
notifyResolution(uint32_t width,uint32_t height)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
setMediaDrmSession(const Vector<uint8_t> & sessionId)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