1 /* SPDX-License-Identifier: BSD-2-Clause */ 2 /* 3 * Copyright (c) 2014, STMicroelectronics International N.V. 4 */ 5 6 /* Based on GP TEE Internal API Specification Version 0.27 */ 7 #ifndef TEE_INTERNAL_API_H 8 #define TEE_INTERNAL_API_H 9 10 #ifdef __TEE_API_COMPAT_H 11 #error "<tee_api_compat.h> must not be included before <tee_internal_api.h>" 12 #endif 13 14 #include <compiler.h> 15 #include <stddef.h> 16 #include <tee_api_defines.h> 17 #include <tee_api_types.h> 18 #include <trace.h> 19 20 /* Property access functions */ 21 22 TEE_Result TEE_GetPropertyAsString(TEE_PropSetHandle propsetOrEnumerator, 23 const char *name, char *valueBuffer, 24 size_t *valueBufferLen); 25 TEE_Result __GP11_TEE_GetPropertyAsString(TEE_PropSetHandle propsetOrEnumerator, 26 const char *name, char *valueBuffer, 27 uint32_t *valueBufferLen); 28 29 TEE_Result TEE_GetPropertyAsBool(TEE_PropSetHandle propsetOrEnumerator, 30 const char *name, bool *value); 31 32 TEE_Result TEE_GetPropertyAsU32(TEE_PropSetHandle propsetOrEnumerator, 33 const char *name, uint32_t *value); 34 35 TEE_Result TEE_GetPropertyAsU64(TEE_PropSetHandle propsetOrEnumerator, 36 const char *name, uint64_t *value); 37 38 TEE_Result TEE_GetPropertyAsBinaryBlock(TEE_PropSetHandle propsetOrEnumerator, 39 const char *name, void *valueBuffer, 40 size_t *valueBufferLen); 41 TEE_Result 42 __GP11_TEE_GetPropertyAsBinaryBlock(TEE_PropSetHandle propsetOrEnumerator, 43 const char *name, void *valueBuffer, 44 uint32_t *valueBufferLen); 45 46 TEE_Result TEE_GetPropertyAsUUID(TEE_PropSetHandle propsetOrEnumerator, 47 const char *name, TEE_UUID *value); 48 49 TEE_Result TEE_GetPropertyAsIdentity(TEE_PropSetHandle propsetOrEnumerator, 50 const char *name, TEE_Identity *value); 51 52 TEE_Result TEE_AllocatePropertyEnumerator(TEE_PropSetHandle *enumerator); 53 54 void TEE_FreePropertyEnumerator(TEE_PropSetHandle enumerator); 55 56 void TEE_StartPropertyEnumerator(TEE_PropSetHandle enumerator, 57 TEE_PropSetHandle propSet); 58 59 void TEE_ResetPropertyEnumerator(TEE_PropSetHandle enumerator); 60 61 TEE_Result TEE_GetPropertyName(TEE_PropSetHandle enumerator, 62 void *nameBuffer, size_t *nameBufferLen); 63 TEE_Result __GP11_TEE_GetPropertyName(TEE_PropSetHandle enumerator, 64 void *nameBuffer, 65 uint32_t *nameBufferLen); 66 67 TEE_Result TEE_GetNextProperty(TEE_PropSetHandle enumerator); 68 69 /* System API - Misc */ 70 71 void TEE_Panic(TEE_Result panicCode); 72 73 /* System API - Internal Client API */ 74 75 TEE_Result TEE_OpenTASession(const TEE_UUID *destination, 76 uint32_t cancellationRequestTimeout, 77 uint32_t paramTypes, 78 TEE_Param params[TEE_NUM_PARAMS], 79 TEE_TASessionHandle *session, 80 uint32_t *returnOrigin); 81 TEE_Result __GP11_TEE_OpenTASession(const TEE_UUID *destination, 82 uint32_t cancellationRequestTimeout, 83 uint32_t paramTypes, 84 __GP11_TEE_Param params[TEE_NUM_PARAMS], 85 TEE_TASessionHandle *session, 86 uint32_t *returnOrigin); 87 88 void TEE_CloseTASession(TEE_TASessionHandle session); 89 90 TEE_Result TEE_InvokeTACommand(TEE_TASessionHandle session, 91 uint32_t cancellationRequestTimeout, 92 uint32_t commandID, uint32_t paramTypes, 93 TEE_Param params[TEE_NUM_PARAMS], 94 uint32_t *returnOrigin); 95 TEE_Result __GP11_TEE_InvokeTACommand(TEE_TASessionHandle session, 96 uint32_t cancellationRequestTimeout, 97 uint32_t commandID, uint32_t paramTypes, 98 __GP11_TEE_Param params[TEE_NUM_PARAMS], 99 uint32_t *returnOrigin); 100 101 /* System API - Cancellations */ 102 103 bool TEE_GetCancellationFlag(void); 104 105 bool TEE_UnmaskCancellation(void); 106 107 bool TEE_MaskCancellation(void); 108 109 /* System API - Memory Management */ 110 111 TEE_Result TEE_CheckMemoryAccessRights(uint32_t accessFlags, void *buffer, 112 size_t size); 113 TEE_Result __GP11_TEE_CheckMemoryAccessRights(uint32_t accessFlags, 114 void *buffer, uint32_t size); 115 116 void TEE_SetInstanceData(const void *instanceData); 117 118 const void *TEE_GetInstanceData(void); 119 120 void *TEE_Malloc(size_t size, uint32_t hint); 121 void *__GP11_TEE_Malloc(uint32_t size, uint32_t hint); 122 123 void *TEE_Realloc(void *buffer, size_t newSize); 124 void *__GP11_TEE_Realloc(void *buffer, uint32_t newSize); 125 126 void TEE_Free(void *buffer); 127 128 void *TEE_MemMove(void *dest, const void *src, size_t size); 129 void *__GP11_TEE_MemMove(void *dest, const void *src, uint32_t size); 130 131 /* 132 * Note: TEE_MemCompare() has a constant-time implementation (execution time 133 * does not depend on buffer content but only on buffer size). It is the main 134 * difference with memcmp(). 135 */ 136 int32_t TEE_MemCompare(const void *buffer1, const void *buffer2, size_t size); 137 int32_t __GP11_TEE_MemCompare(const void *buffer1, const void *buffer2, 138 uint32_t size); 139 140 void TEE_MemFill(void *buff, uint32_t x, size_t size); 141 void __GP11_TEE_MemFill(void *buff, uint32_t x, uint32_t size); 142 143 /* Data and Key Storage API - Generic Object Functions */ 144 145 void TEE_GetObjectInfo(TEE_ObjectHandle object, TEE_ObjectInfo *objectInfo); 146 void __GP11_TEE_GetObjectInfo(TEE_ObjectHandle object, 147 __GP11_TEE_ObjectInfo *objectInfo); 148 149 TEE_Result TEE_GetObjectInfo1(TEE_ObjectHandle object, 150 TEE_ObjectInfo *objectInfo); 151 TEE_Result __GP11_TEE_GetObjectInfo1(TEE_ObjectHandle object, 152 __GP11_TEE_ObjectInfo *objectInfo); 153 154 void TEE_RestrictObjectUsage(TEE_ObjectHandle object, uint32_t objectUsage); 155 TEE_Result TEE_RestrictObjectUsage1(TEE_ObjectHandle object, 156 uint32_t objectUsage); 157 158 TEE_Result TEE_GetObjectBufferAttribute(TEE_ObjectHandle object, 159 uint32_t attributeID, void *buffer, 160 size_t *size); 161 TEE_Result __GP11_TEE_GetObjectBufferAttribute(TEE_ObjectHandle object, 162 uint32_t attributeID, 163 void *buffer, uint32_t *size); 164 165 TEE_Result TEE_GetObjectValueAttribute(TEE_ObjectHandle object, 166 uint32_t attributeID, uint32_t *a, 167 uint32_t *b); 168 169 void TEE_CloseObject(TEE_ObjectHandle object); 170 171 /* Data and Key Storage API - Transient Object Functions */ 172 173 TEE_Result TEE_AllocateTransientObject(TEE_ObjectType objectType, 174 uint32_t maxObjectSize, 175 TEE_ObjectHandle *object); 176 TEE_Result __GP11_TEE_AllocateTransientObject(TEE_ObjectType objectType, 177 uint32_t maxKeySize, 178 TEE_ObjectHandle *object); 179 180 void TEE_FreeTransientObject(TEE_ObjectHandle object); 181 182 void TEE_ResetTransientObject(TEE_ObjectHandle object); 183 184 TEE_Result TEE_PopulateTransientObject(TEE_ObjectHandle object, 185 const TEE_Attribute *attrs, 186 uint32_t attrCount); 187 TEE_Result __GP11_TEE_PopulateTransientObject(TEE_ObjectHandle object, 188 const __GP11_TEE_Attribute *attrs, 189 uint32_t attrCount); 190 191 void TEE_InitRefAttribute(TEE_Attribute *attr, uint32_t attributeID, 192 const void *buffer, size_t length); 193 void __GP11_TEE_InitRefAttribute(__GP11_TEE_Attribute *attr, 194 uint32_t attributeID, 195 const void *buffer, uint32_t length); 196 197 void TEE_InitValueAttribute(TEE_Attribute *attr, uint32_t attributeID, 198 uint32_t a, uint32_t b); 199 void __GP11_TEE_InitValueAttribute(__GP11_TEE_Attribute *attr, 200 uint32_t attributeID, 201 uint32_t a, uint32_t b); 202 203 void TEE_CopyObjectAttributes(TEE_ObjectHandle destObject, 204 TEE_ObjectHandle srcObject); 205 206 TEE_Result TEE_CopyObjectAttributes1(TEE_ObjectHandle destObject, 207 TEE_ObjectHandle srcObject); 208 209 TEE_Result TEE_GenerateKey(TEE_ObjectHandle object, uint32_t keySize, 210 const TEE_Attribute *params, uint32_t paramCount); 211 TEE_Result __GP11_TEE_GenerateKey(TEE_ObjectHandle object, uint32_t keySize, 212 const __GP11_TEE_Attribute *params, 213 uint32_t paramCount); 214 215 /* Data and Key Storage API - Persistent Object Functions */ 216 217 TEE_Result TEE_OpenPersistentObject(uint32_t storageID, const void *objectID, 218 size_t objectIDLen, uint32_t flags, 219 TEE_ObjectHandle *object); 220 TEE_Result __GP11_TEE_OpenPersistentObject(uint32_t storageID, 221 const void *objectID, 222 uint32_t objectIDLen, uint32_t flags, 223 TEE_ObjectHandle *object); 224 225 TEE_Result TEE_CreatePersistentObject(uint32_t storageID, const void *objectID, 226 size_t objectIDLen, uint32_t flags, 227 TEE_ObjectHandle attributes, 228 const void *initialData, 229 size_t initialDataLen, 230 TEE_ObjectHandle *object); 231 TEE_Result __GP11_TEE_CreatePersistentObject(uint32_t storageID, 232 const void *objectID, 233 uint32_t objectIDLen, 234 uint32_t flags, 235 TEE_ObjectHandle attributes, 236 const void *initialData, 237 uint32_t initialDataLen, 238 TEE_ObjectHandle *object); 239 240 void TEE_CloseAndDeletePersistentObject(TEE_ObjectHandle object); 241 242 TEE_Result TEE_CloseAndDeletePersistentObject1(TEE_ObjectHandle object); 243 244 TEE_Result TEE_RenamePersistentObject(TEE_ObjectHandle object, 245 const void *newObjectID, 246 size_t newObjectIDLen); 247 TEE_Result __GP11_TEE_RenamePersistentObject(TEE_ObjectHandle object, 248 const void *newObjectID, 249 uint32_t newObjectIDLen); 250 251 TEE_Result TEE_AllocatePersistentObjectEnumerator(TEE_ObjectEnumHandle * 252 objectEnumerator); 253 254 void TEE_FreePersistentObjectEnumerator(TEE_ObjectEnumHandle objectEnumerator); 255 256 void TEE_ResetPersistentObjectEnumerator(TEE_ObjectEnumHandle objectEnumerator); 257 258 TEE_Result TEE_StartPersistentObjectEnumerator(TEE_ObjectEnumHandle 259 objectEnumerator, 260 uint32_t storageID); 261 262 TEE_Result TEE_GetNextPersistentObject(TEE_ObjectEnumHandle objectEnumerator, 263 TEE_ObjectInfo *objectInfo, 264 void *objectID, size_t *objectIDLen); 265 TEE_Result 266 __GP11_TEE_GetNextPersistentObject(TEE_ObjectEnumHandle objectEnumerator, 267 __GP11_TEE_ObjectInfo *objectInfo, 268 void *objectID, uint32_t *objectIDLen); 269 270 /* Data and Key Storage API - Data Stream Access Functions */ 271 272 TEE_Result TEE_ReadObjectData(TEE_ObjectHandle object, void *buffer, 273 size_t size, size_t *count); 274 TEE_Result __GP11_TEE_ReadObjectData(TEE_ObjectHandle object, void *buffer, 275 uint32_t size, uint32_t *count); 276 277 TEE_Result TEE_WriteObjectData(TEE_ObjectHandle object, const void *buffer, 278 size_t size); 279 TEE_Result __GP11_TEE_WriteObjectData(TEE_ObjectHandle object, 280 const void *buffer, uint32_t size); 281 282 TEE_Result TEE_TruncateObjectData(TEE_ObjectHandle object, size_t size); 283 TEE_Result __GP11_TEE_TruncateObjectData(TEE_ObjectHandle object, 284 uint32_t size); 285 286 TEE_Result TEE_SeekObjectData(TEE_ObjectHandle object, intmax_t offset, 287 TEE_Whence whence); 288 TEE_Result __GP11_TEE_SeekObjectData(TEE_ObjectHandle object, int32_t offset, 289 TEE_Whence whence); 290 291 /* Cryptographic Operations API - Generic Operation Functions */ 292 293 TEE_Result TEE_AllocateOperation(TEE_OperationHandle *operation, 294 uint32_t algorithm, uint32_t mode, 295 uint32_t maxKeySize); 296 297 void TEE_FreeOperation(TEE_OperationHandle operation); 298 void __GP11_TEE_FreeOperation(TEE_OperationHandle operation); 299 300 void TEE_GetOperationInfo(TEE_OperationHandle operation, 301 TEE_OperationInfo *operationInfo); 302 303 TEE_Result 304 TEE_GetOperationInfoMultiple(TEE_OperationHandle operation, 305 TEE_OperationInfoMultiple *operationInfoMultiple, 306 size_t *operationSize); 307 TEE_Result 308 __GP11_TEE_GetOperationInfoMultiple(TEE_OperationHandle operation, 309 TEE_OperationInfoMultiple *info, 310 uint32_t *operationSize); 311 312 void TEE_ResetOperation(TEE_OperationHandle operation); 313 314 TEE_Result TEE_SetOperationKey(TEE_OperationHandle operation, 315 TEE_ObjectHandle key); 316 TEE_Result __GP11_TEE_SetOperationKey(TEE_OperationHandle operation, 317 TEE_ObjectHandle key); 318 319 TEE_Result TEE_SetOperationKey2(TEE_OperationHandle operation, 320 TEE_ObjectHandle key1, TEE_ObjectHandle key2); 321 TEE_Result __GP11_TEE_SetOperationKey2(TEE_OperationHandle operation, 322 TEE_ObjectHandle key1, 323 TEE_ObjectHandle key2); 324 325 void TEE_CopyOperation(TEE_OperationHandle dstOperation, 326 TEE_OperationHandle srcOperation); 327 328 TEE_Result TEE_IsAlgorithmSupported(uint32_t algId, uint32_t element); 329 330 /* Cryptographic Operations API - Message Digest Functions */ 331 332 void TEE_DigestUpdate(TEE_OperationHandle operation, 333 const void *chunk, size_t chunkSize); 334 void __GP11_TEE_DigestUpdate(TEE_OperationHandle operation, 335 const void *chunk, uint32_t chunkSize); 336 337 TEE_Result TEE_DigestDoFinal(TEE_OperationHandle operation, const void *chunk, 338 size_t chunkLen, void *hash, size_t *hashLen); 339 TEE_Result __GP11_TEE_DigestDoFinal(TEE_OperationHandle operation, 340 const void *chunk, uint32_t chunkLen, 341 void *hash, uint32_t *hashLen); 342 343 TEE_Result TEE_DigestExtract(TEE_OperationHandle operation, void *hash, 344 size_t *hashLen); 345 346 /* Cryptographic Operations API - Symmetric Cipher Functions */ 347 348 void TEE_CipherInit(TEE_OperationHandle operation, const void *IV, 349 size_t IVLen); 350 void __GP11_TEE_CipherInit(TEE_OperationHandle operation, const void *IV, 351 uint32_t IVLen); 352 353 TEE_Result TEE_CipherUpdate(TEE_OperationHandle operation, const void *srcData, 354 size_t srcLen, void *destData, size_t *destLen); 355 TEE_Result __GP11_TEE_CipherUpdate(TEE_OperationHandle operation, 356 const void *srcData, uint32_t srcLen, 357 void *destData, uint32_t *destLen); 358 359 TEE_Result TEE_CipherDoFinal(TEE_OperationHandle operation, 360 const void *srcData, size_t srcLen, 361 void *destData, size_t *destLen); 362 TEE_Result __GP11_TEE_CipherDoFinal(TEE_OperationHandle operation, 363 const void *srcData, uint32_t srcLen, 364 void *destData, uint32_t *destLen); 365 366 /* Cryptographic Operations API - MAC Functions */ 367 368 void TEE_MACInit(TEE_OperationHandle operation, const void *IV, 369 size_t IVLen); 370 void __GP11_TEE_MACInit(TEE_OperationHandle operation, const void *IV, 371 uint32_t IVLen); 372 373 void TEE_MACUpdate(TEE_OperationHandle operation, const void *chunk, 374 size_t chunkSize); 375 void __GP11_TEE_MACUpdate(TEE_OperationHandle operation, const void *chunk, 376 uint32_t chunkSize); 377 378 TEE_Result TEE_MACComputeFinal(TEE_OperationHandle operation, 379 const void *message, size_t messageLen, 380 void *mac, size_t *macLen); 381 TEE_Result __GP11_TEE_MACComputeFinal(TEE_OperationHandle operation, 382 const void *message, uint32_t messageLen, 383 void *mac, uint32_t *macLen); 384 385 TEE_Result TEE_MACCompareFinal(TEE_OperationHandle operation, 386 const void *message, size_t messageLen, 387 const void *mac, size_t macLen); 388 TEE_Result __GP11_TEE_MACCompareFinal(TEE_OperationHandle operation, 389 const void *message, uint32_t messageLen, 390 const void *mac, uint32_t macLen); 391 392 /* Cryptographic Operations API - Authenticated Encryption Functions */ 393 394 TEE_Result TEE_AEInit(TEE_OperationHandle operation, const void *nonce, 395 size_t nonceLen, uint32_t tagLen, size_t AADLen, 396 size_t payloadLen); 397 TEE_Result __GP11_TEE_AEInit(TEE_OperationHandle operation, const void *nonce, 398 uint32_t nonceLen, uint32_t tagLen, 399 uint32_t AADLen, uint32_t payloadLen); 400 401 void TEE_AEUpdateAAD(TEE_OperationHandle operation, const void *AADdata, 402 size_t AADdataLen); 403 void __GP11_TEE_AEUpdateAAD(TEE_OperationHandle operation, const void *AADdata, 404 uint32_t AADdataLen); 405 406 TEE_Result TEE_AEUpdate(TEE_OperationHandle operation, const void *srcData, 407 size_t srcLen, void *destData, size_t *destLen); 408 TEE_Result __GP11_TEE_AEUpdate(TEE_OperationHandle operation, 409 const void *srcData, uint32_t srcLen, 410 void *destData, uint32_t *destLen); 411 412 TEE_Result TEE_AEEncryptFinal(TEE_OperationHandle operation, 413 const void *srcData, size_t srcLen, 414 void *destData, size_t *destLen, void *tag, 415 size_t *tagLen); 416 TEE_Result __GP11_TEE_AEEncryptFinal(TEE_OperationHandle operation, 417 const void *srcData, uint32_t srcLen, 418 void *destData, uint32_t *destLen, 419 void *tag, uint32_t *tagLen); 420 421 TEE_Result TEE_AEDecryptFinal(TEE_OperationHandle operation, 422 const void *srcData, size_t srcLen, 423 void *destData, size_t *destLen, void *tag, 424 size_t tagLen); 425 TEE_Result __GP11_TEE_AEDecryptFinal(TEE_OperationHandle operation, 426 const void *srcData, uint32_t srcLen, 427 void *destData, uint32_t *destLen, 428 void *tag, uint32_t tagLen); 429 430 /* Cryptographic Operations API - Asymmetric Functions */ 431 432 TEE_Result TEE_AsymmetricEncrypt(TEE_OperationHandle operation, 433 const TEE_Attribute *params, 434 uint32_t paramCount, const void *srcData, 435 size_t srcLen, void *destData, 436 size_t *destLen); 437 TEE_Result __GP11_TEE_AsymmetricEncrypt(TEE_OperationHandle operation, 438 const __GP11_TEE_Attribute *params, 439 uint32_t paramCount, 440 const void *srcData, uint32_t srcLen, 441 void *destData, uint32_t *destLen); 442 443 TEE_Result TEE_AsymmetricDecrypt(TEE_OperationHandle operation, 444 const TEE_Attribute *params, 445 uint32_t paramCount, const void *srcData, 446 size_t srcLen, void *destData, 447 size_t *destLen); 448 TEE_Result __GP11_TEE_AsymmetricDecrypt(TEE_OperationHandle operation, 449 const __GP11_TEE_Attribute *params, 450 uint32_t paramCount, 451 const void *srcData, uint32_t srcLen, 452 void *destData, uint32_t *destLen); 453 454 TEE_Result TEE_AsymmetricSignDigest(TEE_OperationHandle operation, 455 const TEE_Attribute *params, 456 uint32_t paramCount, const void *digest, 457 size_t digestLen, void *signature, 458 size_t *signatureLen); 459 TEE_Result __GP11_TEE_AsymmetricSignDigest(TEE_OperationHandle operation, 460 const __GP11_TEE_Attribute *params, 461 uint32_t paramCount, 462 const void *digest, 463 uint32_t digestLen, void *signature, 464 uint32_t *signatureLen); 465 466 TEE_Result TEE_AsymmetricVerifyDigest(TEE_OperationHandle operation, 467 const TEE_Attribute *params, 468 uint32_t paramCount, const void *digest, 469 size_t digestLen, const void *signature, 470 size_t signatureLen); 471 TEE_Result __GP11_TEE_AsymmetricVerifyDigest(TEE_OperationHandle operation, 472 const __GP11_TEE_Attribute *params, 473 uint32_t paramCount, 474 const void *digest, 475 uint32_t digestLen, 476 const void *signature, 477 uint32_t signatureLen); 478 479 /* Cryptographic Operations API - Key Derivation Functions */ 480 481 void TEE_DeriveKey(TEE_OperationHandle operation, 482 const TEE_Attribute *params, uint32_t paramCount, 483 TEE_ObjectHandle derivedKey); 484 void __GP11_TEE_DeriveKey(TEE_OperationHandle operation, 485 const __GP11_TEE_Attribute *params, 486 uint32_t paramCount, TEE_ObjectHandle derivedKey); 487 488 /* Cryptographic Operations API - Random Number Generation Functions */ 489 490 void TEE_GenerateRandom(void *randomBuffer, size_t randomBufferLen); 491 void __GP11_TEE_GenerateRandom(void *randomBuffer, uint32_t randomBufferLen); 492 493 /* Date & Time API */ 494 495 void TEE_GetSystemTime(TEE_Time *time); 496 497 TEE_Result TEE_Wait(uint32_t timeout); 498 499 TEE_Result TEE_GetTAPersistentTime(TEE_Time *time); 500 501 TEE_Result TEE_SetTAPersistentTime(const TEE_Time *time); 502 503 void TEE_GetREETime(TEE_Time *time); 504 505 /* TEE Arithmetical API - Memory allocation and size of objects */ 506 507 size_t TEE_BigIntFMMSizeInU32(size_t modulusSizeInBits); 508 uint32_t __GP11_TEE_BigIntFMMSizeInU32(uint32_t modulusSizeInBits); 509 510 size_t TEE_BigIntFMMContextSizeInU32(size_t modulusSizeInBits); 511 uint32_t __GP11_TEE_BigIntFMMContextSizeInU32(uint32_t modulusSizeInBits); 512 513 /* TEE Arithmetical API - Initialization functions */ 514 515 void TEE_BigIntInit(TEE_BigInt *bigInt, size_t len); 516 void __GP11_TEE_BigIntInit(TEE_BigInt *bigInt, uint32_t len); 517 518 void TEE_BigIntInitFMMContext(TEE_BigIntFMMContext *context, size_t len, 519 const TEE_BigInt *modulus); 520 void __GP11_TEE_BigIntInitFMMContext(TEE_BigIntFMMContext *context, 521 uint32_t len, const TEE_BigInt *modulus); 522 523 TEE_Result TEE_BigIntInitFMMContext1(TEE_BigIntFMMContext *context, 524 size_t len, const TEE_BigInt *modulus); 525 526 void TEE_BigIntInitFMM(TEE_BigIntFMM *bigIntFMM, size_t len); 527 void __GP11_TEE_BigIntInitFMM(TEE_BigIntFMM *bigIntFMM, uint32_t len); 528 529 /* TEE Arithmetical API - Converter functions */ 530 531 TEE_Result TEE_BigIntConvertFromOctetString(TEE_BigInt *dest, 532 const uint8_t *buffer, 533 size_t bufferLen, 534 int32_t sign); 535 TEE_Result __GP11_TEE_BigIntConvertFromOctetString(TEE_BigInt *dest, 536 const uint8_t *buffer, 537 uint32_t bufferLen, 538 int32_t sign); 539 540 TEE_Result TEE_BigIntConvertToOctetString(uint8_t *buffer, size_t *bufferLen, 541 const TEE_BigInt *bigInt); 542 TEE_Result __GP11_TEE_BigIntConvertToOctetString(uint8_t *buffer, 543 uint32_t *bufferLen, 544 const TEE_BigInt *bigInt); 545 546 void TEE_BigIntConvertFromS32(TEE_BigInt *dest, int32_t shortVal); 547 548 TEE_Result TEE_BigIntConvertToS32(int32_t *dest, const TEE_BigInt *src); 549 550 /* TEE Arithmetical API - Logical operations */ 551 552 int32_t TEE_BigIntCmp(const TEE_BigInt *op1, const TEE_BigInt *op2); 553 554 int32_t TEE_BigIntCmpS32(const TEE_BigInt *op, int32_t shortVal); 555 556 void TEE_BigIntShiftRight(TEE_BigInt *dest, const TEE_BigInt *op, 557 size_t bits); 558 void __GP11_TEE_BigIntShiftRight(TEE_BigInt *dest, const TEE_BigInt *op, 559 uint32_t bits); 560 561 bool TEE_BigIntGetBit(const TEE_BigInt *src, uint32_t bitIndex); 562 563 uint32_t TEE_BigIntGetBitCount(const TEE_BigInt *src); 564 565 TEE_Result TEE_BigIntSetBit(TEE_BigInt *op, uint32_t bitIndex, bool value); 566 567 TEE_Result TEE_BigIntAssign(TEE_BigInt *dest, const TEE_BigInt *src); 568 569 TEE_Result TEE_BigIntAbs(TEE_BigInt *dest, const TEE_BigInt *src); 570 571 void TEE_BigIntAdd(TEE_BigInt *dest, const TEE_BigInt *op1, 572 const TEE_BigInt *op2); 573 574 void TEE_BigIntSub(TEE_BigInt *dest, const TEE_BigInt *op1, 575 const TEE_BigInt *op2); 576 577 void TEE_BigIntNeg(TEE_BigInt *dest, const TEE_BigInt *op); 578 579 void TEE_BigIntMul(TEE_BigInt *dest, const TEE_BigInt *op1, 580 const TEE_BigInt *op2); 581 582 void TEE_BigIntSquare(TEE_BigInt *dest, const TEE_BigInt *op); 583 584 void TEE_BigIntDiv(TEE_BigInt *dest_q, TEE_BigInt *dest_r, 585 const TEE_BigInt *op1, const TEE_BigInt *op2); 586 587 /* TEE Arithmetical API - Modular arithmetic operations */ 588 589 void TEE_BigIntMod(TEE_BigInt *dest, const TEE_BigInt *op, 590 const TEE_BigInt *n); 591 592 void TEE_BigIntAddMod(TEE_BigInt *dest, const TEE_BigInt *op1, 593 const TEE_BigInt *op2, const TEE_BigInt *n); 594 595 void TEE_BigIntSubMod(TEE_BigInt *dest, const TEE_BigInt *op1, 596 const TEE_BigInt *op2, const TEE_BigInt *n); 597 598 void TEE_BigIntMulMod(TEE_BigInt *dest, const TEE_BigInt *op1, 599 const TEE_BigInt *op2, const TEE_BigInt *n); 600 601 void TEE_BigIntSquareMod(TEE_BigInt *dest, const TEE_BigInt *op, 602 const TEE_BigInt *n); 603 604 void TEE_BigIntInvMod(TEE_BigInt *dest, const TEE_BigInt *op, 605 const TEE_BigInt *n); 606 607 /* TEE Arithmetical API - Other arithmetic operations */ 608 609 bool TEE_BigIntRelativePrime(const TEE_BigInt *op1, const TEE_BigInt *op2); 610 611 void TEE_BigIntComputeExtendedGcd(TEE_BigInt *gcd, TEE_BigInt *u, 612 TEE_BigInt *v, const TEE_BigInt *op1, 613 const TEE_BigInt *op2); 614 615 int32_t TEE_BigIntIsProbablePrime(const TEE_BigInt *op, 616 uint32_t confidenceLevel); 617 618 /* TEE Arithmetical API - Fast modular multiplication operations */ 619 620 void TEE_BigIntConvertToFMM(TEE_BigIntFMM *dest, const TEE_BigInt *src, 621 const TEE_BigInt *n, 622 const TEE_BigIntFMMContext *context); 623 624 void TEE_BigIntConvertFromFMM(TEE_BigInt *dest, const TEE_BigIntFMM *src, 625 const TEE_BigInt *n, 626 const TEE_BigIntFMMContext *context); 627 628 void TEE_BigIntFMMConvertToBigInt(TEE_BigInt *dest, const TEE_BigIntFMM *src, 629 const TEE_BigInt *n, 630 const TEE_BigIntFMMContext *context); 631 632 void TEE_BigIntComputeFMM(TEE_BigIntFMM *dest, const TEE_BigIntFMM *op1, 633 const TEE_BigIntFMM *op2, const TEE_BigInt *n, 634 const TEE_BigIntFMMContext *context); 635 636 #define TA_EXPORT 637 638 /* 639 * TA Interface 640 * 641 * Each Trusted Application must provide the Implementation with a number 642 * of functions, collectively called the “TA interface”. These functions 643 * are the entry points called by the Trusted Core Framework to create the 644 * instance, notify the instance that a new client is connecting, notify 645 * the instance when the client invokes a command, etc. 646 * 647 * Trusted Application Entry Points: 648 */ 649 650 /* 651 * The function TA_CreateEntryPoint is the Trusted Application's 652 * constructor, which the Framework calls when it creates a new instance of 653 * the Trusted Application. To register instance data, the implementation 654 * of this constructor can use either global variables or the function 655 * TEE_InstanceSetData. 656 * 657 * Return Value: 658 * - TEE_SUCCESS: if the instance is successfully created, the function 659 * must return TEE_SUCCESS. 660 * - Any other value: if any other code is returned the instance is not 661 * created, and no other entry points of this instance will be called. 662 * The Framework MUST reclaim all resources and dereference all objects 663 * related to the creation of the instance. 664 * 665 * If this entry point was called as a result of a client opening a 666 * session, the error code is returned to the client and the session is 667 * not opened. 668 */ 669 TEE_Result TA_EXPORT TA_CreateEntryPoint(void); 670 671 /* 672 * The function TA_DestroyEntryPoint is the Trusted Application‟s 673 * destructor, which the Framework calls when the instance is being 674 * destroyed. 675 * 676 * When the function TA_DestroyEntryPoint is called, the Framework 677 * guarantees that no client session is currently open. Once the call to 678 * TA_DestroyEntryPoint has been completed, no other entry point of this 679 * instance will ever be called. 680 * 681 * Note that when this function is called, all resources opened by the 682 * instance are still available. It is only after the function returns that 683 * the Implementation MUST start automatically reclaiming resources left 684 * opened. 685 * 686 * Return Value: 687 * This function can return no success or error code. After this function 688 * returns the Implementation MUST consider the instance destroyed and 689 * reclaims all resources left open by the instance. 690 */ 691 void TA_EXPORT TA_DestroyEntryPoint(void); 692 693 /* 694 * The Framework calls the function TA_OpenSessionEntryPoint when a client 695 * requests to open a session with the Trusted Application. The open 696 * session request may result in a new Trusted Application instance being 697 * created as defined in section 4.5. 698 * 699 * The client can specify parameters in an open operation which are passed 700 * to the Trusted Application instance in the arguments paramTypes and 701 * params. These arguments can also be used by the Trusted Application 702 * instance to transfer response data back to the client. See section 4.3.6 703 * for a specification of how to handle the operation parameters. 704 * 705 * If this function returns TEE_SUCCESS, the client is connected to a 706 * Trusted Application instance and can invoke Trusted Application 707 * commands. When the client disconnects, the Framework will eventually 708 * call the TA_CloseSessionEntryPoint entry point. 709 * 710 * If the function returns any error, the Framework rejects the connection 711 * and returns the error code and the current content of the parameters the 712 * client. The return origin is then set to TEE_ORIGIN_TRUSTED_APP. 713 * 714 * The Trusted Application instance can register a session data pointer by 715 * setting *psessionContext. The value of this pointer is not interpreted 716 * by the Framework, and is simply passed back to other TA_ functions 717 * within this session. Note that *sessionContext may be set with a pointer 718 * to a memory allocated by the Trusted Application instance or with 719 * anything else, like an integer, a handle etc. The Framework will not 720 * automatically free *sessionContext when the session is closed; the 721 * Trusted Application instance is responsible for freeing memory if 722 * required. 723 * 724 * During the call to TA_OpenSessionEntryPoint the client may request to 725 * cancel the operation. See section 4.10 for more details on 726 * cancellations. If the call to TA_OpenSessionEntryPoint returns 727 * TEE_SUCCESS, the client must consider the session as successfully opened 728 * and explicitly close it if necessary. 729 * 730 * Parameters: 731 * - paramTypes: the types of the four parameters. 732 * - params: a pointer to an array of four parameters. 733 * - sessionContext: A pointer to a variable that can be filled by the 734 * Trusted Application instance with an opaque void* data pointer 735 * 736 * Return Value: 737 * - TEE_SUCCESS if the session is successfully opened. 738 * - Any other value if the session could not be open. 739 * o The error code may be one of the pre-defined codes, or may be a new 740 * error code defined by the Trusted Application implementation itself. 741 */ 742 TEE_Result TA_EXPORT TA_OpenSessionEntryPoint(uint32_t paramTypes, 743 TEE_Param params[TEE_NUM_PARAMS], 744 void **sessionContext); 745 TEE_Result TA_EXPORT 746 __GP11_TA_OpenSessionEntryPoint(uint32_t paramTypes, 747 __GP11_TEE_Param params[TEE_NUM_PARAMS], 748 void **sessionContext); 749 750 /* 751 * The Framework calls this function to close a client session. During the 752 * call to this function the implementation can use any session functions. 753 * 754 * The Trusted Application implementation is responsible for freeing any 755 * resources consumed by the session being closed. Note that the Trusted 756 * Application cannot refuse to close a session, but can hold the closing 757 * until it returns from TA_CloseSessionEntryPoint. This is why this 758 * function cannot return an error code. 759 * 760 * Parameters: 761 * - sessionContext: The value of the void* opaque data pointer set by the 762 * Trusted Application in the function TA_OpenSessionEntryPoint for this 763 * session. 764 */ 765 void TA_EXPORT TA_CloseSessionEntryPoint(void *sessionContext); 766 767 /* 768 * The Framework calls this function when the client invokes a command 769 * within the given session. 770 * 771 * The Trusted Application can access the parameters sent by the client 772 * through the paramTypes and params arguments. It can also use these 773 * arguments to transfer response data back to the client. 774 * 775 * During the call to TA_InvokeCommandEntryPoint the client may request to 776 * cancel the operation. 777 * 778 * A command is always invoked within the context of a client session. 779 * Thus, any session function can be called by the command implementation. 780 * 781 * Parameter: 782 * - sessionContext: The value of the void* opaque data pointer set by the 783 * Trusted Application in the function TA_OpenSessionEntryPoint. 784 * - commandID: A Trusted Application-specific code that identifies the 785 * command to be invoked. 786 * - paramTypes: the types of the four parameters. 787 * - params: a pointer to an array of four parameters. 788 * 789 * Return Value: 790 * - TEE_SUCCESS: if the command is successfully executed, the function 791 * must return this value. 792 * - Any other value: if the invocation of the command fails for any 793 * reason. 794 * o The error code may be one of the pre-defined codes, or may be a new 795 * error code defined by the Trusted Application implementation itself. 796 */ 797 798 TEE_Result TA_EXPORT 799 TA_InvokeCommandEntryPoint(void *sessionContext, uint32_t commandID, 800 uint32_t paramTypes, 801 TEE_Param params[TEE_NUM_PARAMS]); 802 TEE_Result TA_EXPORT 803 __GP11_TA_InvokeCommandEntryPoint(void *sessionContext, uint32_t commandID, 804 uint32_t paramTypes, 805 __GP11_TEE_Param params[TEE_NUM_PARAMS]); 806 807 /* 808 * Matching Client Functions <--> TA Functions 809 * 810 * TEE_OpenSession or TEE_OpenTASession: 811 * If a new Trusted Application instance is needed to handle the session, 812 * TA_CreateEntryPoint is called. 813 * Then, TA_OpenSessionEntryPoint is called. 814 * 815 * TEE_InvokeCommand or TEE_InvokeTACommand: 816 * TA_InvokeCommandEntryPoint is called. 817 * 818 * TEE_CloseSession or TEE_CloseTASession: 819 * TA_CloseSessionEntryPoint is called. 820 * For a multi-instance TA or for a single-instance, non keep-alive TA, if 821 * the session closed was the last session on the instance, then 822 * TA_DestroyEntryPoint is called. Otherwise, the instance is kept until 823 * the TEE shuts down. 824 */ 825 826 #include <tee_api_compat.h> 827 828 #endif /*TEE_INTERNAL_API_H*/ 829