1 // SPDX-License-Identifier: BSD-2-Clause 2 /* 3 * Copyright (c) 2014, STMicroelectronics International N.V. 4 */ 5 #include <stdlib.h> 6 #include <string.h> 7 8 #include <tee_api.h> 9 #include <utee_syscalls.h> 10 #include "tee_api_private.h" 11 12 #define TEE_USAGE_DEFAULT 0xffffffff 13 14 void __utee_from_attr(struct utee_attribute *ua, const TEE_Attribute *attrs, 15 uint32_t attr_count) 16 { 17 size_t n; 18 19 for (n = 0; n < attr_count; n++) { 20 ua[n].attribute_id = attrs[n].attributeID; 21 if (attrs[n].attributeID & TEE_ATTR_FLAG_VALUE) { 22 ua[n].a = attrs[n].content.value.a; 23 ua[n].b = attrs[n].content.value.b; 24 } else { 25 ua[n].a = (uintptr_t)attrs[n].content.ref.buffer; 26 ua[n].b = attrs[n].content.ref.length; 27 } 28 } 29 } 30 31 /* Data and Key Storage API - Generic Object Functions */ 32 /* 33 * Use of this function is deprecated 34 * new code SHOULD use the TEE_GetObjectInfo1 function instead 35 * These functions will be removed at some future major revision of 36 * this specification 37 */ 38 void TEE_GetObjectInfo(TEE_ObjectHandle object, TEE_ObjectInfo *objectInfo) 39 { 40 struct utee_object_info info = { }; 41 TEE_Result res = TEE_SUCCESS; 42 43 res = _utee_cryp_obj_get_info((unsigned long)object, &info); 44 45 if (res != TEE_SUCCESS) 46 TEE_Panic(res); 47 48 if (info.obj_type == TEE_TYPE_CORRUPTED_OBJECT) { 49 objectInfo->keySize = 0; 50 objectInfo->maxKeySize = 0; 51 objectInfo->objectUsage = 0; 52 objectInfo->dataSize = 0; 53 objectInfo->dataPosition = 0; 54 objectInfo->handleFlags = 0; 55 } else { 56 objectInfo->objectType = info.obj_type; 57 objectInfo->keySize = info.obj_size; 58 objectInfo->maxKeySize = info.max_obj_size; 59 objectInfo->objectUsage = info.obj_usage; 60 objectInfo->dataSize = info.data_size; 61 objectInfo->dataPosition = info.data_pos; 62 objectInfo->handleFlags = info.handle_flags; 63 } 64 } 65 66 TEE_Result TEE_GetObjectInfo1(TEE_ObjectHandle object, TEE_ObjectInfo *objectInfo) 67 { 68 struct utee_object_info info = { }; 69 TEE_Result res = TEE_SUCCESS; 70 71 res = _utee_cryp_obj_get_info((unsigned long)object, &info); 72 73 if (res != TEE_SUCCESS && 74 res != TEE_ERROR_CORRUPT_OBJECT && 75 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 76 TEE_Panic(res); 77 78 objectInfo->objectType = info.obj_type; 79 objectInfo->keySize = info.obj_size; 80 objectInfo->maxKeySize = info.max_obj_size; 81 objectInfo->objectUsage = info.obj_usage; 82 objectInfo->dataSize = info.data_size; 83 objectInfo->dataPosition = info.data_pos; 84 objectInfo->handleFlags = info.handle_flags; 85 86 return res; 87 } 88 89 /* 90 * Use of this function is deprecated 91 * new code SHOULD use the TEE_RestrictObjectUsage1 function instead 92 * These functions will be removed at some future major revision of 93 * this specification 94 */ 95 void TEE_RestrictObjectUsage(TEE_ObjectHandle object, uint32_t objectUsage) 96 { 97 struct utee_object_info info = { }; 98 TEE_Result res = TEE_SUCCESS; 99 100 res = _utee_cryp_obj_get_info((unsigned long)object, &info); 101 if (info.obj_type == TEE_TYPE_CORRUPTED_OBJECT) 102 return; 103 104 res = TEE_RestrictObjectUsage1(object, objectUsage); 105 106 if (res != TEE_SUCCESS) 107 TEE_Panic(res); 108 } 109 110 TEE_Result TEE_RestrictObjectUsage1(TEE_ObjectHandle object, uint32_t objectUsage) 111 { 112 TEE_Result res; 113 114 res = _utee_cryp_obj_restrict_usage((unsigned long)object, 115 objectUsage); 116 117 if (res != TEE_SUCCESS && 118 res != TEE_ERROR_CORRUPT_OBJECT && 119 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 120 TEE_Panic(res); 121 122 return res; 123 } 124 125 TEE_Result TEE_GetObjectBufferAttribute(TEE_ObjectHandle object, 126 uint32_t attributeID, void *buffer, 127 uint32_t *size) 128 { 129 struct utee_object_info info = { }; 130 TEE_Result res = TEE_SUCCESS; 131 uint64_t sz = 0; 132 133 __utee_check_inout_annotation(size, sizeof(*size)); 134 135 res = _utee_cryp_obj_get_info((unsigned long)object, &info); 136 if (res != TEE_SUCCESS) 137 goto exit; 138 139 /* This function only supports reference attributes */ 140 if ((attributeID & TEE_ATTR_FLAG_VALUE)) { 141 res = TEE_ERROR_BAD_PARAMETERS; 142 goto exit; 143 } 144 145 sz = *size; 146 res = _utee_cryp_obj_get_attr((unsigned long)object, attributeID, 147 buffer, &sz); 148 *size = sz; 149 150 exit: 151 if (res != TEE_SUCCESS && 152 res != TEE_ERROR_ITEM_NOT_FOUND && 153 res != TEE_ERROR_SHORT_BUFFER && 154 res != TEE_ERROR_CORRUPT_OBJECT && 155 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 156 TEE_Panic(res); 157 158 return res; 159 } 160 161 TEE_Result TEE_GetObjectValueAttribute(TEE_ObjectHandle object, 162 uint32_t attributeID, uint32_t *a, 163 uint32_t *b) 164 { 165 struct utee_object_info info = { }; 166 TEE_Result res = TEE_SUCCESS; 167 uint32_t buf[2]; 168 uint64_t size = sizeof(buf); 169 170 if (a) 171 __utee_check_out_annotation(a, sizeof(*a)); 172 if (b) 173 __utee_check_out_annotation(b, sizeof(*b)); 174 175 res = _utee_cryp_obj_get_info((unsigned long)object, &info); 176 if (res != TEE_SUCCESS) 177 goto exit; 178 179 /* This function only supports value attributes */ 180 if (!(attributeID & TEE_ATTR_FLAG_VALUE)) { 181 res = TEE_ERROR_BAD_PARAMETERS; 182 goto exit; 183 } 184 185 res = _utee_cryp_obj_get_attr((unsigned long)object, attributeID, buf, 186 &size); 187 188 exit: 189 if (res != TEE_SUCCESS && 190 res != TEE_ERROR_ITEM_NOT_FOUND && 191 res != TEE_ERROR_CORRUPT_OBJECT && 192 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 193 TEE_Panic(res); 194 195 if (size != sizeof(buf)) 196 TEE_Panic(0); 197 198 if (res == TEE_SUCCESS) { 199 if (a) 200 *a = buf[0]; 201 if (b) 202 *b = buf[1]; 203 } 204 205 return res; 206 } 207 208 void TEE_CloseObject(TEE_ObjectHandle object) 209 { 210 TEE_Result res; 211 212 if (object == TEE_HANDLE_NULL) 213 return; 214 215 res = _utee_cryp_obj_close((unsigned long)object); 216 if (res != TEE_SUCCESS) 217 TEE_Panic(res); 218 } 219 220 /* Data and Key Storage API - Transient Object Functions */ 221 222 TEE_Result TEE_AllocateTransientObject(TEE_ObjectType objectType, 223 uint32_t maxKeySize, 224 TEE_ObjectHandle *object) 225 { 226 TEE_Result res; 227 uint32_t obj; 228 229 __utee_check_out_annotation(object, sizeof(*object)); 230 231 res = _utee_cryp_obj_alloc(objectType, maxKeySize, &obj); 232 233 if (res != TEE_SUCCESS && 234 res != TEE_ERROR_OUT_OF_MEMORY && 235 res != TEE_ERROR_NOT_SUPPORTED) 236 TEE_Panic(res); 237 238 if (res == TEE_SUCCESS) 239 *object = (TEE_ObjectHandle)(uintptr_t)obj; 240 241 return res; 242 } 243 244 void TEE_FreeTransientObject(TEE_ObjectHandle object) 245 { 246 struct utee_object_info info = { }; 247 TEE_Result res = TEE_SUCCESS; 248 249 if (object == TEE_HANDLE_NULL) 250 return; 251 252 res = _utee_cryp_obj_get_info((unsigned long)object, &info); 253 if (res != TEE_SUCCESS) 254 TEE_Panic(res); 255 256 if ((info.handle_flags & TEE_HANDLE_FLAG_PERSISTENT) != 0) 257 TEE_Panic(0); 258 259 res = _utee_cryp_obj_close((unsigned long)object); 260 if (res != TEE_SUCCESS) 261 TEE_Panic(res); 262 } 263 264 void TEE_ResetTransientObject(TEE_ObjectHandle object) 265 { 266 struct utee_object_info info = { }; 267 TEE_Result res = TEE_SUCCESS; 268 269 if (object == TEE_HANDLE_NULL) 270 return; 271 272 res = _utee_cryp_obj_get_info((unsigned long)object, &info); 273 if (res != TEE_SUCCESS) 274 TEE_Panic(res); 275 276 if ((info.handle_flags & TEE_HANDLE_FLAG_PERSISTENT) != 0) 277 TEE_Panic(0); 278 279 res = _utee_cryp_obj_reset((unsigned long)object); 280 if (res != TEE_SUCCESS) 281 TEE_Panic(res); 282 } 283 284 TEE_Result TEE_PopulateTransientObject(TEE_ObjectHandle object, 285 const TEE_Attribute *attrs, 286 uint32_t attrCount) 287 { 288 struct utee_attribute ua[attrCount]; 289 struct utee_object_info info = { }; 290 TEE_Result res = TEE_SUCCESS; 291 292 __utee_check_attr_in_annotation(attrs, attrCount); 293 294 res = _utee_cryp_obj_get_info((unsigned long)object, &info); 295 if (res != TEE_SUCCESS) 296 TEE_Panic(res); 297 298 /* Must be a transient object */ 299 if ((info.handle_flags & TEE_HANDLE_FLAG_PERSISTENT) != 0) 300 TEE_Panic(0); 301 302 /* Must not be initialized already */ 303 if ((info.handle_flags & TEE_HANDLE_FLAG_INITIALIZED) != 0) 304 TEE_Panic(0); 305 306 __utee_from_attr(ua, attrs, attrCount); 307 res = _utee_cryp_obj_populate((unsigned long)object, ua, attrCount); 308 if (res != TEE_SUCCESS && res != TEE_ERROR_BAD_PARAMETERS) 309 TEE_Panic(res); 310 return res; 311 } 312 313 void TEE_InitRefAttribute(TEE_Attribute *attr, uint32_t attributeID, 314 const void *buffer, uint32_t length) 315 { 316 __utee_check_out_annotation(attr, sizeof(*attr)); 317 318 if ((attributeID & TEE_ATTR_FLAG_VALUE) != 0) 319 TEE_Panic(0); 320 attr->attributeID = attributeID; 321 attr->content.ref.buffer = (void *)buffer; 322 attr->content.ref.length = length; 323 } 324 325 void TEE_InitValueAttribute(TEE_Attribute *attr, uint32_t attributeID, 326 uint32_t a, uint32_t b) 327 { 328 __utee_check_out_annotation(attr, sizeof(*attr)); 329 330 if ((attributeID & TEE_ATTR_FLAG_VALUE) == 0) 331 TEE_Panic(0); 332 attr->attributeID = attributeID; 333 attr->content.value.a = a; 334 attr->content.value.b = b; 335 } 336 337 /* 338 * Use of this function is deprecated 339 * new code SHOULD use the TEE_CopyObjectAttributes1 function instead 340 * These functions will be removed at some future major revision of 341 * this specification 342 */ 343 void TEE_CopyObjectAttributes(TEE_ObjectHandle destObject, 344 TEE_ObjectHandle srcObject) 345 { 346 struct utee_object_info src_info = { }; 347 TEE_Result res = TEE_SUCCESS; 348 349 res = _utee_cryp_obj_get_info((unsigned long)srcObject, &src_info); 350 if (src_info.obj_type == TEE_TYPE_CORRUPTED_OBJECT) 351 return; 352 353 res = TEE_CopyObjectAttributes1(destObject, srcObject); 354 if (res != TEE_SUCCESS) 355 TEE_Panic(res); 356 } 357 358 TEE_Result TEE_CopyObjectAttributes1(TEE_ObjectHandle destObject, 359 TEE_ObjectHandle srcObject) 360 { 361 struct utee_object_info dst_info = { }; 362 struct utee_object_info src_info = { }; 363 TEE_Result res = TEE_SUCCESS; 364 365 res = _utee_cryp_obj_get_info((unsigned long)destObject, &dst_info); 366 if (res != TEE_SUCCESS) 367 goto exit; 368 369 res = _utee_cryp_obj_get_info((unsigned long)srcObject, &src_info); 370 if (res != TEE_SUCCESS) 371 goto exit; 372 373 if (!(src_info.handle_flags & TEE_HANDLE_FLAG_INITIALIZED)) 374 TEE_Panic(0); 375 376 if ((dst_info.handle_flags & TEE_HANDLE_FLAG_PERSISTENT)) 377 TEE_Panic(0); 378 379 if ((dst_info.handle_flags & TEE_HANDLE_FLAG_INITIALIZED)) 380 TEE_Panic(0); 381 382 res = _utee_cryp_obj_copy((unsigned long)destObject, 383 (unsigned long)srcObject); 384 385 exit: 386 if (res != TEE_SUCCESS && 387 res != TEE_ERROR_CORRUPT_OBJECT && 388 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 389 TEE_Panic(res); 390 391 return res; 392 } 393 394 TEE_Result TEE_GenerateKey(TEE_ObjectHandle object, uint32_t keySize, 395 const TEE_Attribute *params, uint32_t paramCount) 396 { 397 TEE_Result res; 398 struct utee_attribute ua[paramCount]; 399 400 __utee_check_attr_in_annotation(params, paramCount); 401 402 __utee_from_attr(ua, params, paramCount); 403 res = _utee_cryp_obj_generate_key((unsigned long)object, keySize, 404 ua, paramCount); 405 406 if (res != TEE_SUCCESS && res != TEE_ERROR_BAD_PARAMETERS) 407 TEE_Panic(res); 408 409 return res; 410 } 411 412 /* Data and Key Storage API - Persistent Object Functions */ 413 414 TEE_Result TEE_OpenPersistentObject(uint32_t storageID, const void *objectID, 415 uint32_t objectIDLen, uint32_t flags, 416 TEE_ObjectHandle *object) 417 { 418 TEE_Result res; 419 uint32_t obj; 420 421 __utee_check_out_annotation(object, sizeof(*object)); 422 423 res = _utee_storage_obj_open(storageID, objectID, objectIDLen, flags, 424 &obj); 425 if (res == TEE_SUCCESS) 426 *object = (TEE_ObjectHandle)(uintptr_t)obj; 427 428 if (res != TEE_SUCCESS && 429 res != TEE_ERROR_ITEM_NOT_FOUND && 430 res != TEE_ERROR_ACCESS_CONFLICT && 431 res != TEE_ERROR_OUT_OF_MEMORY && 432 res != TEE_ERROR_CORRUPT_OBJECT && 433 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 434 TEE_Panic(res); 435 436 if (res != TEE_SUCCESS) 437 *object = TEE_HANDLE_NULL; 438 439 return res; 440 } 441 442 TEE_Result TEE_CreatePersistentObject(uint32_t storageID, const void *objectID, 443 uint32_t objectIDLen, uint32_t flags, 444 TEE_ObjectHandle attributes, 445 const void *initialData, 446 uint32_t initialDataLen, 447 TEE_ObjectHandle *object) 448 { 449 TEE_Result res; 450 uint32_t obj; 451 452 __utee_check_out_annotation(object, sizeof(*object)); 453 454 res = _utee_storage_obj_create(storageID, objectID, objectIDLen, flags, 455 (unsigned long)attributes, initialData, 456 initialDataLen, &obj); 457 458 if (res == TEE_SUCCESS) 459 *object = (TEE_ObjectHandle)(uintptr_t)obj; 460 461 if (res != TEE_SUCCESS && 462 res != TEE_ERROR_ITEM_NOT_FOUND && 463 res != TEE_ERROR_ACCESS_CONFLICT && 464 res != TEE_ERROR_OUT_OF_MEMORY && 465 res != TEE_ERROR_STORAGE_NO_SPACE && 466 res != TEE_ERROR_CORRUPT_OBJECT && 467 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 468 TEE_Panic(res); 469 470 if (res != TEE_SUCCESS) 471 *object = TEE_HANDLE_NULL; 472 473 return res; 474 } 475 476 /* 477 * Use of this function is deprecated 478 * new code SHOULD use the TEE_CloseAndDeletePersistentObject1 function instead 479 * These functions will be removed at some future major revision of 480 * this specification 481 */ 482 void TEE_CloseAndDeletePersistentObject(TEE_ObjectHandle object) 483 { 484 TEE_Result res; 485 486 if (object == TEE_HANDLE_NULL) 487 return; 488 489 res = TEE_CloseAndDeletePersistentObject1(object); 490 491 if (res != TEE_SUCCESS) 492 TEE_Panic(0); 493 } 494 495 TEE_Result TEE_CloseAndDeletePersistentObject1(TEE_ObjectHandle object) 496 { 497 TEE_Result res; 498 499 if (object == TEE_HANDLE_NULL) 500 return TEE_SUCCESS; 501 502 res = _utee_storage_obj_del((unsigned long)object); 503 504 if (res != TEE_SUCCESS && res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 505 TEE_Panic(res); 506 507 return res; 508 } 509 510 511 TEE_Result TEE_RenamePersistentObject(TEE_ObjectHandle object, 512 const void *newObjectID, 513 uint32_t newObjectIDLen) 514 { 515 TEE_Result res; 516 517 if (object == TEE_HANDLE_NULL) { 518 res = TEE_ERROR_ITEM_NOT_FOUND; 519 goto out; 520 } 521 522 res = _utee_storage_obj_rename((unsigned long)object, newObjectID, 523 newObjectIDLen); 524 525 out: 526 if (res != TEE_SUCCESS && 527 res != TEE_ERROR_ACCESS_CONFLICT && 528 res != TEE_ERROR_CORRUPT_OBJECT && 529 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 530 TEE_Panic(res); 531 532 return res; 533 } 534 535 TEE_Result TEE_AllocatePersistentObjectEnumerator(TEE_ObjectEnumHandle * 536 objectEnumerator) 537 { 538 TEE_Result res; 539 uint32_t oe; 540 541 __utee_check_out_annotation(objectEnumerator, 542 sizeof(*objectEnumerator)); 543 544 res = _utee_storage_alloc_enum(&oe); 545 546 if (res != TEE_SUCCESS) 547 oe = TEE_HANDLE_NULL; 548 549 *objectEnumerator = (TEE_ObjectEnumHandle)(uintptr_t)oe; 550 551 if (res != TEE_SUCCESS && 552 res != TEE_ERROR_ACCESS_CONFLICT) 553 TEE_Panic(res); 554 555 return res; 556 } 557 558 void TEE_FreePersistentObjectEnumerator(TEE_ObjectEnumHandle objectEnumerator) 559 { 560 TEE_Result res; 561 562 if (objectEnumerator == TEE_HANDLE_NULL) 563 return; 564 565 res = _utee_storage_free_enum((unsigned long)objectEnumerator); 566 567 if (res != TEE_SUCCESS) 568 TEE_Panic(res); 569 } 570 571 void TEE_ResetPersistentObjectEnumerator(TEE_ObjectEnumHandle objectEnumerator) 572 { 573 TEE_Result res; 574 575 if (objectEnumerator == TEE_HANDLE_NULL) 576 return; 577 578 res = _utee_storage_reset_enum((unsigned long)objectEnumerator); 579 580 if (res != TEE_SUCCESS) 581 TEE_Panic(res); 582 } 583 584 TEE_Result TEE_StartPersistentObjectEnumerator(TEE_ObjectEnumHandle 585 objectEnumerator, 586 uint32_t storageID) 587 { 588 TEE_Result res; 589 590 res = _utee_storage_start_enum((unsigned long)objectEnumerator, 591 storageID); 592 593 if (res != TEE_SUCCESS && 594 res != TEE_ERROR_ITEM_NOT_FOUND && 595 res != TEE_ERROR_CORRUPT_OBJECT && 596 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 597 TEE_Panic(res); 598 599 return res; 600 } 601 602 TEE_Result TEE_GetNextPersistentObject(TEE_ObjectEnumHandle objectEnumerator, 603 TEE_ObjectInfo *objectInfo, 604 void *objectID, uint32_t *objectIDLen) 605 { 606 struct utee_object_info info = { }; 607 TEE_Result res = TEE_SUCCESS; 608 uint64_t len = 0; 609 610 if (objectInfo) 611 __utee_check_out_annotation(objectInfo, sizeof(*objectInfo)); 612 __utee_check_out_annotation(objectIDLen, sizeof(*objectIDLen)); 613 614 if (!objectID) { 615 res = TEE_ERROR_BAD_PARAMETERS; 616 goto out; 617 } 618 619 len = *objectIDLen; 620 res = _utee_storage_next_enum((unsigned long)objectEnumerator, 621 &info, objectID, &len); 622 if (objectInfo) { 623 objectInfo->objectType = info.obj_type; 624 objectInfo->keySize = info.obj_size; 625 objectInfo->maxKeySize = info.max_obj_size; 626 objectInfo->objectUsage = info.obj_usage; 627 objectInfo->dataSize = info.data_size; 628 objectInfo->dataPosition = info.data_pos; 629 objectInfo->handleFlags = info.handle_flags; 630 } 631 *objectIDLen = len; 632 633 out: 634 if (res != TEE_SUCCESS && 635 res != TEE_ERROR_ITEM_NOT_FOUND && 636 res != TEE_ERROR_CORRUPT_OBJECT && 637 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 638 TEE_Panic(res); 639 640 return res; 641 } 642 643 /* Data and Key Storage API - Data Stream Access Functions */ 644 645 TEE_Result TEE_ReadObjectData(TEE_ObjectHandle object, void *buffer, 646 uint32_t size, uint32_t *count) 647 { 648 TEE_Result res; 649 uint64_t cnt64; 650 651 if (object == TEE_HANDLE_NULL) { 652 res = TEE_ERROR_BAD_PARAMETERS; 653 goto out; 654 } 655 __utee_check_out_annotation(count, sizeof(*count)); 656 657 cnt64 = *count; 658 res = _utee_storage_obj_read((unsigned long)object, buffer, size, 659 &cnt64); 660 *count = cnt64; 661 662 out: 663 if (res != TEE_SUCCESS && 664 res != TEE_ERROR_CORRUPT_OBJECT && 665 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 666 TEE_Panic(res); 667 668 return res; 669 } 670 671 TEE_Result TEE_WriteObjectData(TEE_ObjectHandle object, const void *buffer, 672 uint32_t size) 673 { 674 TEE_Result res; 675 676 if (object == TEE_HANDLE_NULL) { 677 res = TEE_ERROR_BAD_PARAMETERS; 678 goto out; 679 } 680 681 if (size > TEE_DATA_MAX_POSITION) { 682 res = TEE_ERROR_OVERFLOW; 683 goto out; 684 } 685 686 res = _utee_storage_obj_write((unsigned long)object, buffer, size); 687 688 out: 689 if (res != TEE_SUCCESS && 690 res != TEE_ERROR_STORAGE_NO_SPACE && 691 res != TEE_ERROR_OVERFLOW && 692 res != TEE_ERROR_CORRUPT_OBJECT && 693 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 694 TEE_Panic(res); 695 696 return res; 697 } 698 699 TEE_Result TEE_TruncateObjectData(TEE_ObjectHandle object, uint32_t size) 700 { 701 TEE_Result res; 702 703 if (object == TEE_HANDLE_NULL) { 704 res = TEE_ERROR_BAD_PARAMETERS; 705 goto out; 706 } 707 708 res = _utee_storage_obj_trunc((unsigned long)object, size); 709 710 out: 711 if (res != TEE_SUCCESS && 712 res != TEE_ERROR_STORAGE_NO_SPACE && 713 res != TEE_ERROR_CORRUPT_OBJECT && 714 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 715 TEE_Panic(res); 716 717 return res; 718 } 719 720 TEE_Result TEE_SeekObjectData(TEE_ObjectHandle object, int32_t offset, 721 TEE_Whence whence) 722 { 723 struct utee_object_info info = { }; 724 TEE_Result res = TEE_SUCCESS; 725 726 if (object == TEE_HANDLE_NULL) { 727 res = TEE_ERROR_BAD_PARAMETERS; 728 goto out; 729 } 730 731 res = _utee_cryp_obj_get_info((unsigned long)object, &info); 732 if (res != TEE_SUCCESS) 733 goto out; 734 735 switch (whence) { 736 case TEE_DATA_SEEK_SET: 737 if (offset > 0 && (uint32_t)offset > TEE_DATA_MAX_POSITION) { 738 res = TEE_ERROR_OVERFLOW; 739 goto out; 740 } 741 break; 742 case TEE_DATA_SEEK_CUR: 743 if (offset > 0 && 744 ((uint32_t)offset + info.data_pos > TEE_DATA_MAX_POSITION || 745 (uint32_t)offset + info.data_pos < info.data_pos)) { 746 res = TEE_ERROR_OVERFLOW; 747 goto out; 748 } 749 break; 750 case TEE_DATA_SEEK_END: 751 if (offset > 0 && 752 ((uint32_t)offset + info.data_size > 753 TEE_DATA_MAX_POSITION || 754 (uint32_t)offset + info.data_size < info.data_size)) { 755 res = TEE_ERROR_OVERFLOW; 756 goto out; 757 } 758 break; 759 default: 760 res = TEE_ERROR_ITEM_NOT_FOUND; 761 goto out; 762 } 763 764 res = _utee_storage_obj_seek((unsigned long)object, offset, whence); 765 766 out: 767 if (res != TEE_SUCCESS && 768 res != TEE_ERROR_OVERFLOW && 769 res != TEE_ERROR_CORRUPT_OBJECT && 770 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 771 TEE_Panic(res); 772 773 return res; 774 } 775