IDrm.cpp revision 68d9d71a792deed75d32fe13febc07c9c12c8449
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/IDrm.h> 23#include <media/stagefright/MediaErrors.h> 24#include <media/stagefright/foundation/ADebug.h> 25#include <media/stagefright/foundation/AString.h> 26 27namespace android { 28 29enum { 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 SET_CIPHER_ALGORITHM, 50 SET_MAC_ALGORITHM, 51 ENCRYPT, 52 DECRYPT, 53 SIGN, 54 SIGN_RSA, 55 VERIFY, 56 SET_LISTENER 57}; 58 59struct BpDrm : public BpInterface<IDrm> { 60 BpDrm(const sp<IBinder> &impl) 61 : BpInterface<IDrm>(impl) { 62 } 63 64 virtual status_t initCheck() const { 65 Parcel data, reply; 66 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 67 remote()->transact(INIT_CHECK, data, &reply); 68 69 return reply.readInt32(); 70 } 71 72 virtual bool isCryptoSchemeSupported(const uint8_t uuid[16], const String8 &mimeType) { 73 Parcel data, reply; 74 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 75 data.write(uuid, 16); 76 data.writeString8(mimeType); 77 remote()->transact(IS_CRYPTO_SUPPORTED, data, &reply); 78 79 return reply.readInt32() != 0; 80 } 81 82 virtual status_t createPlugin(const uint8_t uuid[16]) { 83 Parcel data, reply; 84 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 85 data.write(uuid, 16); 86 87 remote()->transact(CREATE_PLUGIN, data, &reply); 88 89 return reply.readInt32(); 90 } 91 92 virtual status_t destroyPlugin() { 93 Parcel data, reply; 94 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 95 remote()->transact(DESTROY_PLUGIN, data, &reply); 96 97 return reply.readInt32(); 98 } 99 100 virtual status_t openSession(Vector<uint8_t> &sessionId) { 101 Parcel data, reply; 102 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 103 104 remote()->transact(OPEN_SESSION, data, &reply); 105 readVector(reply, sessionId); 106 107 return reply.readInt32(); 108 } 109 110 virtual status_t closeSession(Vector<uint8_t> const &sessionId) { 111 Parcel data, reply; 112 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 113 114 writeVector(data, sessionId); 115 remote()->transact(CLOSE_SESSION, data, &reply); 116 117 return reply.readInt32(); 118 } 119 120 virtual status_t 121 getKeyRequest(Vector<uint8_t> const &sessionId, 122 Vector<uint8_t> const &initData, 123 String8 const &mimeType, DrmPlugin::KeyType keyType, 124 KeyedVector<String8, String8> const &optionalParameters, 125 Vector<uint8_t> &request, String8 &defaultUrl) { 126 Parcel data, reply; 127 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 128 129 writeVector(data, sessionId); 130 writeVector(data, initData); 131 data.writeString8(mimeType); 132 data.writeInt32((uint32_t)keyType); 133 134 data.writeInt32(optionalParameters.size()); 135 for (size_t i = 0; i < optionalParameters.size(); ++i) { 136 data.writeString8(optionalParameters.keyAt(i)); 137 data.writeString8(optionalParameters.valueAt(i)); 138 } 139 remote()->transact(GET_KEY_REQUEST, data, &reply); 140 141 readVector(reply, request); 142 defaultUrl = reply.readString8(); 143 144 return reply.readInt32(); 145 } 146 147 virtual status_t provideKeyResponse(Vector<uint8_t> const &sessionId, 148 Vector<uint8_t> const &response, 149 Vector<uint8_t> &keySetId) { 150 Parcel data, reply; 151 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 152 writeVector(data, sessionId); 153 writeVector(data, response); 154 remote()->transact(PROVIDE_KEY_RESPONSE, data, &reply); 155 readVector(reply, keySetId); 156 157 return reply.readInt32(); 158 } 159 160 virtual status_t removeKeys(Vector<uint8_t> const &keySetId) { 161 Parcel data, reply; 162 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 163 164 writeVector(data, keySetId); 165 remote()->transact(REMOVE_KEYS, data, &reply); 166 167 return reply.readInt32(); 168 } 169 170 virtual status_t restoreKeys(Vector<uint8_t> const &sessionId, 171 Vector<uint8_t> const &keySetId) { 172 Parcel data, reply; 173 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 174 175 writeVector(data, sessionId); 176 writeVector(data, keySetId); 177 remote()->transact(RESTORE_KEYS, data, &reply); 178 179 return reply.readInt32(); 180 } 181 182 virtual status_t queryKeyStatus(Vector<uint8_t> const &sessionId, 183 KeyedVector<String8, String8> &infoMap) const { 184 Parcel data, reply; 185 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 186 187 writeVector(data, sessionId); 188 remote()->transact(QUERY_KEY_STATUS, data, &reply); 189 190 infoMap.clear(); 191 size_t count = reply.readInt32(); 192 for (size_t i = 0; i < count; i++) { 193 String8 key = reply.readString8(); 194 String8 value = reply.readString8(); 195 infoMap.add(key, value); 196 } 197 return reply.readInt32(); 198 } 199 200 virtual status_t getProvisionRequest(String8 const &certType, 201 String8 const &certAuthority, 202 Vector<uint8_t> &request, 203 String8 &defaultUrl) { 204 Parcel data, reply; 205 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 206 207 data.writeString8(certType); 208 data.writeString8(certAuthority); 209 remote()->transact(GET_PROVISION_REQUEST, data, &reply); 210 211 readVector(reply, request); 212 defaultUrl = reply.readString8(); 213 214 return reply.readInt32(); 215 } 216 217 virtual status_t provideProvisionResponse(Vector<uint8_t> const &response, 218 Vector<uint8_t> &certificate, 219 Vector<uint8_t> &wrappedKey) { 220 Parcel data, reply; 221 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 222 223 writeVector(data, response); 224 remote()->transact(PROVIDE_PROVISION_RESPONSE, data, &reply); 225 226 readVector(reply, certificate); 227 readVector(reply, wrappedKey); 228 229 return reply.readInt32(); 230 } 231 232 virtual status_t getSecureStops(List<Vector<uint8_t> > &secureStops) { 233 Parcel data, reply; 234 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 235 236 remote()->transact(GET_SECURE_STOPS, data, &reply); 237 238 secureStops.clear(); 239 uint32_t count = reply.readInt32(); 240 for (size_t i = 0; i < count; i++) { 241 Vector<uint8_t> secureStop; 242 readVector(reply, secureStop); 243 secureStops.push_back(secureStop); 244 } 245 return reply.readInt32(); 246 } 247 248 virtual status_t releaseSecureStops(Vector<uint8_t> const &ssRelease) { 249 Parcel data, reply; 250 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 251 252 writeVector(data, ssRelease); 253 remote()->transact(RELEASE_SECURE_STOPS, data, &reply); 254 255 return reply.readInt32(); 256 } 257 258 virtual status_t getPropertyString(String8 const &name, String8 &value) const { 259 Parcel data, reply; 260 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 261 262 data.writeString8(name); 263 remote()->transact(GET_PROPERTY_STRING, data, &reply); 264 265 value = reply.readString8(); 266 return reply.readInt32(); 267 } 268 269 virtual status_t getPropertyByteArray(String8 const &name, Vector<uint8_t> &value) const { 270 Parcel data, reply; 271 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 272 273 data.writeString8(name); 274 remote()->transact(GET_PROPERTY_BYTE_ARRAY, data, &reply); 275 276 readVector(reply, value); 277 return reply.readInt32(); 278 } 279 280 virtual status_t setPropertyString(String8 const &name, String8 const &value) const { 281 Parcel data, reply; 282 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 283 284 data.writeString8(name); 285 data.writeString8(value); 286 remote()->transact(SET_PROPERTY_STRING, data, &reply); 287 288 return reply.readInt32(); 289 } 290 291 virtual status_t setPropertyByteArray(String8 const &name, 292 Vector<uint8_t> const &value) const { 293 Parcel data, reply; 294 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 295 296 data.writeString8(name); 297 writeVector(data, value); 298 remote()->transact(SET_PROPERTY_BYTE_ARRAY, data, &reply); 299 300 return reply.readInt32(); 301 } 302 303 304 virtual status_t setCipherAlgorithm(Vector<uint8_t> const &sessionId, 305 String8 const &algorithm) { 306 Parcel data, reply; 307 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 308 309 writeVector(data, sessionId); 310 data.writeString8(algorithm); 311 remote()->transact(SET_CIPHER_ALGORITHM, data, &reply); 312 return reply.readInt32(); 313 } 314 315 virtual status_t setMacAlgorithm(Vector<uint8_t> const &sessionId, 316 String8 const &algorithm) { 317 Parcel data, reply; 318 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 319 320 writeVector(data, sessionId); 321 data.writeString8(algorithm); 322 remote()->transact(SET_MAC_ALGORITHM, data, &reply); 323 return reply.readInt32(); 324 } 325 326 virtual status_t encrypt(Vector<uint8_t> const &sessionId, 327 Vector<uint8_t> const &keyId, 328 Vector<uint8_t> const &input, 329 Vector<uint8_t> const &iv, 330 Vector<uint8_t> &output) { 331 Parcel data, reply; 332 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 333 334 writeVector(data, sessionId); 335 writeVector(data, keyId); 336 writeVector(data, input); 337 writeVector(data, iv); 338 339 remote()->transact(ENCRYPT, data, &reply); 340 readVector(reply, output); 341 342 return reply.readInt32(); 343 } 344 345 virtual status_t decrypt(Vector<uint8_t> const &sessionId, 346 Vector<uint8_t> const &keyId, 347 Vector<uint8_t> const &input, 348 Vector<uint8_t> const &iv, 349 Vector<uint8_t> &output) { 350 Parcel data, reply; 351 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 352 353 writeVector(data, sessionId); 354 writeVector(data, keyId); 355 writeVector(data, input); 356 writeVector(data, iv); 357 358 remote()->transact(DECRYPT, data, &reply); 359 readVector(reply, output); 360 361 return reply.readInt32(); 362 } 363 364 virtual status_t sign(Vector<uint8_t> const &sessionId, 365 Vector<uint8_t> const &keyId, 366 Vector<uint8_t> const &message, 367 Vector<uint8_t> &signature) { 368 Parcel data, reply; 369 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 370 371 writeVector(data, sessionId); 372 writeVector(data, keyId); 373 writeVector(data, message); 374 375 remote()->transact(SIGN, data, &reply); 376 readVector(reply, signature); 377 378 return reply.readInt32(); 379 } 380 381 virtual status_t verify(Vector<uint8_t> const &sessionId, 382 Vector<uint8_t> const &keyId, 383 Vector<uint8_t> const &message, 384 Vector<uint8_t> const &signature, 385 bool &match) { 386 Parcel data, reply; 387 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 388 389 writeVector(data, sessionId); 390 writeVector(data, keyId); 391 writeVector(data, message); 392 writeVector(data, signature); 393 394 remote()->transact(VERIFY, data, &reply); 395 match = (bool)reply.readInt32(); 396 return reply.readInt32(); 397 } 398 399 virtual status_t signRSA(Vector<uint8_t> const &sessionId, 400 String8 const &algorithm, 401 Vector<uint8_t> const &message, 402 Vector<uint8_t> const &wrappedKey, 403 Vector<uint8_t> &signature) { 404 Parcel data, reply; 405 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 406 407 writeVector(data, sessionId); 408 data.writeString8(algorithm); 409 writeVector(data, message); 410 writeVector(data, wrappedKey); 411 412 remote()->transact(SIGN_RSA, data, &reply); 413 readVector(reply, signature); 414 415 return reply.readInt32(); 416 } 417 418 virtual status_t setListener(const sp<IDrmClient>& listener) { 419 Parcel data, reply; 420 data.writeInterfaceToken(IDrm::getInterfaceDescriptor()); 421 data.writeStrongBinder(listener->asBinder()); 422 remote()->transact(SET_LISTENER, data, &reply); 423 return reply.readInt32(); 424 } 425 426private: 427 void readVector(Parcel &reply, Vector<uint8_t> &vector) const { 428 uint32_t size = reply.readInt32(); 429 vector.insertAt((size_t)0, size); 430 reply.read(vector.editArray(), size); 431 } 432 433 void writeVector(Parcel &data, Vector<uint8_t> const &vector) const { 434 data.writeInt32(vector.size()); 435 data.write(vector.array(), vector.size()); 436 } 437 438 DISALLOW_EVIL_CONSTRUCTORS(BpDrm); 439}; 440 441IMPLEMENT_META_INTERFACE(Drm, "android.drm.IDrm"); 442 443//////////////////////////////////////////////////////////////////////////////// 444 445void BnDrm::readVector(const Parcel &data, Vector<uint8_t> &vector) const { 446 uint32_t size = data.readInt32(); 447 vector.insertAt((size_t)0, size); 448 data.read(vector.editArray(), size); 449} 450 451void BnDrm::writeVector(Parcel *reply, Vector<uint8_t> const &vector) const { 452 reply->writeInt32(vector.size()); 453 reply->write(vector.array(), vector.size()); 454} 455 456status_t BnDrm::onTransact( 457 uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) { 458 switch (code) { 459 case INIT_CHECK: 460 { 461 CHECK_INTERFACE(IDrm, data, reply); 462 reply->writeInt32(initCheck()); 463 return OK; 464 } 465 466 case IS_CRYPTO_SUPPORTED: 467 { 468 CHECK_INTERFACE(IDrm, data, reply); 469 uint8_t uuid[16]; 470 data.read(uuid, sizeof(uuid)); 471 String8 mimeType = data.readString8(); 472 reply->writeInt32(isCryptoSchemeSupported(uuid, mimeType)); 473 474 return OK; 475 } 476 477 case CREATE_PLUGIN: 478 { 479 CHECK_INTERFACE(IDrm, data, reply); 480 uint8_t uuid[16]; 481 data.read(uuid, sizeof(uuid)); 482 reply->writeInt32(createPlugin(uuid)); 483 return OK; 484 } 485 486 case DESTROY_PLUGIN: 487 { 488 CHECK_INTERFACE(IDrm, data, reply); 489 reply->writeInt32(destroyPlugin()); 490 return OK; 491 } 492 493 case OPEN_SESSION: 494 { 495 CHECK_INTERFACE(IDrm, data, reply); 496 Vector<uint8_t> sessionId; 497 status_t result = openSession(sessionId); 498 writeVector(reply, sessionId); 499 reply->writeInt32(result); 500 return OK; 501 } 502 503 case CLOSE_SESSION: 504 { 505 CHECK_INTERFACE(IDrm, data, reply); 506 Vector<uint8_t> sessionId; 507 readVector(data, sessionId); 508 reply->writeInt32(closeSession(sessionId)); 509 return OK; 510 } 511 512 case GET_KEY_REQUEST: 513 { 514 CHECK_INTERFACE(IDrm, data, reply); 515 Vector<uint8_t> sessionId, initData; 516 517 readVector(data, sessionId); 518 readVector(data, initData); 519 String8 mimeType = data.readString8(); 520 DrmPlugin::KeyType keyType = (DrmPlugin::KeyType)data.readInt32(); 521 522 KeyedVector<String8, String8> optionalParameters; 523 uint32_t count = data.readInt32(); 524 for (size_t i = 0; i < count; ++i) { 525 String8 key, value; 526 key = data.readString8(); 527 value = data.readString8(); 528 optionalParameters.add(key, value); 529 } 530 531 Vector<uint8_t> request; 532 String8 defaultUrl; 533 534 status_t result = getKeyRequest(sessionId, initData, 535 mimeType, keyType, 536 optionalParameters, 537 request, defaultUrl); 538 writeVector(reply, request); 539 reply->writeString8(defaultUrl); 540 reply->writeInt32(result); 541 return OK; 542 } 543 544 case PROVIDE_KEY_RESPONSE: 545 { 546 CHECK_INTERFACE(IDrm, data, reply); 547 Vector<uint8_t> sessionId, response, keySetId; 548 readVector(data, sessionId); 549 readVector(data, response); 550 uint32_t result = provideKeyResponse(sessionId, response, keySetId); 551 writeVector(reply, keySetId); 552 reply->writeInt32(result); 553 return OK; 554 } 555 556 case REMOVE_KEYS: 557 { 558 CHECK_INTERFACE(IDrm, data, reply); 559 Vector<uint8_t> keySetId; 560 readVector(data, keySetId); 561 reply->writeInt32(removeKeys(keySetId)); 562 return OK; 563 } 564 565 case RESTORE_KEYS: 566 { 567 CHECK_INTERFACE(IDrm, data, reply); 568 Vector<uint8_t> sessionId, keySetId; 569 readVector(data, sessionId); 570 readVector(data, keySetId); 571 reply->writeInt32(restoreKeys(sessionId, keySetId)); 572 return OK; 573 } 574 575 case QUERY_KEY_STATUS: 576 { 577 CHECK_INTERFACE(IDrm, data, reply); 578 Vector<uint8_t> sessionId; 579 readVector(data, sessionId); 580 KeyedVector<String8, String8> infoMap; 581 status_t result = queryKeyStatus(sessionId, infoMap); 582 size_t count = infoMap.size(); 583 reply->writeInt32(count); 584 for (size_t i = 0; i < count; ++i) { 585 reply->writeString8(infoMap.keyAt(i)); 586 reply->writeString8(infoMap.valueAt(i)); 587 } 588 reply->writeInt32(result); 589 return OK; 590 } 591 592 case GET_PROVISION_REQUEST: 593 { 594 CHECK_INTERFACE(IDrm, data, reply); 595 String8 certType = data.readString8(); 596 String8 certAuthority = data.readString8(); 597 598 Vector<uint8_t> request; 599 String8 defaultUrl; 600 status_t result = getProvisionRequest(certType, certAuthority, 601 request, defaultUrl); 602 writeVector(reply, request); 603 reply->writeString8(defaultUrl); 604 reply->writeInt32(result); 605 return OK; 606 } 607 608 case PROVIDE_PROVISION_RESPONSE: 609 { 610 CHECK_INTERFACE(IDrm, data, reply); 611 Vector<uint8_t> response; 612 Vector<uint8_t> certificate; 613 Vector<uint8_t> wrappedKey; 614 readVector(data, response); 615 status_t result = provideProvisionResponse(response, certificate, wrappedKey); 616 writeVector(reply, certificate); 617 writeVector(reply, wrappedKey); 618 reply->writeInt32(result); 619 return OK; 620 } 621 622 case GET_SECURE_STOPS: 623 { 624 CHECK_INTERFACE(IDrm, data, reply); 625 List<Vector<uint8_t> > secureStops; 626 status_t result = getSecureStops(secureStops); 627 size_t count = secureStops.size(); 628 reply->writeInt32(count); 629 List<Vector<uint8_t> >::iterator iter = secureStops.begin(); 630 while(iter != secureStops.end()) { 631 size_t size = iter->size(); 632 reply->writeInt32(size); 633 reply->write(iter->array(), iter->size()); 634 iter++; 635 } 636 reply->writeInt32(result); 637 return OK; 638 } 639 640 case RELEASE_SECURE_STOPS: 641 { 642 CHECK_INTERFACE(IDrm, data, reply); 643 Vector<uint8_t> ssRelease; 644 readVector(data, ssRelease); 645 reply->writeInt32(releaseSecureStops(ssRelease)); 646 return OK; 647 } 648 649 case GET_PROPERTY_STRING: 650 { 651 CHECK_INTERFACE(IDrm, data, reply); 652 String8 name = data.readString8(); 653 String8 value; 654 status_t result = getPropertyString(name, value); 655 reply->writeString8(value); 656 reply->writeInt32(result); 657 return OK; 658 } 659 660 case GET_PROPERTY_BYTE_ARRAY: 661 { 662 CHECK_INTERFACE(IDrm, data, reply); 663 String8 name = data.readString8(); 664 Vector<uint8_t> value; 665 status_t result = getPropertyByteArray(name, value); 666 writeVector(reply, value); 667 reply->writeInt32(result); 668 return OK; 669 } 670 671 case SET_PROPERTY_STRING: 672 { 673 CHECK_INTERFACE(IDrm, data, reply); 674 String8 name = data.readString8(); 675 String8 value = data.readString8(); 676 reply->writeInt32(setPropertyString(name, value)); 677 return OK; 678 } 679 680 case SET_PROPERTY_BYTE_ARRAY: 681 { 682 CHECK_INTERFACE(IDrm, data, reply); 683 String8 name = data.readString8(); 684 Vector<uint8_t> value; 685 readVector(data, value); 686 reply->writeInt32(setPropertyByteArray(name, value)); 687 return OK; 688 } 689 690 case SET_CIPHER_ALGORITHM: 691 { 692 CHECK_INTERFACE(IDrm, data, reply); 693 Vector<uint8_t> sessionId; 694 readVector(data, sessionId); 695 String8 algorithm = data.readString8(); 696 reply->writeInt32(setCipherAlgorithm(sessionId, algorithm)); 697 return OK; 698 } 699 700 case SET_MAC_ALGORITHM: 701 { 702 CHECK_INTERFACE(IDrm, data, reply); 703 Vector<uint8_t> sessionId; 704 readVector(data, sessionId); 705 String8 algorithm = data.readString8(); 706 reply->writeInt32(setMacAlgorithm(sessionId, algorithm)); 707 return OK; 708 } 709 710 case ENCRYPT: 711 { 712 CHECK_INTERFACE(IDrm, data, reply); 713 Vector<uint8_t> sessionId, keyId, input, iv, output; 714 readVector(data, sessionId); 715 readVector(data, keyId); 716 readVector(data, input); 717 readVector(data, iv); 718 uint32_t result = encrypt(sessionId, keyId, input, iv, output); 719 writeVector(reply, output); 720 reply->writeInt32(result); 721 return OK; 722 } 723 724 case DECRYPT: 725 { 726 CHECK_INTERFACE(IDrm, data, reply); 727 Vector<uint8_t> sessionId, keyId, input, iv, output; 728 readVector(data, sessionId); 729 readVector(data, keyId); 730 readVector(data, input); 731 readVector(data, iv); 732 uint32_t result = decrypt(sessionId, keyId, input, iv, output); 733 writeVector(reply, output); 734 reply->writeInt32(result); 735 return OK; 736 } 737 738 case SIGN: 739 { 740 CHECK_INTERFACE(IDrm, data, reply); 741 Vector<uint8_t> sessionId, keyId, message, signature; 742 readVector(data, sessionId); 743 readVector(data, keyId); 744 readVector(data, message); 745 uint32_t result = sign(sessionId, keyId, message, signature); 746 writeVector(reply, signature); 747 reply->writeInt32(result); 748 return OK; 749 } 750 751 case VERIFY: 752 { 753 CHECK_INTERFACE(IDrm, data, reply); 754 Vector<uint8_t> sessionId, keyId, message, signature; 755 readVector(data, sessionId); 756 readVector(data, keyId); 757 readVector(data, message); 758 readVector(data, signature); 759 bool match; 760 uint32_t result = verify(sessionId, keyId, message, signature, match); 761 reply->writeInt32(match); 762 reply->writeInt32(result); 763 return OK; 764 } 765 766 case SIGN_RSA: 767 { 768 CHECK_INTERFACE(IDrm, data, reply); 769 Vector<uint8_t> sessionId, message, wrappedKey, signature; 770 readVector(data, sessionId); 771 String8 algorithm = data.readString8(); 772 readVector(data, message); 773 readVector(data, wrappedKey); 774 uint32_t result = signRSA(sessionId, algorithm, message, wrappedKey, signature); 775 writeVector(reply, signature); 776 reply->writeInt32(result); 777 return OK; 778 } 779 780 case SET_LISTENER: { 781 CHECK_INTERFACE(IDrm, data, reply); 782 sp<IDrmClient> listener = 783 interface_cast<IDrmClient>(data.readStrongBinder()); 784 reply->writeInt32(setListener(listener)); 785 return NO_ERROR; 786 } break; 787 788 default: 789 return BBinder::onTransact(code, data, reply, flags); 790 } 791} 792 793} // namespace android 794 795