1 /*
2  * Copyright (C) 2013 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 "IDrm"
19 #include <utils/Log.h>
20 
21 #include <binder/Parcel.h>
22 #include <media/stagefright/MediaErrors.h>
23 #include <media/stagefright/foundation/ADebug.h>
24 #include <media/stagefright/foundation/AString.h>
25 #include <mediadrm/IDrm.h>
26 
27 namespace android {
28 
29 enum {
30     INIT_CHECK = IBinder::FIRST_CALL_TRANSACTION,
31     IS_CRYPTO_SUPPORTED,
32     CREATE_PLUGIN,
33     DESTROY_PLUGIN,
34     OPEN_SESSION,
35     CLOSE_SESSION,
36     GET_KEY_REQUEST,
37     PROVIDE_KEY_RESPONSE,
38     REMOVE_KEYS,
39     RESTORE_KEYS,
40     QUERY_KEY_STATUS,
41     GET_PROVISION_REQUEST,
42     PROVIDE_PROVISION_RESPONSE,
43     GET_SECURE_STOPS,
44     RELEASE_SECURE_STOPS,
45     GET_PROPERTY_STRING,
46     GET_PROPERTY_BYTE_ARRAY,
47     SET_PROPERTY_STRING,
48     SET_PROPERTY_BYTE_ARRAY,
49     GET_METRICS,
50     SET_CIPHER_ALGORITHM,
51     SET_MAC_ALGORITHM,
52     ENCRYPT,
53     DECRYPT,
54     SIGN,
55     SIGN_RSA,
56     VERIFY,
57     SET_LISTENER,
58     GET_SECURE_STOP,
59     REMOVE_ALL_SECURE_STOPS,
60     GET_HDCP_LEVELS,
61     GET_NUMBER_OF_SESSIONS,
62     GET_SECURITY_LEVEL,
63     REMOVE_SECURE_STOP,
64     GET_SECURE_STOP_IDS,
65     GET_OFFLINE_LICENSE_KEYSET_IDS,
66     REMOVE_OFFLINE_LICENSE,
67     GET_OFFLINE_LICENSE_STATE
68 };
69 
70 struct BpDrm : public BpInterface<IDrm> {
BpDrmandroid::BpDrm71     explicit BpDrm(const sp<IBinder> &impl)
72         : BpInterface<IDrm>(impl) {
73     }
74 
initCheckandroid::BpDrm75     virtual status_t initCheck() const {
76         Parcel data, reply;
77         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
78         status_t status = remote()->transact(INIT_CHECK, data, &reply);
79         if (status != OK) {
80             return status;
81         }
82 
83         return reply.readInt32();
84     }
85 
isCryptoSchemeSupportedandroid::BpDrm86     virtual status_t isCryptoSchemeSupported(const uint8_t uuid[16], const String8 &mimeType,
87             DrmPlugin::SecurityLevel level, bool *isSupported) {
88         Parcel data, reply;
89         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
90         data.write(uuid, 16);
91         data.writeString8(mimeType);
92         data.writeInt32(level);
93 
94         status_t status = remote()->transact(IS_CRYPTO_SUPPORTED, data, &reply);
95         if (status != OK) {
96             ALOGE("isCryptoSchemeSupported: binder call failed: %d", status);
97             return status;
98         }
99         *isSupported = static_cast<bool>(reply.readInt32());
100 
101         return reply.readInt32();
102     }
103 
createPluginandroid::BpDrm104     virtual status_t createPlugin(const uint8_t uuid[16],
105                                   const String8& appPackageName) {
106         Parcel data, reply;
107         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
108         data.write(uuid, 16);
109         data.writeString8(appPackageName);
110         status_t status = remote()->transact(CREATE_PLUGIN, data, &reply);
111         if (status != OK) {
112             ALOGE("createPlugin: binder call failed: %d", status);
113             return status;
114         }
115 
116         return reply.readInt32();
117     }
118 
destroyPluginandroid::BpDrm119     virtual status_t destroyPlugin() {
120         Parcel data, reply;
121         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
122         status_t status = remote()->transact(DESTROY_PLUGIN, data, &reply);
123         if (status != OK) {
124             return status;
125         }
126 
127         return reply.readInt32();
128     }
129 
openSessionandroid::BpDrm130     virtual status_t openSession(DrmPlugin::SecurityLevel level,
131             Vector<uint8_t> &sessionId) {
132         Parcel data, reply;
133         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
134         data.writeInt32(level);
135 
136         status_t status = remote()->transact(OPEN_SESSION, data, &reply);
137         if (status != OK) {
138             return status;
139         }
140         readVector(reply, sessionId);
141 
142         return reply.readInt32();
143     }
144 
closeSessionandroid::BpDrm145     virtual status_t closeSession(Vector<uint8_t> const &sessionId) {
146         Parcel data, reply;
147         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
148 
149         writeVector(data, sessionId);
150         status_t status = remote()->transact(CLOSE_SESSION, data, &reply);
151         if (status != OK) {
152             return status;
153         }
154 
155         return reply.readInt32();
156     }
157 
158     virtual status_t
getKeyRequestandroid::BpDrm159         getKeyRequest(Vector<uint8_t> const &sessionId,
160                       Vector<uint8_t> const &initData,
161                       String8 const &mimeType, DrmPlugin::KeyType keyType,
162                       KeyedVector<String8, String8> const &optionalParameters,
163                       Vector<uint8_t> &request, String8 &defaultUrl,
164                       DrmPlugin::KeyRequestType *keyRequestType) {
165         Parcel data, reply;
166         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
167 
168         writeVector(data, sessionId);
169         writeVector(data, initData);
170         data.writeString8(mimeType);
171         data.writeInt32((uint32_t)keyType);
172 
173         data.writeInt32(optionalParameters.size());
174         for (size_t i = 0; i < optionalParameters.size(); ++i) {
175             data.writeString8(optionalParameters.keyAt(i));
176             data.writeString8(optionalParameters.valueAt(i));
177         }
178 
179         status_t status = remote()->transact(GET_KEY_REQUEST, data, &reply);
180         if (status != OK) {
181             return status;
182         }
183 
184         readVector(reply, request);
185         defaultUrl = reply.readString8();
186         *keyRequestType = static_cast<DrmPlugin::KeyRequestType>(reply.readInt32());
187 
188         return reply.readInt32();
189     }
190 
provideKeyResponseandroid::BpDrm191     virtual status_t provideKeyResponse(Vector<uint8_t> const &sessionId,
192                                         Vector<uint8_t> const &response,
193                                         Vector<uint8_t> &keySetId) {
194         Parcel data, reply;
195         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
196         writeVector(data, sessionId);
197         writeVector(data, response);
198 
199         status_t status = remote()->transact(PROVIDE_KEY_RESPONSE, data, &reply);
200         if (status != OK) {
201             return status;
202         }
203 
204         readVector(reply, keySetId);
205 
206         return reply.readInt32();
207     }
208 
removeKeysandroid::BpDrm209     virtual status_t removeKeys(Vector<uint8_t> const &keySetId) {
210         Parcel data, reply;
211         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
212 
213         writeVector(data, keySetId);
214         status_t status = remote()->transact(REMOVE_KEYS, data, &reply);
215         if (status != OK) {
216             return status;
217         }
218 
219         return reply.readInt32();
220     }
221 
restoreKeysandroid::BpDrm222     virtual status_t restoreKeys(Vector<uint8_t> const &sessionId,
223                                  Vector<uint8_t> const &keySetId) {
224         Parcel data, reply;
225         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
226 
227         writeVector(data, sessionId);
228         writeVector(data, keySetId);
229         status_t status = remote()->transact(RESTORE_KEYS, data, &reply);
230         if (status != OK) {
231             return status;
232         }
233 
234         return reply.readInt32();
235     }
236 
queryKeyStatusandroid::BpDrm237     virtual status_t queryKeyStatus(Vector<uint8_t> const &sessionId,
238                                         KeyedVector<String8, String8> &infoMap) const {
239         Parcel data, reply;
240         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
241 
242         writeVector(data, sessionId);
243         status_t status = remote()->transact(QUERY_KEY_STATUS, data, &reply);
244         if (status != OK) {
245             return status;
246         }
247 
248         infoMap.clear();
249         size_t count = reply.readInt32();
250         for (size_t i = 0; i < count; i++) {
251             String8 key = reply.readString8();
252             String8 value = reply.readString8();
253             infoMap.add(key, value);
254         }
255         return reply.readInt32();
256     }
257 
getProvisionRequestandroid::BpDrm258     virtual status_t getProvisionRequest(String8 const &certType,
259                                          String8 const &certAuthority,
260                                          Vector<uint8_t> &request,
261                                          String8 &defaultUrl) {
262         Parcel data, reply;
263         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
264 
265         data.writeString8(certType);
266         data.writeString8(certAuthority);
267         status_t status = remote()->transact(GET_PROVISION_REQUEST, data, &reply);
268         if (status != OK) {
269             return status;
270         }
271 
272         readVector(reply, request);
273         defaultUrl = reply.readString8();
274 
275         return reply.readInt32();
276     }
277 
provideProvisionResponseandroid::BpDrm278     virtual status_t provideProvisionResponse(Vector<uint8_t> const &response,
279                                               Vector<uint8_t> &certificate,
280                                               Vector<uint8_t> &wrappedKey) {
281         Parcel data, reply;
282         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
283 
284         writeVector(data, response);
285         status_t status = remote()->transact(PROVIDE_PROVISION_RESPONSE, data, &reply);
286         if (status != OK) {
287             return status;
288         }
289 
290         readVector(reply, certificate);
291         readVector(reply, wrappedKey);
292 
293         return reply.readInt32();
294     }
295 
getSecureStopsandroid::BpDrm296     virtual status_t getSecureStops(List<Vector<uint8_t> > &secureStops) {
297         Parcel data, reply;
298         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
299 
300         status_t status = remote()->transact(GET_SECURE_STOPS, data, &reply);
301         if (status != OK) {
302             return status;
303         }
304 
305         secureStops.clear();
306         uint32_t count = reply.readInt32();
307         for (size_t i = 0; i < count; i++) {
308             Vector<uint8_t> secureStop;
309             readVector(reply, secureStop);
310             secureStops.push_back(secureStop);
311         }
312         return reply.readInt32();
313     }
314 
getSecureStopIdsandroid::BpDrm315     virtual status_t getSecureStopIds(List<Vector<uint8_t> > &secureStopIds) {
316         Parcel data, reply;
317         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
318 
319         status_t status = remote()->transact(GET_SECURE_STOP_IDS, data, &reply);
320         if (status != OK) {
321             return status;
322         }
323 
324         secureStopIds.clear();
325         uint32_t count = reply.readInt32();
326         for (size_t i = 0; i < count; i++) {
327             Vector<uint8_t> secureStopId;
328             readVector(reply, secureStopId);
329             secureStopIds.push_back(secureStopId);
330         }
331         return reply.readInt32();
332     }
333 
getSecureStopandroid::BpDrm334     virtual status_t getSecureStop(Vector<uint8_t> const &ssid, Vector<uint8_t> &secureStop) {
335         Parcel data, reply;
336         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
337 
338         writeVector(data, ssid);
339         status_t status = remote()->transact(GET_SECURE_STOP, data, &reply);
340         if (status != OK) {
341             return status;
342         }
343 
344         readVector(reply, secureStop);
345         return reply.readInt32();
346     }
347 
releaseSecureStopsandroid::BpDrm348     virtual status_t releaseSecureStops(Vector<uint8_t> const &ssRelease) {
349         Parcel data, reply;
350         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
351 
352         writeVector(data, ssRelease);
353         status_t status = remote()->transact(RELEASE_SECURE_STOPS, data, &reply);
354         if (status != OK) {
355             return status;
356         }
357 
358         return reply.readInt32();
359     }
360 
removeSecureStopandroid::BpDrm361     virtual status_t removeSecureStop(Vector<uint8_t> const &ssid) {
362         Parcel data, reply;
363         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
364 
365         writeVector(data, ssid);
366         status_t status = remote()->transact(REMOVE_SECURE_STOP, data, &reply);
367         if (status != OK) {
368             return status;
369         }
370 
371         return reply.readInt32();
372     }
373 
removeAllSecureStopsandroid::BpDrm374     virtual status_t removeAllSecureStops() {
375         Parcel data, reply;
376         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
377 
378         status_t status = remote()->transact(REMOVE_ALL_SECURE_STOPS, data, &reply);
379         if (status != OK) {
380             return status;
381         }
382 
383         return reply.readInt32();
384     }
385 
getOfflineLicenseKeySetIdsandroid::BpDrm386     virtual status_t getOfflineLicenseKeySetIds(List<Vector<uint8_t> > &keySetIds) const {
387         Parcel data, reply;
388         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
389 
390         status_t status = remote()->transact(GET_OFFLINE_LICENSE_KEYSET_IDS, data, &reply);
391         if (status != OK) {
392             return status;
393         }
394 
395         keySetIds.clear();
396         uint32_t count = reply.readInt32();
397         for (size_t i = 0; i < count; i++) {
398             Vector<uint8_t> keySetId;
399             readVector(reply, keySetId);
400             keySetIds.push_back(keySetId);
401         }
402         return reply.readInt32();
403     }
404 
removeOfflineLicenseandroid::BpDrm405     virtual status_t removeOfflineLicense(Vector<uint8_t> const &keySetId) {
406         Parcel data, reply;
407         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
408 
409         writeVector(data, keySetId);
410         status_t status = remote()->transact(REMOVE_OFFLINE_LICENSE, data, &reply);
411         if (status != OK) {
412             return status;
413         }
414         return reply.readInt32();
415     }
416 
getOfflineLicenseStateandroid::BpDrm417     virtual status_t getOfflineLicenseState(Vector<uint8_t> const &keySetId,
418             DrmPlugin::OfflineLicenseState *licenseState) const {
419         Parcel data, reply;
420         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
421 
422         writeVector(data, keySetId);
423         status_t status = remote()->transact(GET_OFFLINE_LICENSE_STATE, data, &reply);
424         if (status != OK) {
425             *licenseState = DrmPlugin::OfflineLicenseState::kOfflineLicenseStateUnknown;
426             return status;
427         }
428         *licenseState = static_cast<DrmPlugin::OfflineLicenseState>(reply.readInt32());
429         return reply.readInt32();
430     }
431 
getPropertyStringandroid::BpDrm432     virtual status_t getPropertyString(String8 const &name, String8 &value) const {
433         Parcel data, reply;
434         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
435 
436         data.writeString8(name);
437         status_t status = remote()->transact(GET_PROPERTY_STRING, data, &reply);
438         if (status != OK) {
439             return status;
440         }
441 
442         value = reply.readString8();
443         return reply.readInt32();
444     }
445 
getHdcpLevelsandroid::BpDrm446     virtual status_t getHdcpLevels(DrmPlugin::HdcpLevel *connected,
447             DrmPlugin::HdcpLevel *max) const {
448         Parcel data, reply;
449 
450         if (connected == NULL || max == NULL) {
451             return BAD_VALUE;
452         }
453 
454         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
455 
456         status_t status = remote()->transact(GET_HDCP_LEVELS, data, &reply);
457         if (status != OK) {
458             return status;
459         }
460 
461         *connected = static_cast<DrmPlugin::HdcpLevel>(reply.readInt32());
462         *max = static_cast<DrmPlugin::HdcpLevel>(reply.readInt32());
463         return reply.readInt32();
464     }
465 
getNumberOfSessionsandroid::BpDrm466     virtual status_t getNumberOfSessions(uint32_t *open, uint32_t *max) const {
467         Parcel data, reply;
468 
469         if (open == NULL || max == NULL) {
470             return BAD_VALUE;
471         }
472 
473         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
474 
475         status_t status = remote()->transact(GET_NUMBER_OF_SESSIONS, data, &reply);
476         if (status != OK) {
477             return status;
478         }
479 
480         *open = reply.readInt32();
481         *max = reply.readInt32();
482         return reply.readInt32();
483     }
484 
getSecurityLevelandroid::BpDrm485     virtual status_t getSecurityLevel(Vector<uint8_t> const &sessionId,
486             DrmPlugin::SecurityLevel *level) const {
487         Parcel data, reply;
488 
489         if (level == NULL) {
490             return BAD_VALUE;
491         }
492 
493         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
494 
495         writeVector(data, sessionId);
496         status_t status = remote()->transact(GET_SECURITY_LEVEL, data, &reply);
497         if (status != OK) {
498             return status;
499         }
500 
501         *level = static_cast<DrmPlugin::SecurityLevel>(reply.readInt32());
502         return reply.readInt32();
503     }
504 
getPropertyByteArrayandroid::BpDrm505     virtual status_t getPropertyByteArray(String8 const &name, Vector<uint8_t> &value) const {
506         Parcel data, reply;
507         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
508 
509         data.writeString8(name);
510         status_t status = remote()->transact(GET_PROPERTY_BYTE_ARRAY, data, &reply);
511         if (status != OK) {
512             return status;
513         }
514 
515         readVector(reply, value);
516         return reply.readInt32();
517     }
518 
setPropertyStringandroid::BpDrm519     virtual status_t setPropertyString(String8 const &name, String8 const &value) const {
520         Parcel data, reply;
521         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
522 
523         data.writeString8(name);
524         data.writeString8(value);
525         status_t status = remote()->transact(SET_PROPERTY_STRING, data, &reply);
526         if (status != OK) {
527             return status;
528         }
529 
530         return reply.readInt32();
531     }
532 
setPropertyByteArrayandroid::BpDrm533     virtual status_t setPropertyByteArray(String8 const &name,
534                                           Vector<uint8_t> const &value) const {
535         Parcel data, reply;
536         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
537 
538         data.writeString8(name);
539         writeVector(data, value);
540         status_t status = remote()->transact(SET_PROPERTY_BYTE_ARRAY, data, &reply);
541         if (status != OK) {
542             return status;
543         }
544 
545         return reply.readInt32();
546     }
547 
getMetricsandroid::BpDrm548     virtual status_t getMetrics(os::PersistableBundle *metrics) {
549         if (metrics == NULL) {
550             return BAD_VALUE;
551         }
552         Parcel data, reply;
553         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
554 
555         status_t status = remote()->transact(GET_METRICS, data, &reply);
556         if (status != OK) {
557             return status;
558         }
559         // The reply data is ordered as
560         // 1) 32 bit integer reply followed by
561         // 2) Serialized PersistableBundle containing metrics.
562         status_t reply_status;
563         if (reply.readInt32(&reply_status) != OK
564            || reply_status != OK) {
565           ALOGE("Failed to read getMetrics response code from parcel. %d",
566                 reply_status);
567           return reply_status;
568         }
569 
570         status = metrics->readFromParcel(&reply);
571         if (status != OK) {
572             ALOGE("Failed to read metrics from parcel. %d", status);
573             return status;
574         }
575         return reply_status;
576     }
577 
setCipherAlgorithmandroid::BpDrm578     virtual status_t setCipherAlgorithm(Vector<uint8_t> const &sessionId,
579                                         String8 const &algorithm) {
580         Parcel data, reply;
581         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
582 
583         writeVector(data, sessionId);
584         data.writeString8(algorithm);
585         status_t status = remote()->transact(SET_CIPHER_ALGORITHM, data, &reply);
586         if (status != OK) {
587             return status;
588         }
589         return reply.readInt32();
590     }
591 
setMacAlgorithmandroid::BpDrm592     virtual status_t setMacAlgorithm(Vector<uint8_t> const &sessionId,
593                                      String8 const &algorithm) {
594         Parcel data, reply;
595         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
596 
597         writeVector(data, sessionId);
598         data.writeString8(algorithm);
599         status_t status = remote()->transact(SET_MAC_ALGORITHM, data, &reply);
600         if (status != OK) {
601             return status;
602         }
603         return reply.readInt32();
604     }
605 
encryptandroid::BpDrm606     virtual status_t encrypt(Vector<uint8_t> const &sessionId,
607                              Vector<uint8_t> const &keyId,
608                              Vector<uint8_t> const &input,
609                              Vector<uint8_t> const &iv,
610                              Vector<uint8_t> &output) {
611         Parcel data, reply;
612         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
613 
614         writeVector(data, sessionId);
615         writeVector(data, keyId);
616         writeVector(data, input);
617         writeVector(data, iv);
618 
619         status_t status = remote()->transact(ENCRYPT, data, &reply);
620         if (status != OK) {
621             return status;
622         }
623         readVector(reply, output);
624 
625         return reply.readInt32();
626     }
627 
decryptandroid::BpDrm628     virtual status_t decrypt(Vector<uint8_t> const &sessionId,
629                              Vector<uint8_t> const &keyId,
630                              Vector<uint8_t> const &input,
631                              Vector<uint8_t> const &iv,
632                              Vector<uint8_t> &output) {
633         Parcel data, reply;
634         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
635 
636         writeVector(data, sessionId);
637         writeVector(data, keyId);
638         writeVector(data, input);
639         writeVector(data, iv);
640 
641         status_t status = remote()->transact(DECRYPT, data, &reply);
642         if (status != OK) {
643             return status;
644         }
645         readVector(reply, output);
646 
647         return reply.readInt32();
648     }
649 
signandroid::BpDrm650     virtual status_t sign(Vector<uint8_t> const &sessionId,
651                           Vector<uint8_t> const &keyId,
652                           Vector<uint8_t> const &message,
653                           Vector<uint8_t> &signature) {
654         Parcel data, reply;
655         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
656 
657         writeVector(data, sessionId);
658         writeVector(data, keyId);
659         writeVector(data, message);
660 
661         status_t status = remote()->transact(SIGN, data, &reply);
662         if (status != OK) {
663             return status;
664         }
665         readVector(reply, signature);
666 
667         return reply.readInt32();
668     }
669 
verifyandroid::BpDrm670     virtual status_t verify(Vector<uint8_t> const &sessionId,
671                             Vector<uint8_t> const &keyId,
672                             Vector<uint8_t> const &message,
673                             Vector<uint8_t> const &signature,
674                             bool &match) {
675         Parcel data, reply;
676         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
677 
678         writeVector(data, sessionId);
679         writeVector(data, keyId);
680         writeVector(data, message);
681         writeVector(data, signature);
682 
683         status_t status = remote()->transact(VERIFY, data, &reply);
684         if (status != OK) {
685             return status;
686         }
687         match = (bool)reply.readInt32();
688         return reply.readInt32();
689     }
690 
signRSAandroid::BpDrm691     virtual status_t signRSA(Vector<uint8_t> const &sessionId,
692                              String8 const &algorithm,
693                              Vector<uint8_t> const &message,
694                              Vector<uint8_t> const &wrappedKey,
695                              Vector<uint8_t> &signature) {
696         Parcel data, reply;
697         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
698 
699         writeVector(data, sessionId);
700         data.writeString8(algorithm);
701         writeVector(data, message);
702         writeVector(data, wrappedKey);
703 
704         status_t status = remote()->transact(SIGN_RSA, data, &reply);
705         if (status != OK) {
706             return status;
707         }
708         readVector(reply, signature);
709 
710         return reply.readInt32();
711     }
712 
setListenerandroid::BpDrm713     virtual status_t setListener(const sp<IDrmClient>& listener) {
714         Parcel data, reply;
715         data.writeInterfaceToken(IDrm::getInterfaceDescriptor());
716         data.writeStrongBinder(IInterface::asBinder(listener));
717         status_t status = remote()->transact(SET_LISTENER, data, &reply);
718         if (status != OK) {
719             return status;
720         }
721         return reply.readInt32();
722     }
723 
724 private:
readVectorandroid::BpDrm725     void readVector(Parcel &reply, Vector<uint8_t> &vector) const {
726         uint32_t size = reply.readInt32();
727         vector.insertAt((size_t)0, size);
728         reply.read(vector.editArray(), size);
729     }
730 
writeVectorandroid::BpDrm731     void writeVector(Parcel &data, Vector<uint8_t> const &vector) const {
732         data.writeInt32(vector.size());
733         data.write(vector.array(), vector.size());
734     }
735 
736     DISALLOW_EVIL_CONSTRUCTORS(BpDrm);
737 };
738 
739 IMPLEMENT_META_INTERFACE(Drm, "android.drm.IDrm");
740 
741 ////////////////////////////////////////////////////////////////////////////////
742 
readVector(const Parcel & data,Vector<uint8_t> & vector) const743 void BnDrm::readVector(const Parcel &data, Vector<uint8_t> &vector) const {
744     uint32_t size = data.readInt32();
745     if (vector.insertAt((size_t)0, size) < 0) {
746         vector.clear();
747     }
748     if (data.read(vector.editArray(), size) != NO_ERROR) {
749         vector.clear();
750         android_errorWriteWithInfoLog(0x534e4554, "62872384", -1, NULL, 0);
751     }
752 }
753 
writeVector(Parcel * reply,Vector<uint8_t> const & vector) const754 void BnDrm::writeVector(Parcel *reply, Vector<uint8_t> const &vector) const {
755     reply->writeInt32(vector.size());
756     reply->write(vector.array(), vector.size());
757 }
758 
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)759 status_t BnDrm::onTransact(
760     uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {
761     switch (code) {
762         case INIT_CHECK:
763         {
764             CHECK_INTERFACE(IDrm, data, reply);
765             reply->writeInt32(initCheck());
766             return OK;
767         }
768 
769         case IS_CRYPTO_SUPPORTED:
770         {
771             CHECK_INTERFACE(IDrm, data, reply);
772             uint8_t uuid[16];
773             data.read(uuid, sizeof(uuid));
774             String8 mimeType = data.readString8();
775             DrmPlugin::SecurityLevel level =
776                     static_cast<DrmPlugin::SecurityLevel>(data.readInt32());
777             bool isSupported = false;
778             status_t result = isCryptoSchemeSupported(uuid, mimeType, level, &isSupported);
779             reply->writeInt32(isSupported);
780             reply->writeInt32(result);
781             return OK;
782         }
783 
784         case CREATE_PLUGIN:
785         {
786             CHECK_INTERFACE(IDrm, data, reply);
787             uint8_t uuid[16];
788             data.read(uuid, sizeof(uuid));
789             String8 appPackageName = data.readString8();
790             reply->writeInt32(createPlugin(uuid, appPackageName));
791             return OK;
792         }
793 
794         case DESTROY_PLUGIN:
795         {
796             CHECK_INTERFACE(IDrm, data, reply);
797             reply->writeInt32(destroyPlugin());
798             return OK;
799         }
800 
801         case OPEN_SESSION:
802         {
803             CHECK_INTERFACE(IDrm, data, reply);
804             DrmPlugin::SecurityLevel level =
805                     static_cast<DrmPlugin::SecurityLevel>(data.readInt32());
806             Vector<uint8_t> sessionId;
807             status_t result = openSession(level, sessionId);
808             writeVector(reply, sessionId);
809             reply->writeInt32(result);
810             return OK;
811         }
812 
813         case CLOSE_SESSION:
814         {
815             CHECK_INTERFACE(IDrm, data, reply);
816             Vector<uint8_t> sessionId;
817             readVector(data, sessionId);
818             reply->writeInt32(closeSession(sessionId));
819             return OK;
820         }
821 
822         case GET_KEY_REQUEST:
823         {
824             CHECK_INTERFACE(IDrm, data, reply);
825             Vector<uint8_t> sessionId, initData;
826 
827             readVector(data, sessionId);
828             readVector(data, initData);
829             String8 mimeType = data.readString8();
830             DrmPlugin::KeyType keyType = (DrmPlugin::KeyType)data.readInt32();
831 
832             KeyedVector<String8, String8> optionalParameters;
833             uint32_t count = data.readInt32();
834             for (size_t i = 0; i < count; ++i) {
835                 String8 key, value;
836                 key = data.readString8();
837                 value = data.readString8();
838                 optionalParameters.add(key, value);
839             }
840 
841             Vector<uint8_t> request;
842             String8 defaultUrl;
843             DrmPlugin::KeyRequestType keyRequestType = DrmPlugin::kKeyRequestType_Unknown;
844 
845             status_t result = getKeyRequest(sessionId, initData, mimeType,
846                     keyType, optionalParameters, request, defaultUrl,
847                     &keyRequestType);
848 
849             writeVector(reply, request);
850             reply->writeString8(defaultUrl);
851             reply->writeInt32(static_cast<int32_t>(keyRequestType));
852             reply->writeInt32(result);
853             return OK;
854         }
855 
856         case PROVIDE_KEY_RESPONSE:
857         {
858             CHECK_INTERFACE(IDrm, data, reply);
859             Vector<uint8_t> sessionId, response, keySetId;
860             readVector(data, sessionId);
861             readVector(data, response);
862             uint32_t result = provideKeyResponse(sessionId, response, keySetId);
863             writeVector(reply, keySetId);
864             reply->writeInt32(result);
865             return OK;
866         }
867 
868         case REMOVE_KEYS:
869         {
870             CHECK_INTERFACE(IDrm, data, reply);
871             Vector<uint8_t> keySetId;
872             readVector(data, keySetId);
873             reply->writeInt32(removeKeys(keySetId));
874             return OK;
875         }
876 
877         case RESTORE_KEYS:
878         {
879             CHECK_INTERFACE(IDrm, data, reply);
880             Vector<uint8_t> sessionId, keySetId;
881             readVector(data, sessionId);
882             readVector(data, keySetId);
883             reply->writeInt32(restoreKeys(sessionId, keySetId));
884             return OK;
885         }
886 
887         case QUERY_KEY_STATUS:
888         {
889             CHECK_INTERFACE(IDrm, data, reply);
890             Vector<uint8_t> sessionId;
891             readVector(data, sessionId);
892             KeyedVector<String8, String8> infoMap;
893             status_t result = queryKeyStatus(sessionId, infoMap);
894             size_t count = infoMap.size();
895             reply->writeInt32(count);
896             for (size_t i = 0; i < count; ++i) {
897                 reply->writeString8(infoMap.keyAt(i));
898                 reply->writeString8(infoMap.valueAt(i));
899             }
900             reply->writeInt32(result);
901             return OK;
902         }
903 
904         case GET_PROVISION_REQUEST:
905         {
906             CHECK_INTERFACE(IDrm, data, reply);
907             String8 certType = data.readString8();
908             String8 certAuthority = data.readString8();
909 
910             Vector<uint8_t> request;
911             String8 defaultUrl;
912             status_t result = getProvisionRequest(certType, certAuthority,
913                                                   request, defaultUrl);
914             writeVector(reply, request);
915             reply->writeString8(defaultUrl);
916             reply->writeInt32(result);
917             return OK;
918         }
919 
920         case PROVIDE_PROVISION_RESPONSE:
921         {
922             CHECK_INTERFACE(IDrm, data, reply);
923             Vector<uint8_t> response;
924             Vector<uint8_t> certificate;
925             Vector<uint8_t> wrappedKey;
926             readVector(data, response);
927             status_t result = provideProvisionResponse(response, certificate, wrappedKey);
928             writeVector(reply, certificate);
929             writeVector(reply, wrappedKey);
930             reply->writeInt32(result);
931             return OK;
932         }
933 
934         case GET_SECURE_STOPS:
935         {
936             CHECK_INTERFACE(IDrm, data, reply);
937             List<Vector<uint8_t> > secureStops;
938             status_t result = getSecureStops(secureStops);
939             size_t count = secureStops.size();
940             reply->writeInt32(count);
941             List<Vector<uint8_t> >::iterator iter = secureStops.begin();
942             while(iter != secureStops.end()) {
943                 size_t size = iter->size();
944                 reply->writeInt32(size);
945                 reply->write(iter->array(), iter->size());
946                 iter++;
947             }
948             reply->writeInt32(result);
949             return OK;
950         }
951 
952         case GET_SECURE_STOP_IDS:
953         {
954             CHECK_INTERFACE(IDrm, data, reply);
955             List<Vector<uint8_t> > secureStopIds;
956             status_t result = getSecureStopIds(secureStopIds);
957             size_t count = secureStopIds.size();
958             reply->writeInt32(count);
959             List<Vector<uint8_t> >::iterator iter = secureStopIds.begin();
960             while(iter != secureStopIds.end()) {
961                 size_t size = iter->size();
962                 reply->writeInt32(size);
963                 reply->write(iter->array(), iter->size());
964                 iter++;
965             }
966             reply->writeInt32(result);
967             return OK;
968         }
969 
970         case GET_SECURE_STOP:
971         {
972             CHECK_INTERFACE(IDrm, data, reply);
973             Vector<uint8_t> ssid, secureStop;
974             readVector(data, ssid);
975             status_t result = getSecureStop(ssid, secureStop);
976             writeVector(reply, secureStop);
977             reply->writeInt32(result);
978             return OK;
979         }
980 
981         case RELEASE_SECURE_STOPS:
982         {
983             CHECK_INTERFACE(IDrm, data, reply);
984             Vector<uint8_t> ssRelease;
985             readVector(data, ssRelease);
986             reply->writeInt32(releaseSecureStops(ssRelease));
987             return OK;
988         }
989 
990         case REMOVE_SECURE_STOP:
991         {
992             CHECK_INTERFACE(IDrm, data, reply);
993             Vector<uint8_t> ssid;
994             readVector(data, ssid);
995             reply->writeInt32(removeSecureStop(ssid));
996             return OK;
997         }
998 
999         case REMOVE_ALL_SECURE_STOPS:
1000         {
1001             CHECK_INTERFACE(IDrm, data, reply);
1002             reply->writeInt32(removeAllSecureStops());
1003             return OK;
1004         }
1005 
1006         case GET_HDCP_LEVELS:
1007         {
1008             CHECK_INTERFACE(IDrm, data, reply);
1009             DrmPlugin::HdcpLevel connected = DrmPlugin::kHdcpLevelUnknown;
1010             DrmPlugin::HdcpLevel max = DrmPlugin::kHdcpLevelUnknown;
1011             status_t result = getHdcpLevels(&connected, &max);
1012             reply->writeInt32(connected);
1013             reply->writeInt32(max);
1014             reply->writeInt32(result);
1015             return OK;
1016         }
1017 
1018         case GET_NUMBER_OF_SESSIONS:
1019         {
1020             CHECK_INTERFACE(IDrm, data, reply);
1021             uint32_t open = 0, max = 0;
1022             status_t result = getNumberOfSessions(&open, &max);
1023             reply->writeInt32(open);
1024             reply->writeInt32(max);
1025             reply->writeInt32(result);
1026             return OK;
1027         }
1028 
1029         case GET_SECURITY_LEVEL:
1030         {
1031             CHECK_INTERFACE(IDrm, data, reply);
1032             Vector<uint8_t> sessionId;
1033             readVector(data, sessionId);
1034             DrmPlugin::SecurityLevel level = DrmPlugin::kSecurityLevelUnknown;
1035             status_t result = getSecurityLevel(sessionId, &level);
1036             reply->writeInt32(level);
1037             reply->writeInt32(result);
1038             return OK;
1039         }
1040 
1041         case GET_OFFLINE_LICENSE_KEYSET_IDS:
1042         {
1043             CHECK_INTERFACE(IDrm, data, reply);
1044             List<Vector<uint8_t> > keySetIds;
1045             status_t result = getOfflineLicenseKeySetIds(keySetIds);
1046             size_t count = keySetIds.size();
1047             reply->writeInt32(count);
1048             List<Vector<uint8_t> >::iterator iter = keySetIds.begin();
1049             while(iter != keySetIds.end()) {
1050                 size_t size = iter->size();
1051                 reply->writeInt32(size);
1052                 reply->write(iter->array(), iter->size());
1053                 iter++;
1054             }
1055             reply->writeInt32(result);
1056             return OK;
1057         }
1058 
1059         case REMOVE_OFFLINE_LICENSE:
1060         {
1061             CHECK_INTERFACE(IDrm, data, reply);
1062             Vector<uint8_t> keySetId;
1063             readVector(data, keySetId);
1064             reply->writeInt32(removeOfflineLicense(keySetId));
1065             return OK;
1066         }
1067 
1068         case GET_OFFLINE_LICENSE_STATE:
1069         {
1070             CHECK_INTERFACE(IDrm, data, reply);
1071             Vector<uint8_t> keySetId;
1072             readVector(data, keySetId);
1073             DrmPlugin::OfflineLicenseState state;
1074             state = DrmPlugin::OfflineLicenseState::kOfflineLicenseStateUnknown;
1075             status_t result = getOfflineLicenseState(keySetId, &state);
1076             reply->writeInt32(static_cast<DrmPlugin::OfflineLicenseState>(state));
1077             reply->writeInt32(result);
1078             return OK;
1079         }
1080 
1081         case GET_PROPERTY_STRING:
1082         {
1083             CHECK_INTERFACE(IDrm, data, reply);
1084             String8 name = data.readString8();
1085             String8 value;
1086             status_t result = getPropertyString(name, value);
1087             reply->writeString8(value);
1088             reply->writeInt32(result);
1089             return OK;
1090         }
1091 
1092         case GET_PROPERTY_BYTE_ARRAY:
1093         {
1094             CHECK_INTERFACE(IDrm, data, reply);
1095             String8 name = data.readString8();
1096             Vector<uint8_t> value;
1097             status_t result = getPropertyByteArray(name, value);
1098             writeVector(reply, value);
1099             reply->writeInt32(result);
1100             return OK;
1101         }
1102 
1103         case SET_PROPERTY_STRING:
1104         {
1105             CHECK_INTERFACE(IDrm, data, reply);
1106             String8 name = data.readString8();
1107             String8 value = data.readString8();
1108             reply->writeInt32(setPropertyString(name, value));
1109             return OK;
1110         }
1111 
1112         case SET_PROPERTY_BYTE_ARRAY:
1113         {
1114             CHECK_INTERFACE(IDrm, data, reply);
1115             String8 name = data.readString8();
1116             Vector<uint8_t> value;
1117             readVector(data, value);
1118             reply->writeInt32(setPropertyByteArray(name, value));
1119             return OK;
1120         }
1121 
1122         case GET_METRICS:
1123         {
1124             CHECK_INTERFACE(IDrm, data, reply);
1125 
1126             os::PersistableBundle metrics;
1127             status_t result = getMetrics(&metrics);
1128             // The reply data is ordered as
1129             // 1) 32 bit integer reply followed by
1130             // 2) Serialized PersistableBundle containing metrics.
1131             // Only write the metrics if the getMetrics result was
1132             // OK and we successfully added the status to reply.
1133             status_t parcel_result = reply->writeInt32(result);
1134             if (result == OK && parcel_result == OK) {
1135                 parcel_result = metrics.writeToParcel(reply);
1136             }
1137             return parcel_result;
1138         }
1139 
1140         case SET_CIPHER_ALGORITHM:
1141         {
1142             CHECK_INTERFACE(IDrm, data, reply);
1143             Vector<uint8_t> sessionId;
1144             readVector(data, sessionId);
1145             String8 algorithm = data.readString8();
1146             reply->writeInt32(setCipherAlgorithm(sessionId, algorithm));
1147             return OK;
1148         }
1149 
1150         case SET_MAC_ALGORITHM:
1151         {
1152             CHECK_INTERFACE(IDrm, data, reply);
1153             Vector<uint8_t> sessionId;
1154             readVector(data, sessionId);
1155             String8 algorithm = data.readString8();
1156             reply->writeInt32(setMacAlgorithm(sessionId, algorithm));
1157             return OK;
1158         }
1159 
1160         case ENCRYPT:
1161         {
1162             CHECK_INTERFACE(IDrm, data, reply);
1163             Vector<uint8_t> sessionId, keyId, input, iv, output;
1164             readVector(data, sessionId);
1165             readVector(data, keyId);
1166             readVector(data, input);
1167             readVector(data, iv);
1168             uint32_t result = encrypt(sessionId, keyId, input, iv, output);
1169             writeVector(reply, output);
1170             reply->writeInt32(result);
1171             return OK;
1172         }
1173 
1174         case DECRYPT:
1175         {
1176             CHECK_INTERFACE(IDrm, data, reply);
1177             Vector<uint8_t> sessionId, keyId, input, iv, output;
1178             readVector(data, sessionId);
1179             readVector(data, keyId);
1180             readVector(data, input);
1181             readVector(data, iv);
1182             uint32_t result = decrypt(sessionId, keyId, input, iv, output);
1183             writeVector(reply, output);
1184             reply->writeInt32(result);
1185             return OK;
1186         }
1187 
1188         case SIGN:
1189         {
1190             CHECK_INTERFACE(IDrm, data, reply);
1191             Vector<uint8_t> sessionId, keyId, message, signature;
1192             readVector(data, sessionId);
1193             readVector(data, keyId);
1194             readVector(data, message);
1195             uint32_t result = sign(sessionId, keyId, message, signature);
1196             writeVector(reply, signature);
1197             reply->writeInt32(result);
1198             return OK;
1199         }
1200 
1201         case VERIFY:
1202         {
1203             CHECK_INTERFACE(IDrm, data, reply);
1204             Vector<uint8_t> sessionId, keyId, message, signature;
1205             readVector(data, sessionId);
1206             readVector(data, keyId);
1207             readVector(data, message);
1208             readVector(data, signature);
1209             bool match = false;
1210             uint32_t result = verify(sessionId, keyId, message, signature, match);
1211             reply->writeInt32(match);
1212             reply->writeInt32(result);
1213             return OK;
1214         }
1215 
1216         case SIGN_RSA:
1217         {
1218             CHECK_INTERFACE(IDrm, data, reply);
1219             Vector<uint8_t> sessionId, message, wrappedKey, signature;
1220             readVector(data, sessionId);
1221             String8 algorithm = data.readString8();
1222             readVector(data, message);
1223             readVector(data, wrappedKey);
1224             uint32_t result = signRSA(sessionId, algorithm, message, wrappedKey, signature);
1225             writeVector(reply, signature);
1226             reply->writeInt32(result);
1227             return OK;
1228         }
1229 
1230     case SET_LISTENER: {
1231         CHECK_INTERFACE(IDrm, data, reply);
1232         sp<IDrmClient> listener =
1233             interface_cast<IDrmClient>(data.readStrongBinder());
1234         reply->writeInt32(setListener(listener));
1235         return NO_ERROR;
1236     } break;
1237 
1238     default:
1239         return BBinder::onTransact(code, data, reply, flags);
1240     }
1241 }
1242 
1243 }  // namespace android
1244