1 /* 2 * Copyright 2017, Rockchip Electronics Co., Ltd 3 * hisping lin, <hisping.lin@rock-chips.com> 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #include <common.h> 9 #include <optee_include/OpteeClientApiLib.h> 10 #include <optee_include/tee_client_api.h> 11 12 void test_optee(void) 13 { 14 TEEC_Result TeecResult; 15 TEEC_Context TeecContext; 16 TEEC_Session TeecSession; 17 uint32_t ErrorOrigin; 18 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 19 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 20 TEEC_UUID *TeecUuid = &tempuuid; 21 TEEC_Operation TeecOperation = {0}; 22 23 debug("testmm start\n"); 24 OpteeClientApiLibInitialize(); 25 26 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 27 28 TeecResult = TEEC_OpenSession(&TeecContext, 29 &TeecSession, 30 TeecUuid, 31 TEEC_LOGIN_PUBLIC, 32 NULL, 33 NULL, 34 &ErrorOrigin); 35 36 TEEC_SharedMemory SharedMem0 = {0}; 37 38 SharedMem0.size = sizeof("filename_test"); 39 SharedMem0.flags = 0; 40 41 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 42 43 memcpy(SharedMem0.buffer, "filename_test", SharedMem0.size); 44 45 TEEC_SharedMemory SharedMem1 = {0}; 46 47 SharedMem1.size = 32; 48 SharedMem1.flags = 0; 49 50 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 51 52 memset(SharedMem1.buffer, 'a', SharedMem1.size); 53 54 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 55 TeecOperation.params[0].tmpref.size = SharedMem0.size; 56 57 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 58 TeecOperation.params[1].tmpref.size = SharedMem1.size; 59 60 61 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 62 TEEC_MEMREF_TEMP_INOUT, 63 TEEC_NONE, 64 TEEC_NONE); 65 66 TeecResult = TEEC_InvokeCommand(&TeecSession, 67 1, 68 &TeecOperation, 69 &ErrorOrigin); 70 71 TEEC_ReleaseSharedMemory(&SharedMem0); 72 TEEC_ReleaseSharedMemory(&SharedMem1); 73 74 TEEC_CloseSession(&TeecSession); 75 76 TEEC_FinalizeContext(&TeecContext); 77 78 debug("testmm end\n"); 79 debug("TeecResult %x\n", TeecResult); 80 } 81 82 static uint8_t b2hs_add_base(uint8_t in) 83 { 84 if (in > 9) 85 return in + 55; 86 else 87 return in + 48; 88 } 89 90 uint32_t b2hs(uint8_t *b, uint8_t *hs, uint32_t blen, uint32_t hslen) 91 { 92 uint32_t i = 0; 93 94 if (blen * 2 + 1 > hslen) 95 return 0; 96 97 for (; i < blen; i++) { 98 hs[i * 2 + 1] = b2hs_add_base(b[i] & 0xf); 99 hs[i * 2] = b2hs_add_base(b[i] >> 4); 100 } 101 hs[blen * 2] = 0; 102 103 return blen * 2; 104 } 105 106 107 uint32_t trusty_read_rollback_index(uint32_t slot, uint64_t *value) 108 { 109 TEEC_Result TeecResult; 110 TEEC_Context TeecContext; 111 TEEC_Session TeecSession; 112 uint32_t ErrorOrigin; 113 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 114 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 115 TEEC_UUID *TeecUuid = &tempuuid; 116 TEEC_Operation TeecOperation = {0}; 117 uint8_t hs[9]; 118 119 b2hs((uint8_t *)&slot, hs, 4, 9); 120 debug("testmm start\n"); 121 OpteeClientApiLibInitialize(); 122 123 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 124 125 TeecResult = TEEC_OpenSession(&TeecContext, 126 &TeecSession, 127 TeecUuid, 128 TEEC_LOGIN_PUBLIC, 129 NULL, 130 NULL, 131 &ErrorOrigin); 132 133 TEEC_SharedMemory SharedMem0 = {0}; 134 135 SharedMem0.size = 8; 136 SharedMem0.flags = 0; 137 138 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 139 140 memcpy(SharedMem0.buffer, hs, SharedMem0.size); 141 142 TEEC_SharedMemory SharedMem1 = {0}; 143 144 SharedMem1.size = 8; 145 SharedMem1.flags = 0; 146 147 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 148 149 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 150 TeecOperation.params[0].tmpref.size = SharedMem0.size; 151 152 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 153 TeecOperation.params[1].tmpref.size = SharedMem1.size; 154 155 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 156 TEEC_MEMREF_TEMP_INOUT, 157 TEEC_NONE, 158 TEEC_NONE); 159 160 TeecResult = TEEC_InvokeCommand(&TeecSession, 161 0, 162 &TeecOperation, 163 &ErrorOrigin); 164 if (TeecResult == TEEC_SUCCESS) 165 memcpy((char *)value, SharedMem1.buffer, SharedMem1.size); 166 167 TEEC_ReleaseSharedMemory(&SharedMem0); 168 TEEC_ReleaseSharedMemory(&SharedMem1); 169 170 TEEC_CloseSession(&TeecSession); 171 172 TEEC_FinalizeContext(&TeecContext); 173 174 debug("testmm end\n"); 175 return TeecResult; 176 } 177 178 uint32_t trusty_write_rollback_index(uint32_t slot, uint64_t value) 179 { 180 TEEC_Result TeecResult; 181 TEEC_Context TeecContext; 182 TEEC_Session TeecSession; 183 uint32_t ErrorOrigin; 184 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 185 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 186 TEEC_UUID *TeecUuid = &tempuuid; 187 TEEC_Operation TeecOperation = {0}; 188 uint8_t hs[9]; 189 b2hs((uint8_t *)&slot, hs, 4, 9); 190 OpteeClientApiLibInitialize(); 191 192 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 193 194 TeecResult = TEEC_OpenSession(&TeecContext, 195 &TeecSession, 196 TeecUuid, 197 TEEC_LOGIN_PUBLIC, 198 NULL, 199 NULL, 200 &ErrorOrigin); 201 202 TEEC_SharedMemory SharedMem0 = {0}; 203 204 SharedMem0.size = 8; 205 SharedMem0.flags = 0; 206 207 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 208 209 memcpy(SharedMem0.buffer, hs, SharedMem0.size); 210 211 TEEC_SharedMemory SharedMem1 = {0}; 212 213 SharedMem1.size = 8; 214 SharedMem1.flags = 0; 215 216 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 217 218 memcpy(SharedMem1.buffer, (char *)&value, SharedMem1.size); 219 220 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 221 TeecOperation.params[0].tmpref.size = SharedMem0.size; 222 223 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 224 TeecOperation.params[1].tmpref.size = SharedMem1.size; 225 226 227 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 228 TEEC_MEMREF_TEMP_INOUT, 229 TEEC_NONE, 230 TEEC_NONE); 231 232 TeecResult = TEEC_InvokeCommand(&TeecSession, 233 1, 234 &TeecOperation, 235 &ErrorOrigin); 236 237 TEEC_ReleaseSharedMemory(&SharedMem0); 238 TEEC_ReleaseSharedMemory(&SharedMem1); 239 240 TEEC_CloseSession(&TeecSession); 241 242 TEEC_FinalizeContext(&TeecContext); 243 244 debug("testmm end\n"); 245 246 return TeecResult; 247 } 248 249 uint32_t trusty_read_permanent_attributes(uint8_t *attributes, uint32_t size) 250 { 251 TEEC_Result TeecResult; 252 TEEC_Context TeecContext; 253 TEEC_Session TeecSession; 254 uint32_t ErrorOrigin; 255 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 256 { 0xa8, 0x69, 0x9c, 0xe6, 0x88, 0x6c, 0x5d, 0x5d } }; 257 TEEC_UUID *TeecUuid = &tempuuid; 258 TEEC_Operation TeecOperation = {0}; 259 260 debug("testmm start\n"); 261 OpteeClientApiLibInitialize(); 262 263 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 264 265 TeecResult = TEEC_OpenSession(&TeecContext, 266 &TeecSession, 267 TeecUuid, 268 TEEC_LOGIN_PUBLIC, 269 NULL, 270 NULL, 271 &ErrorOrigin); 272 273 TEEC_SharedMemory SharedMem0 = {0}; 274 275 SharedMem0.size = sizeof("attributes"); 276 SharedMem0.flags = 0; 277 278 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 279 280 memcpy(SharedMem0.buffer, "attributes", SharedMem0.size); 281 282 TEEC_SharedMemory SharedMem1 = {0}; 283 284 SharedMem1.size = size; 285 SharedMem1.flags = 0; 286 287 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 288 289 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 290 TeecOperation.params[0].tmpref.size = SharedMem0.size; 291 292 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 293 TeecOperation.params[1].tmpref.size = SharedMem1.size; 294 295 296 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 297 TEEC_MEMREF_TEMP_INOUT, 298 TEEC_NONE, 299 TEEC_NONE); 300 301 TeecResult = TEEC_InvokeCommand(&TeecSession, 302 142, 303 &TeecOperation, 304 &ErrorOrigin); 305 if (TeecResult == TEEC_SUCCESS) 306 memcpy(attributes, SharedMem1.buffer, SharedMem1.size); 307 TEEC_ReleaseSharedMemory(&SharedMem0); 308 TEEC_ReleaseSharedMemory(&SharedMem1); 309 TEEC_CloseSession(&TeecSession); 310 TEEC_FinalizeContext(&TeecContext); 311 debug("testmm end\n"); 312 313 return TeecResult; 314 } 315 316 uint32_t trusty_write_permanent_attributes(uint8_t *attributes, uint32_t size) 317 { 318 TEEC_Result TeecResult; 319 TEEC_Context TeecContext; 320 TEEC_Session TeecSession; 321 uint32_t ErrorOrigin; 322 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 323 { 0xa8, 0x69, 0x9c, 0xe6, 0x88, 0x6c, 0x5d, 0x5d } }; 324 TEEC_UUID *TeecUuid = &tempuuid; 325 TEEC_Operation TeecOperation = {0}; 326 327 debug("testmm start\n"); 328 OpteeClientApiLibInitialize(); 329 330 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 331 332 TeecResult = TEEC_OpenSession(&TeecContext, 333 &TeecSession, 334 TeecUuid, 335 TEEC_LOGIN_PUBLIC, 336 NULL, 337 NULL, 338 &ErrorOrigin); 339 340 TEEC_SharedMemory SharedMem0 = {0}; 341 342 SharedMem0.size = sizeof("attributes"); 343 SharedMem0.flags = 0; 344 345 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 346 347 memcpy(SharedMem0.buffer, "attributes", SharedMem0.size); 348 349 TEEC_SharedMemory SharedMem1 = {0}; 350 351 SharedMem1.size = size; 352 SharedMem1.flags = 0; 353 354 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 355 356 memcpy(SharedMem1.buffer, attributes, SharedMem1.size); 357 358 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 359 TeecOperation.params[0].tmpref.size = SharedMem0.size; 360 361 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 362 TeecOperation.params[1].tmpref.size = SharedMem1.size; 363 364 365 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 366 TEEC_MEMREF_TEMP_INOUT, 367 TEEC_NONE, 368 TEEC_NONE); 369 370 TeecResult = TEEC_InvokeCommand(&TeecSession, 371 141, 372 &TeecOperation, 373 &ErrorOrigin); 374 375 TEEC_ReleaseSharedMemory(&SharedMem0); 376 TEEC_ReleaseSharedMemory(&SharedMem1); 377 TEEC_CloseSession(&TeecSession); 378 TEEC_FinalizeContext(&TeecContext); 379 debug("testmm end\n"); 380 381 return TeecResult; 382 } 383 384 uint32_t trusty_read_lock_state(uint8_t *lock_state) 385 { 386 TEEC_Result TeecResult; 387 TEEC_Context TeecContext; 388 TEEC_Session TeecSession; 389 uint32_t ErrorOrigin; 390 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 391 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 392 TEEC_UUID *TeecUuid = &tempuuid; 393 TEEC_Operation TeecOperation = {0}; 394 395 debug("testmm start\n"); 396 OpteeClientApiLibInitialize(); 397 398 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 399 400 401 TeecResult = TEEC_OpenSession(&TeecContext, 402 &TeecSession, 403 TeecUuid, 404 TEEC_LOGIN_PUBLIC, 405 NULL, 406 NULL, 407 &ErrorOrigin); 408 409 TEEC_SharedMemory SharedMem0 = {0}; 410 411 SharedMem0.size = sizeof("lock_state"); 412 SharedMem0.flags = 0; 413 414 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 415 416 memcpy(SharedMem0.buffer, "lock_state", SharedMem0.size); 417 418 TEEC_SharedMemory SharedMem1 = {0}; 419 420 SharedMem1.size = 1; 421 SharedMem1.flags = 0; 422 423 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 424 425 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 426 TeecOperation.params[0].tmpref.size = SharedMem0.size; 427 428 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 429 TeecOperation.params[1].tmpref.size = SharedMem1.size; 430 431 432 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 433 TEEC_MEMREF_TEMP_INOUT, 434 TEEC_NONE, 435 TEEC_NONE); 436 437 TeecResult = TEEC_InvokeCommand(&TeecSession, 438 0, 439 &TeecOperation, 440 &ErrorOrigin); 441 if (TeecResult == TEEC_SUCCESS) 442 memcpy(lock_state, SharedMem1.buffer, SharedMem1.size); 443 TEEC_ReleaseSharedMemory(&SharedMem0); 444 TEEC_ReleaseSharedMemory(&SharedMem1); 445 TEEC_CloseSession(&TeecSession); 446 TEEC_FinalizeContext(&TeecContext); 447 debug("testmm end\n"); 448 449 return TeecResult; 450 } 451 452 uint32_t trusty_write_lock_state(uint8_t lock_state) 453 { 454 TEEC_Result TeecResult; 455 TEEC_Context TeecContext; 456 TEEC_Session TeecSession; 457 uint32_t ErrorOrigin; 458 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 459 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 460 TEEC_UUID *TeecUuid = &tempuuid; 461 TEEC_Operation TeecOperation = {0}; 462 463 debug("testmm start\n"); 464 OpteeClientApiLibInitialize(); 465 466 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 467 468 TeecResult = TEEC_OpenSession(&TeecContext, 469 &TeecSession, 470 TeecUuid, 471 TEEC_LOGIN_PUBLIC, 472 NULL, 473 NULL, 474 &ErrorOrigin); 475 476 TEEC_SharedMemory SharedMem0 = {0}; 477 478 SharedMem0.size = sizeof("lock_state"); 479 SharedMem0.flags = 0; 480 481 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 482 483 memcpy(SharedMem0.buffer, "lock_state", SharedMem0.size); 484 485 TEEC_SharedMemory SharedMem1 = {0}; 486 487 SharedMem1.size = 1; 488 SharedMem1.flags = 0; 489 490 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 491 492 memcpy(SharedMem1.buffer, &lock_state, SharedMem1.size); 493 494 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 495 TeecOperation.params[0].tmpref.size = SharedMem0.size; 496 497 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 498 TeecOperation.params[1].tmpref.size = SharedMem1.size; 499 500 501 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 502 TEEC_MEMREF_TEMP_INOUT, 503 TEEC_NONE, 504 TEEC_NONE); 505 506 TeecResult = TEEC_InvokeCommand(&TeecSession, 507 1, 508 &TeecOperation, 509 &ErrorOrigin); 510 511 TEEC_ReleaseSharedMemory(&SharedMem0); 512 TEEC_ReleaseSharedMemory(&SharedMem1); 513 TEEC_CloseSession(&TeecSession); 514 TEEC_FinalizeContext(&TeecContext); 515 debug("testmm end\n"); 516 517 return TeecResult; 518 } 519 520 uint32_t trusty_read_flash_lock_state(uint8_t *flash_lock_state) 521 { 522 TEEC_Result TeecResult; 523 TEEC_Context TeecContext; 524 TEEC_Session TeecSession; 525 uint32_t ErrorOrigin; 526 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 527 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 528 TEEC_UUID *TeecUuid = &tempuuid; 529 TEEC_Operation TeecOperation = {0}; 530 531 debug("testmm start\n"); 532 OpteeClientApiLibInitialize(); 533 534 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 535 536 537 TeecResult = TEEC_OpenSession(&TeecContext, 538 &TeecSession, 539 TeecUuid, 540 TEEC_LOGIN_PUBLIC, 541 NULL, 542 NULL, 543 &ErrorOrigin); 544 545 TEEC_SharedMemory SharedMem0 = {0}; 546 547 SharedMem0.size = sizeof("flash_lock_state"); 548 SharedMem0.flags = 0; 549 550 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 551 552 memcpy(SharedMem0.buffer, "flash_lock_state", SharedMem0.size); 553 554 TEEC_SharedMemory SharedMem1 = {0}; 555 556 SharedMem1.size = 1; 557 SharedMem1.flags = 0; 558 559 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 560 561 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 562 TeecOperation.params[0].tmpref.size = SharedMem0.size; 563 564 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 565 TeecOperation.params[1].tmpref.size = SharedMem1.size; 566 567 568 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 569 TEEC_MEMREF_TEMP_INOUT, 570 TEEC_NONE, 571 TEEC_NONE); 572 573 TeecResult = TEEC_InvokeCommand(&TeecSession, 574 0, 575 &TeecOperation, 576 &ErrorOrigin); 577 if (TeecResult == TEEC_SUCCESS) 578 memcpy(flash_lock_state, SharedMem1.buffer, SharedMem1.size); 579 TEEC_ReleaseSharedMemory(&SharedMem0); 580 TEEC_ReleaseSharedMemory(&SharedMem1); 581 TEEC_CloseSession(&TeecSession); 582 TEEC_FinalizeContext(&TeecContext); 583 debug("testmm end\n"); 584 585 return TeecResult; 586 } 587 588 589 uint32_t trusty_write_flash_lock_state(uint8_t flash_lock_state) 590 { 591 TEEC_Result TeecResult; 592 TEEC_Context TeecContext; 593 TEEC_Session TeecSession; 594 uint32_t ErrorOrigin; 595 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 596 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 597 TEEC_UUID *TeecUuid = &tempuuid; 598 TEEC_Operation TeecOperation = {0}; 599 600 debug("testmm start\n"); 601 OpteeClientApiLibInitialize(); 602 603 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 604 605 TeecResult = TEEC_OpenSession(&TeecContext, 606 &TeecSession, 607 TeecUuid, 608 TEEC_LOGIN_PUBLIC, 609 NULL, 610 NULL, 611 &ErrorOrigin); 612 613 TEEC_SharedMemory SharedMem0 = {0}; 614 615 SharedMem0.size = sizeof("flash_lock_state"); 616 SharedMem0.flags = 0; 617 618 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 619 620 memcpy(SharedMem0.buffer, "flash_lock_state", SharedMem0.size); 621 622 TEEC_SharedMemory SharedMem1 = {0}; 623 624 SharedMem1.size = 1; 625 SharedMem1.flags = 0; 626 627 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 628 629 memcpy(SharedMem1.buffer, &flash_lock_state, SharedMem1.size); 630 631 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 632 TeecOperation.params[0].tmpref.size = SharedMem0.size; 633 634 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 635 TeecOperation.params[1].tmpref.size = SharedMem1.size; 636 637 638 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 639 TEEC_MEMREF_TEMP_INOUT, 640 TEEC_NONE, 641 TEEC_NONE); 642 643 TeecResult = TEEC_InvokeCommand(&TeecSession, 644 1, 645 &TeecOperation, 646 &ErrorOrigin); 647 648 TEEC_ReleaseSharedMemory(&SharedMem0); 649 TEEC_ReleaseSharedMemory(&SharedMem1); 650 TEEC_CloseSession(&TeecSession); 651 TEEC_FinalizeContext(&TeecContext); 652 debug("testmm end\n"); 653 654 return TeecResult; 655 } 656 657 uint32_t write_to_keymaster(uint8_t *filename, 658 uint32_t filename_size, 659 uint8_t *data, 660 uint32_t data_size) 661 { 662 TEEC_Result TeecResult; 663 TEEC_Context TeecContext; 664 TEEC_Session TeecSession; 665 uint32_t ErrorOrigin; 666 667 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 668 { 0xa8, 0x69, 0x9c, 0xe6, 0x88, 0x6c, 0x5d, 0x5d } }; 669 TEEC_UUID *TeecUuid = &tempuuid; 670 TEEC_Operation TeecOperation = {0}; 671 672 debug("write_to_keymaster\n"); 673 OpteeClientApiLibInitialize(); 674 675 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 676 677 TeecResult = TEEC_OpenSession(&TeecContext, 678 &TeecSession, 679 TeecUuid, 680 TEEC_LOGIN_PUBLIC, 681 NULL, 682 NULL, 683 &ErrorOrigin); 684 685 TEEC_SharedMemory SharedMem0 = {0}; 686 687 SharedMem0.size = filename_size; 688 SharedMem0.flags = 0; 689 690 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 691 692 memcpy(SharedMem0.buffer, filename, SharedMem0.size); 693 694 TEEC_SharedMemory SharedMem1 = {0}; 695 696 SharedMem1.size = data_size; 697 SharedMem1.flags = 0; 698 699 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 700 701 memcpy(SharedMem1.buffer, data, SharedMem1.size); 702 703 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 704 TeecOperation.params[0].tmpref.size = SharedMem0.size; 705 706 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 707 TeecOperation.params[1].tmpref.size = SharedMem1.size; 708 709 710 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 711 TEEC_MEMREF_TEMP_INOUT, 712 TEEC_NONE, 713 TEEC_NONE); 714 715 TeecResult = TEEC_InvokeCommand(&TeecSession, 716 139, 717 &TeecOperation, 718 &ErrorOrigin); 719 720 TEEC_ReleaseSharedMemory(&SharedMem0); 721 TEEC_ReleaseSharedMemory(&SharedMem1); 722 TEEC_CloseSession(&TeecSession); 723 TEEC_FinalizeContext(&TeecContext); 724 debug("testmm end\n"); 725 debug("TeecResult %x\n", TeecResult); 726 727 return TeecResult; 728 } 729 730 uint32_t trusty_read_attribute_hash(uint32_t *buf, uint32_t length) 731 { 732 TEEC_Result TeecResult; 733 TEEC_Context TeecContext; 734 TEEC_Session TeecSession; 735 uint32_t ErrorOrigin; 736 737 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 738 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 739 TEEC_UUID *TeecUuid = &tempuuid; 740 TEEC_Operation TeecOperation = {0}; 741 742 OpteeClientApiLibInitialize(); 743 744 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 745 746 TeecResult = TEEC_OpenSession(&TeecContext, 747 &TeecSession, 748 TeecUuid, 749 TEEC_LOGIN_PUBLIC, 750 NULL, 751 NULL, 752 &ErrorOrigin); 753 754 TEEC_SharedMemory SharedMem0 = {0}; 755 756 SharedMem0.size = length * sizeof(uint32_t); 757 SharedMem0.flags = 0; 758 759 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 760 761 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 762 TeecOperation.params[0].tmpref.size = SharedMem0.size; 763 764 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, 765 TEEC_NONE, 766 TEEC_NONE, 767 TEEC_NONE); 768 769 TeecResult = TEEC_InvokeCommand(&TeecSession, 770 0, 771 &TeecOperation, 772 &ErrorOrigin); 773 774 if (TeecResult == TEEC_SUCCESS) 775 memcpy(buf, SharedMem0.buffer, SharedMem0.size); 776 777 TEEC_ReleaseSharedMemory(&SharedMem0); 778 TEEC_CloseSession(&TeecSession); 779 TEEC_FinalizeContext(&TeecContext); 780 781 return TeecResult; 782 } 783 784 uint32_t trusty_write_attribute_hash(uint32_t *buf, uint32_t length) 785 { 786 TEEC_Result TeecResult; 787 TEEC_Context TeecContext; 788 TEEC_Session TeecSession; 789 uint32_t ErrorOrigin; 790 791 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 792 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 793 TEEC_UUID *TeecUuid = &tempuuid; 794 TEEC_Operation TeecOperation = {0}; 795 796 OpteeClientApiLibInitialize(); 797 798 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 799 800 TeecResult = TEEC_OpenSession(&TeecContext, 801 &TeecSession, 802 TeecUuid, 803 TEEC_LOGIN_PUBLIC, 804 NULL, 805 NULL, 806 &ErrorOrigin); 807 808 TEEC_SharedMemory SharedMem0 = {0}; 809 810 SharedMem0.size = length * sizeof(uint32_t); 811 SharedMem0.flags = 0; 812 813 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 814 815 memcpy(SharedMem0.buffer, buf, SharedMem0.size); 816 817 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 818 TeecOperation.params[0].tmpref.size = SharedMem0.size; 819 820 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 821 TEEC_NONE, 822 TEEC_NONE, 823 TEEC_NONE); 824 825 TeecResult = TEEC_InvokeCommand(&TeecSession, 826 1, 827 &TeecOperation, 828 &ErrorOrigin); 829 830 TEEC_ReleaseSharedMemory(&SharedMem0); 831 TEEC_CloseSession(&TeecSession); 832 TEEC_FinalizeContext(&TeecContext); 833 834 return TeecResult; 835 } 836 837 uint32_t notify_optee_rpmb_ta(void) 838 { 839 TEEC_Result TeecResult; 840 TEEC_Context TeecContext; 841 TEEC_Session TeecSession; 842 uint32_t ErrorOrigin; 843 TEEC_UUID tempuuid = { 0x1b484ea5, 0x698b, 0x4142, 844 { 0x82, 0xb8, 0x3a, 0xcf, 0x16, 0xe9, 0x9e, 0x2a } }; 845 TEEC_UUID *TeecUuid = &tempuuid; 846 TEEC_Operation TeecOperation = {0}; 847 848 OpteeClientApiLibInitialize(); 849 850 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 851 852 TeecResult = TEEC_OpenSession(&TeecContext, 853 &TeecSession, 854 TeecUuid, 855 TEEC_LOGIN_PUBLIC, 856 NULL, 857 NULL, 858 &ErrorOrigin); 859 860 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, 861 TEEC_NONE, 862 TEEC_NONE, 863 TEEC_NONE); 864 865 TeecResult = TEEC_InvokeCommand(&TeecSession, 866 2, 867 &TeecOperation, 868 &ErrorOrigin); 869 870 TEEC_CloseSession(&TeecSession); 871 TEEC_FinalizeContext(&TeecContext); 872 873 return TeecResult; 874 } 875 876 uint32_t notify_optee_efuse_ta(void) 877 { 878 TEEC_Result TeecResult; 879 TEEC_Context TeecContext; 880 TEEC_Session TeecSession; 881 uint32_t ErrorOrigin; 882 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 883 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 884 885 TEEC_UUID *TeecUuid = &tempuuid; 886 TEEC_Operation TeecOperation = {0}; 887 888 OpteeClientApiLibInitialize(); 889 890 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 891 892 TeecResult = TEEC_OpenSession(&TeecContext, 893 &TeecSession, 894 TeecUuid, 895 TEEC_LOGIN_PUBLIC, 896 NULL, 897 NULL, 898 &ErrorOrigin); 899 900 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, 901 TEEC_NONE, 902 TEEC_NONE, 903 TEEC_NONE); 904 905 TeecResult = TEEC_InvokeCommand(&TeecSession, 906 2, 907 &TeecOperation, 908 &ErrorOrigin); 909 910 TEEC_CloseSession(&TeecSession); 911 TEEC_FinalizeContext(&TeecContext); 912 913 return TeecResult; 914 } 915 916 uint32_t trusty_notify_optee_uboot_end(void) 917 { 918 TEEC_Result res; 919 res = notify_optee_rpmb_ta(); 920 res |= notify_optee_efuse_ta(); 921 return res; 922 } 923 924 uint32_t trusty_read_vbootkey_hash(uint32_t *buf, uint32_t length) 925 { 926 TEEC_Result TeecResult; 927 TEEC_Context TeecContext; 928 TEEC_Session TeecSession; 929 uint32_t ErrorOrigin; 930 931 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 932 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 933 TEEC_UUID *TeecUuid = &tempuuid; 934 TEEC_Operation TeecOperation = {0}; 935 936 OpteeClientApiLibInitialize(); 937 938 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 939 940 TeecResult = TEEC_OpenSession(&TeecContext, 941 &TeecSession, 942 TeecUuid, 943 TEEC_LOGIN_PUBLIC, 944 NULL, 945 NULL, 946 &ErrorOrigin); 947 948 TEEC_SharedMemory SharedMem0 = {0}; 949 950 SharedMem0.size = length * sizeof(uint32_t); 951 SharedMem0.flags = 0; 952 953 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 954 955 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 956 TeecOperation.params[0].tmpref.size = SharedMem0.size; 957 958 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, 959 TEEC_NONE, 960 TEEC_NONE, 961 TEEC_NONE); 962 963 TeecResult = TEEC_InvokeCommand(&TeecSession, 964 3, 965 &TeecOperation, 966 &ErrorOrigin); 967 968 if (TeecResult == TEEC_SUCCESS) 969 memcpy(buf, SharedMem0.buffer, SharedMem0.size); 970 971 TEEC_ReleaseSharedMemory(&SharedMem0); 972 TEEC_CloseSession(&TeecSession); 973 TEEC_FinalizeContext(&TeecContext); 974 975 return TeecResult; 976 } 977 uint32_t trusty_write_vbootkey_hash(uint32_t *buf, uint32_t length) 978 { 979 TEEC_Result TeecResult; 980 TEEC_Context TeecContext; 981 TEEC_Session TeecSession; 982 uint32_t ErrorOrigin; 983 984 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 985 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 986 TEEC_UUID *TeecUuid = &tempuuid; 987 TEEC_Operation TeecOperation = {0}; 988 989 OpteeClientApiLibInitialize(); 990 991 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 992 993 TeecResult = TEEC_OpenSession(&TeecContext, 994 &TeecSession, 995 TeecUuid, 996 TEEC_LOGIN_PUBLIC, 997 NULL, 998 NULL, 999 &ErrorOrigin); 1000 1001 TEEC_SharedMemory SharedMem0 = {0}; 1002 1003 SharedMem0.size = length * sizeof(uint32_t); 1004 SharedMem0.flags = 0; 1005 1006 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1007 1008 memcpy(SharedMem0.buffer, buf, SharedMem0.size); 1009 1010 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1011 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1012 1013 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1014 TEEC_NONE, 1015 TEEC_NONE, 1016 TEEC_NONE); 1017 1018 TeecResult = TEEC_InvokeCommand(&TeecSession, 1019 4, 1020 &TeecOperation, 1021 &ErrorOrigin); 1022 1023 TEEC_ReleaseSharedMemory(&SharedMem0); 1024 TEEC_CloseSession(&TeecSession); 1025 TEEC_FinalizeContext(&TeecContext); 1026 1027 return TeecResult; 1028 } 1029 1030 uint32_t trusty_read_vbootkey_enable_flag(uint8_t *flag) 1031 { 1032 TEEC_Result TeecResult; 1033 TEEC_Context TeecContext; 1034 TEEC_Session TeecSession; 1035 uint32_t ErrorOrigin; 1036 uint32_t bootflag; 1037 1038 TEEC_UUID tempuuid = { 0x2d26d8a8, 0x5134, 0x4dd8, \ 1039 { 0xb3, 0x2f, 0xb3, 0x4b, 0xce, 0xeb, 0xc4, 0x71 } }; 1040 TEEC_UUID *TeecUuid = &tempuuid; 1041 TEEC_Operation TeecOperation = {0}; 1042 1043 OpteeClientApiLibInitialize(); 1044 1045 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1046 1047 TeecResult = TEEC_OpenSession(&TeecContext, 1048 &TeecSession, 1049 TeecUuid, 1050 TEEC_LOGIN_PUBLIC, 1051 NULL, 1052 NULL, 1053 &ErrorOrigin); 1054 1055 TEEC_SharedMemory SharedMem0 = {0}; 1056 1057 SharedMem0.size = 1 * sizeof(uint32_t); 1058 SharedMem0.flags = 0; 1059 1060 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1061 1062 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1063 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1064 1065 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, 1066 TEEC_NONE, 1067 TEEC_NONE, 1068 TEEC_NONE); 1069 1070 TeecResult = TEEC_InvokeCommand(&TeecSession, 1071 5, 1072 &TeecOperation, 1073 &ErrorOrigin); 1074 1075 if (TeecResult == TEEC_SUCCESS) { 1076 memcpy(&bootflag, SharedMem0.buffer, SharedMem0.size); 1077 if (bootflag == 0x000000FF) 1078 *flag = 1; 1079 } 1080 1081 TEEC_ReleaseSharedMemory(&SharedMem0); 1082 TEEC_CloseSession(&TeecSession); 1083 TEEC_FinalizeContext(&TeecContext); 1084 1085 return TeecResult; 1086 } 1087 1088 uint32_t trusty_read_permanent_attributes_flag(uint8_t *attributes) 1089 { 1090 TEEC_Result TeecResult; 1091 TEEC_Context TeecContext; 1092 TEEC_Session TeecSession; 1093 uint32_t ErrorOrigin; 1094 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1095 { 0xa8, 0x69, 0x9c, 0xe6, 0x88, 0x6c, 0x5d, 0x5d } }; 1096 TEEC_UUID *TeecUuid = &tempuuid; 1097 TEEC_Operation TeecOperation = {0}; 1098 1099 debug("testmm start\n"); 1100 OpteeClientApiLibInitialize(); 1101 1102 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1103 1104 TeecResult = TEEC_OpenSession(&TeecContext, 1105 &TeecSession, 1106 TeecUuid, 1107 TEEC_LOGIN_PUBLIC, 1108 NULL, 1109 NULL, 1110 &ErrorOrigin); 1111 1112 TEEC_SharedMemory SharedMem0 = {0}; 1113 1114 SharedMem0.size = sizeof("attributes_flag"); 1115 SharedMem0.flags = 0; 1116 1117 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1118 1119 memcpy(SharedMem0.buffer, "attributes_flag", SharedMem0.size); 1120 1121 TEEC_SharedMemory SharedMem1 = {0}; 1122 1123 SharedMem1.size = 1; 1124 SharedMem1.flags = 0; 1125 1126 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 1127 1128 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1129 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1130 1131 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 1132 TeecOperation.params[1].tmpref.size = SharedMem1.size; 1133 1134 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1135 TEEC_MEMREF_TEMP_INOUT, 1136 TEEC_NONE, 1137 TEEC_NONE); 1138 1139 TeecResult = TEEC_InvokeCommand(&TeecSession, 1140 142, 1141 &TeecOperation, 1142 &ErrorOrigin); 1143 if (TeecResult == TEEC_SUCCESS) 1144 memcpy(attributes, SharedMem1.buffer, SharedMem1.size); 1145 TEEC_ReleaseSharedMemory(&SharedMem0); 1146 TEEC_ReleaseSharedMemory(&SharedMem1); 1147 TEEC_CloseSession(&TeecSession); 1148 TEEC_FinalizeContext(&TeecContext); 1149 debug("testmm end\n"); 1150 1151 return TeecResult; 1152 } 1153 1154 uint32_t trusty_write_permanent_attributes_flag(uint8_t attributes) 1155 { 1156 TEEC_Result TeecResult; 1157 TEEC_Context TeecContext; 1158 TEEC_Session TeecSession; 1159 uint32_t ErrorOrigin; 1160 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1161 { 0xa8, 0x69, 0x9c, 0xe6, 0x88, 0x6c, 0x5d, 0x5d } }; 1162 TEEC_UUID *TeecUuid = &tempuuid; 1163 TEEC_Operation TeecOperation = {0}; 1164 1165 debug("testmm start\n"); 1166 OpteeClientApiLibInitialize(); 1167 1168 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1169 1170 TeecResult = TEEC_OpenSession(&TeecContext, 1171 &TeecSession, 1172 TeecUuid, 1173 TEEC_LOGIN_PUBLIC, 1174 NULL, 1175 NULL, 1176 &ErrorOrigin); 1177 1178 TEEC_SharedMemory SharedMem0 = {0}; 1179 1180 SharedMem0.size = sizeof("attributes_flag"); 1181 SharedMem0.flags = 0; 1182 1183 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1184 1185 memcpy(SharedMem0.buffer, "attributes_flag", SharedMem0.size); 1186 1187 TEEC_SharedMemory SharedMem1 = {0}; 1188 1189 SharedMem1.size = 1; 1190 SharedMem1.flags = 0; 1191 1192 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 1193 1194 memcpy(SharedMem1.buffer, (char *)&attributes, SharedMem1.size); 1195 1196 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1197 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1198 1199 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 1200 TeecOperation.params[1].tmpref.size = SharedMem1.size; 1201 1202 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, 1203 TEEC_MEMREF_TEMP_INOUT, 1204 TEEC_NONE, 1205 TEEC_NONE); 1206 1207 TeecResult = TEEC_InvokeCommand(&TeecSession, 1208 141, 1209 &TeecOperation, 1210 &ErrorOrigin); 1211 1212 TEEC_ReleaseSharedMemory(&SharedMem0); 1213 TEEC_ReleaseSharedMemory(&SharedMem1); 1214 TEEC_CloseSession(&TeecSession); 1215 TEEC_FinalizeContext(&TeecContext); 1216 debug("testmm end\n"); 1217 1218 return TeecResult; 1219 } 1220 1221 uint32_t trusty_attest_dh(uint8_t *dh, uint32_t *dh_size) 1222 { 1223 TEEC_Result TeecResult; 1224 TEEC_Context TeecContext; 1225 TEEC_Session TeecSession; 1226 uint32_t ErrorOrigin; 1227 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1228 { 0xa8, 0x69, 0x9c, 0xe6, 1229 0x88, 0x6c, 0x5d, 0x5d 1230 } 1231 }; 1232 TEEC_UUID *TeecUuid = &tempuuid; 1233 TEEC_Operation TeecOperation = {0}; 1234 1235 OpteeClientApiLibInitialize(); 1236 1237 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1238 1239 TeecResult = TEEC_OpenSession(&TeecContext, 1240 &TeecSession, 1241 TeecUuid, 1242 TEEC_LOGIN_PUBLIC, 1243 NULL, 1244 NULL, 1245 &ErrorOrigin); 1246 1247 TEEC_SharedMemory SharedMem0 = {0}; 1248 1249 SharedMem0.size = *dh_size; 1250 SharedMem0.flags = 0; 1251 1252 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1253 1254 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1255 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1256 1257 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, 1258 TEEC_NONE, 1259 TEEC_NONE, 1260 TEEC_NONE); 1261 1262 TeecResult = TEEC_InvokeCommand(&TeecSession, 1263 143, 1264 &TeecOperation, 1265 &ErrorOrigin); 1266 1267 *dh_size = TeecOperation.params[0].tmpref.size; 1268 memcpy(dh, SharedMem0.buffer, SharedMem0.size); 1269 1270 TEEC_ReleaseSharedMemory(&SharedMem0); 1271 1272 TEEC_CloseSession(&TeecSession); 1273 TeecResult = TEEC_FinalizeContext(&TeecContext); 1274 1275 return TeecResult; 1276 } 1277 1278 uint32_t trusty_attest_uuid(uint8_t *uuid, uint32_t *uuid_size) 1279 { 1280 TEEC_Result TeecResult; 1281 TEEC_Context TeecContext; 1282 TEEC_Session TeecSession; 1283 uint32_t ErrorOrigin; 1284 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1285 { 0xa8, 0x69, 0x9c, 0xe6, 1286 0x88, 0x6c, 0x5d, 0x5d 1287 } 1288 }; 1289 TEEC_UUID *TeecUuid = &tempuuid; 1290 TEEC_Operation TeecOperation = {0}; 1291 1292 OpteeClientApiLibInitialize(); 1293 1294 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1295 1296 TeecResult = TEEC_OpenSession(&TeecContext, 1297 &TeecSession, 1298 TeecUuid, 1299 TEEC_LOGIN_PUBLIC, 1300 NULL, 1301 NULL, 1302 &ErrorOrigin); 1303 1304 TEEC_SharedMemory SharedMem0 = {0}; 1305 1306 SharedMem0.size = *uuid_size; 1307 SharedMem0.flags = 0; 1308 1309 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1310 1311 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1312 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1313 1314 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, 1315 TEEC_NONE, 1316 TEEC_NONE, 1317 TEEC_NONE); 1318 1319 TeecResult = TEEC_InvokeCommand(&TeecSession, 1320 144, 1321 &TeecOperation, 1322 &ErrorOrigin); 1323 1324 *uuid_size = TeecOperation.params[0].tmpref.size; 1325 memcpy(uuid, SharedMem0.buffer, SharedMem0.size); 1326 1327 TEEC_ReleaseSharedMemory(&SharedMem0); 1328 1329 TEEC_CloseSession(&TeecSession); 1330 TeecResult = TEEC_FinalizeContext(&TeecContext); 1331 1332 return TeecResult; 1333 } 1334 1335 uint32_t trusty_attest_get_ca(uint8_t *operation_start, 1336 uint32_t *operation_size, 1337 uint8_t *out, 1338 uint32_t *out_len) 1339 { 1340 TEEC_Result TeecResult; 1341 TEEC_Context TeecContext; 1342 TEEC_Session TeecSession; 1343 uint32_t ErrorOrigin; 1344 1345 OpteeClientApiLibInitialize(); 1346 1347 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1348 { 0xa8, 0x69, 0x9c, 0xe6, 1349 0x88, 0x6c, 0x5d, 0x5d 1350 } 1351 }; 1352 1353 TEEC_UUID *TeecUuid = &tempuuid; 1354 TEEC_Operation TeecOperation = {0}; 1355 1356 OpteeClientApiLibInitialize(); 1357 1358 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1359 1360 TeecResult = TEEC_OpenSession(&TeecContext, 1361 &TeecSession, 1362 TeecUuid, 1363 TEEC_LOGIN_PUBLIC, 1364 NULL, 1365 NULL, 1366 &ErrorOrigin); 1367 1368 TEEC_SharedMemory SharedMem0 = {0}; 1369 1370 SharedMem0.size = *operation_size; 1371 SharedMem0.flags = 0; 1372 1373 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1374 1375 memcpy(SharedMem0.buffer, operation_start, SharedMem0.size); 1376 1377 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1378 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1379 1380 TEEC_SharedMemory SharedMem1 = {0}; 1381 1382 SharedMem1.size = *out_len; 1383 SharedMem1.flags = 0; 1384 1385 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem1); 1386 1387 TeecOperation.params[1].tmpref.buffer = SharedMem1.buffer; 1388 TeecOperation.params[1].tmpref.size = SharedMem1.size; 1389 1390 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, 1391 TEEC_MEMREF_TEMP_INOUT, 1392 TEEC_NONE, 1393 TEEC_NONE); 1394 1395 TeecResult = TEEC_InvokeCommand(&TeecSession, 1396 145, 1397 &TeecOperation, 1398 &ErrorOrigin); 1399 1400 *out_len = TeecOperation.params[1].tmpref.size; 1401 memcpy(out, SharedMem1.buffer, SharedMem1.size); 1402 TEEC_ReleaseSharedMemory(&SharedMem0); 1403 TEEC_ReleaseSharedMemory(&SharedMem1); 1404 1405 return TeecResult; 1406 } 1407 1408 uint32_t trusty_attest_set_ca(uint8_t *ca_response, uint32_t *ca_response_size) 1409 { 1410 TEEC_Result TeecResult; 1411 TEEC_Context TeecContext; 1412 TEEC_Session TeecSession; 1413 uint32_t ErrorOrigin; 1414 TEEC_UUID tempuuid = { 0x258be795, 0xf9ca, 0x40e6, 1415 { 0xa8, 0x69, 0x9c, 0xe6, 1416 0x88, 0x6c, 0x5d, 0x5d 1417 } 1418 }; 1419 TEEC_UUID *TeecUuid = &tempuuid; 1420 TEEC_Operation TeecOperation = {0}; 1421 1422 TeecResult = TEEC_InitializeContext(NULL, &TeecContext); 1423 1424 TeecResult = TEEC_OpenSession(&TeecContext, 1425 &TeecSession, 1426 TeecUuid, 1427 TEEC_LOGIN_PUBLIC, 1428 NULL, 1429 NULL, 1430 &ErrorOrigin); 1431 1432 TEEC_SharedMemory SharedMem0 = {0}; 1433 1434 SharedMem0.size = *ca_response_size; 1435 SharedMem0.flags = 0; 1436 1437 TeecResult = TEEC_AllocateSharedMemory(&TeecContext, &SharedMem0); 1438 1439 memcpy(SharedMem0.buffer, ca_response, SharedMem0.size); 1440 1441 TeecOperation.params[0].tmpref.buffer = SharedMem0.buffer; 1442 TeecOperation.params[0].tmpref.size = SharedMem0.size; 1443 1444 TeecOperation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, 1445 TEEC_NONE, 1446 TEEC_NONE, 1447 TEEC_NONE); 1448 1449 TeecResult = TEEC_InvokeCommand(&TeecSession, 1450 146, 1451 &TeecOperation, 1452 &ErrorOrigin); 1453 1454 TEEC_ReleaseSharedMemory(&SharedMem0); 1455 1456 TEEC_CloseSession(&TeecSession); 1457 TeecResult = TEEC_FinalizeContext(&TeecContext); 1458 1459 return TeecResult; 1460 } 1461