1#[cfg_attr(feature = "mock", mockall::automock)]
19pub mod api {
20 use crate::*;
21 use core::ffi::*;
22
23 unsafe extern "C" {
24 pub fn TEE_GetPropertyAsString(
27 propsetOrEnumerator: TEE_PropSetHandle,
28 name: *const c_char,
29 valueBuffer: *mut c_char,
30 valueBufferLen: *mut usize,
31 ) -> TEE_Result;
32 pub fn TEE_GetPropertyAsBool(
33 propsetOrEnumerator: TEE_PropSetHandle,
34 name: *const c_char,
35 value: *mut bool,
36 ) -> TEE_Result;
37 pub fn TEE_GetPropertyAsU32(
38 propsetOrEnumerator: TEE_PropSetHandle,
39 name: *const c_char,
40 value: *mut u32,
41 ) -> TEE_Result;
42 pub fn TEE_GetPropertyAsU64(
43 propsetOrEnumerator: TEE_PropSetHandle,
44 name: *const c_char,
45 value: *mut u64,
46 ) -> TEE_Result;
47 pub fn TEE_GetPropertyAsBinaryBlock(
48 propsetOrEnumerator: TEE_PropSetHandle,
49 name: *const c_char,
50 valueBuffer: *mut c_void,
51 valueBufferLen: *mut usize,
52 ) -> TEE_Result;
53 pub fn TEE_GetPropertyAsUUID(
54 propsetOrEnumerator: TEE_PropSetHandle,
55 name: *const c_char,
56 value: *mut TEE_UUID,
57 ) -> TEE_Result;
58 pub fn TEE_GetPropertyAsIdentity(
59 propsetOrEnumerator: TEE_PropSetHandle,
60 name: *const c_char,
61 value: *mut TEE_Identity,
62 ) -> TEE_Result;
63 pub fn TEE_AllocatePropertyEnumerator(enumerator: *mut TEE_PropSetHandle) -> TEE_Result;
64 pub fn TEE_FreePropertyEnumerator(enumerator: TEE_PropSetHandle);
65 pub fn TEE_StartPropertyEnumerator(
66 enumerator: TEE_PropSetHandle,
67 propSet: TEE_PropSetHandle,
68 );
69 pub fn TEE_ResetPropertyEnumerator(enumerator: TEE_PropSetHandle);
70 pub fn TEE_GetPropertyName(
71 enumerator: TEE_PropSetHandle,
72 nameBuffer: *mut c_void,
73 nameBufferLen: *mut usize,
74 ) -> TEE_Result;
75 pub fn TEE_GetNextProperty(enumerator: TEE_PropSetHandle) -> TEE_Result;
76
77 pub fn TEE_Panic(panicCode: TEE_Result);
80
81 pub fn TEE_OpenTASession(
84 destination: *const TEE_UUID,
85 cancellationRequestTimeout: u32,
86 paramTypes: u32,
87 params: *mut TEE_Param,
88 session: *mut TEE_TASessionHandle,
89 returnOrigin: *mut u32,
90 ) -> TEE_Result;
91 pub fn TEE_CloseTASession(session: TEE_TASessionHandle);
92 pub fn TEE_InvokeTACommand(
93 session: TEE_TASessionHandle,
94 cancellationRequestTimeout: u32,
95 commandID: u32,
96 paramTypes: u32,
97 params: *mut TEE_Param,
98 returnOrigin: *mut u32,
99 ) -> TEE_Result;
100
101 pub fn TEE_GetCancellationFlag() -> bool;
104 pub fn TEE_UnmaskCancellation() -> bool;
105 pub fn TEE_MaskCancellation() -> bool;
106
107 pub fn TEE_CheckMemoryAccessRights(
110 accessFlags: u32,
111 buffer: *mut c_void,
112 size: usize,
113 ) -> TEE_Result;
114 pub fn TEE_SetInstanceData(instanceData: *const c_void);
115 pub fn TEE_GetInstanceData() -> *const c_void;
116 pub fn TEE_Malloc(size: usize, hint: u32) -> *mut c_void;
117 pub fn TEE_Realloc(buffer: *mut c_void, newSize: usize) -> *mut c_void;
118 pub fn TEE_Free(buffer: *mut c_void);
119 pub fn TEE_MemMove(dest: *mut c_void, src: *const c_void, size: usize);
120 pub fn TEE_MemCompare(buffer1: *const c_void, buffer2: *const c_void, size: usize) -> i32;
121 pub fn TEE_MemFill(buff: *mut c_void, x: u32, size: usize);
122
123 pub fn TEE_GetObjectInfo(object: TEE_ObjectHandle, objectInfo: *mut TEE_ObjectInfo);
126 pub fn TEE_GetObjectInfo1(
127 object: TEE_ObjectHandle,
128 objectInfo: *mut TEE_ObjectInfo,
129 ) -> TEE_Result;
130 pub fn TEE_RestrictObjectUsage(object: TEE_ObjectHandle, objectUsage: u32);
131 pub fn TEE_RestrictObjectUsage1(object: TEE_ObjectHandle, objectUsage: u32) -> TEE_Result;
132 pub fn TEE_GetObjectBufferAttribute(
133 object: TEE_ObjectHandle,
134 attributeID: u32,
135 buffer: *mut c_void,
136 size: *mut usize,
137 ) -> TEE_Result;
138 pub fn TEE_GetObjectValueAttribute(
139 object: TEE_ObjectHandle,
140 attributeID: u32,
141 a: *mut u32,
142 b: *mut u32,
143 ) -> TEE_Result;
144 pub fn TEE_CloseObject(object: TEE_ObjectHandle);
145
146 pub fn TEE_AllocateTransientObject(
149 objectType: TEE_ObjectType,
150 maxObjectSize: u32,
151 object: *mut TEE_ObjectHandle,
152 ) -> TEE_Result;
153 pub fn TEE_FreeTransientObject(object: TEE_ObjectHandle);
154 pub fn TEE_ResetTransientObject(object: TEE_ObjectHandle);
155 pub fn TEE_PopulateTransientObject(
156 object: TEE_ObjectHandle,
157 attrs: *const TEE_Attribute,
158 attrCount: u32,
159 ) -> TEE_Result;
160 pub fn TEE_InitRefAttribute(
161 attr: *mut TEE_Attribute,
162 attributeID: u32,
163 buffer: *const c_void,
164 length: usize,
165 );
166 pub fn TEE_InitValueAttribute(attr: *mut TEE_Attribute, attributeID: u32, a: u32, b: u32);
167 pub fn TEE_CopyObjectAttributes(destObject: TEE_ObjectHandle, srcObject: TEE_ObjectHandle);
168 pub fn TEE_CopyObjectAttributes1(
169 destObject: TEE_ObjectHandle,
170 srcObject: TEE_ObjectHandle,
171 ) -> TEE_Result;
172 pub fn TEE_GenerateKey(
173 object: TEE_ObjectHandle,
174 keySize: u32,
175 params: *const TEE_Attribute,
176 paramCount: u32,
177 ) -> TEE_Result;
178
179 pub fn TEE_OpenPersistentObject(
182 storageID: u32,
183 objectID: *const c_void,
184 objectIDLen: usize,
185 flags: u32,
186 object: *mut TEE_ObjectHandle,
187 ) -> TEE_Result;
188 pub fn TEE_CreatePersistentObject(
189 storageID: u32,
190 objectID: *const c_void,
191 objectIDLen: usize,
192 flags: u32,
193 attributes: TEE_ObjectHandle,
194 initialData: *const c_void,
195 initialDataLen: usize,
196 object: *mut TEE_ObjectHandle,
197 ) -> TEE_Result;
198 pub fn TEE_CloseAndDeletePersistentObject(object: TEE_ObjectHandle);
199 pub fn TEE_CloseAndDeletePersistentObject1(object: TEE_ObjectHandle) -> TEE_Result;
200 pub fn TEE_RenamePersistentObject(
201 object: TEE_ObjectHandle,
202 newObjectID: *const c_void,
203 newObjectIDLen: usize,
204 ) -> TEE_Result;
205 pub fn TEE_AllocatePersistentObjectEnumerator(
206 objectEnumerator: *mut TEE_ObjectEnumHandle,
207 ) -> TEE_Result;
208 pub fn TEE_FreePersistentObjectEnumerator(objectEnumerator: TEE_ObjectEnumHandle);
209 pub fn TEE_ResetPersistentObjectEnumerator(objectEnumerator: TEE_ObjectEnumHandle);
210 pub fn TEE_StartPersistentObjectEnumerator(
211 objectEnumerator: TEE_ObjectEnumHandle,
212 storageID: u32,
213 ) -> TEE_Result;
214 pub fn TEE_GetNextPersistentObject(
215 objectEnumerator: TEE_ObjectEnumHandle,
216 objectInfo: *mut TEE_ObjectInfo,
217 objectID: *mut c_void,
218 objectIDLen: *mut usize,
219 ) -> TEE_Result;
220
221 pub fn TEE_ReadObjectData(
224 object: TEE_ObjectHandle,
225 buffer: *mut c_void,
226 size: usize,
227 count: *mut usize,
228 ) -> TEE_Result;
229 pub fn TEE_WriteObjectData(
230 object: TEE_ObjectHandle,
231 buffer: *const c_void,
232 size: usize,
233 ) -> TEE_Result;
234 pub fn TEE_TruncateObjectData(object: TEE_ObjectHandle, size: usize) -> TEE_Result;
235 pub fn TEE_SeekObjectData(
236 object: TEE_ObjectHandle,
237 offset: intmax_t,
238 whence: TEE_Whence,
239 ) -> TEE_Result;
240
241 pub fn TEE_AllocateOperation(
244 operation: *mut TEE_OperationHandle,
245 algorithm: u32,
246 mode: u32,
247 maxKeySize: u32,
248 ) -> TEE_Result;
249 pub fn TEE_FreeOperation(operation: TEE_OperationHandle);
250 pub fn TEE_GetOperationInfo(
251 operation: TEE_OperationHandle,
252 operationInfo: *mut TEE_OperationInfo,
253 );
254 pub fn TEE_GetOperationInfoMultiple(
255 operation: TEE_OperationHandle,
256 operationInfoMultiple: *mut TEE_OperationInfoMultiple,
257 operationSize: *mut usize,
258 ) -> TEE_Result;
259 pub fn TEE_ResetOperation(operation: TEE_OperationHandle);
260 pub fn TEE_SetOperationKey(
261 operation: TEE_OperationHandle,
262 key: TEE_ObjectHandle,
263 ) -> TEE_Result;
264 pub fn TEE_SetOperationKey2(
265 operation: TEE_OperationHandle,
266 key1: TEE_ObjectHandle,
267 key2: TEE_ObjectHandle,
268 ) -> TEE_Result;
269 pub fn TEE_CopyOperation(
270 dstOperation: TEE_OperationHandle,
271 srcOperation: TEE_OperationHandle,
272 );
273 pub fn TEE_IsAlgorithmSupported(algId: u32, element: u32) -> TEE_Result;
274
275 pub fn TEE_DigestUpdate(
278 operation: TEE_OperationHandle,
279 chunk: *const c_void,
280 chunkSize: usize,
281 );
282 pub fn TEE_DigestDoFinal(
283 operation: TEE_OperationHandle,
284 chunk: *const c_void,
285 chunkLen: usize,
286 hash: *mut c_void,
287 hashLen: *mut usize,
288 ) -> TEE_Result;
289
290 pub fn TEE_CipherInit(operation: TEE_OperationHandle, IV: *const c_void, IVLen: usize);
293 pub fn TEE_CipherUpdate(
294 operation: TEE_OperationHandle,
295 srcData: *const c_void,
296 srcLen: usize,
297 destData: *mut c_void,
298 destLen: *mut usize,
299 ) -> TEE_Result;
300 pub fn TEE_CipherDoFinal(
301 operation: TEE_OperationHandle,
302 srcData: *const c_void,
303 srcLen: usize,
304 destData: *mut c_void,
305 destLen: *mut usize,
306 ) -> TEE_Result;
307
308 pub fn TEE_MACInit(operation: TEE_OperationHandle, IV: *const c_void, IVLen: usize);
311 pub fn TEE_MACUpdate(
312 operation: TEE_OperationHandle,
313 chunk: *const c_void,
314 chunkSize: usize,
315 );
316 pub fn TEE_MACComputeFinal(
317 operation: TEE_OperationHandle,
318 message: *const c_void,
319 messageLen: usize,
320 mac: *mut c_void,
321 macLen: *mut usize,
322 ) -> TEE_Result;
323 pub fn TEE_MACCompareFinal(
324 operation: TEE_OperationHandle,
325 message: *const c_void,
326 messageLen: usize,
327 mac: *const c_void,
328 macLen: usize,
329 ) -> TEE_Result;
330
331 pub fn TEE_AEInit(
334 operation: TEE_OperationHandle,
335 nonce: *const c_void,
336 nonceLen: usize,
337 tagLen: u32,
338 AADLen: usize,
339 payloadLen: usize,
340 ) -> TEE_Result;
341 pub fn TEE_AEUpdateAAD(
342 operation: TEE_OperationHandle,
343 AADdata: *const c_void,
344 AADdataLen: usize,
345 );
346 pub fn TEE_AEUpdate(
347 operation: TEE_OperationHandle,
348 srcData: *const c_void,
349 srcLen: usize,
350 destData: *mut c_void,
351 destLen: *mut usize,
352 ) -> TEE_Result;
353 pub fn TEE_AEEncryptFinal(
354 operation: TEE_OperationHandle,
355 srcData: *const c_void,
356 srcLen: usize,
357 destData: *mut c_void,
358 destLen: *mut usize,
359 tag: *mut c_void,
360 tagLen: *mut usize,
361 ) -> TEE_Result;
362 pub fn TEE_AEDecryptFinal(
363 operation: TEE_OperationHandle,
364 srcData: *const c_void,
365 srcLen: usize,
366 destData: *mut c_void,
367 destLen: *mut usize,
368 tag: *mut c_void,
369 tagLen: usize,
370 ) -> TEE_Result;
371
372 pub fn TEE_AsymmetricEncrypt(
375 operation: TEE_OperationHandle,
376 params: *const TEE_Attribute,
377 paramCount: u32,
378 srcData: *const c_void,
379 srcLen: usize,
380 destData: *mut c_void,
381 destLen: *mut usize,
382 ) -> TEE_Result;
383 pub fn TEE_AsymmetricDecrypt(
384 operation: TEE_OperationHandle,
385 params: *const TEE_Attribute,
386 paramCount: u32,
387 srcData: *const c_void,
388 srcLen: usize,
389 destData: *mut c_void,
390 destLen: *mut usize,
391 ) -> TEE_Result;
392 pub fn TEE_AsymmetricSignDigest(
393 operation: TEE_OperationHandle,
394 params: *const TEE_Attribute,
395 paramCount: u32,
396 digest: *const c_void,
397 digestLen: usize,
398 signature: *mut c_void,
399 signatureLen: *mut usize,
400 ) -> TEE_Result;
401 pub fn TEE_AsymmetricVerifyDigest(
402 operation: TEE_OperationHandle,
403 params: *const TEE_Attribute,
404 paramCount: u32,
405 digest: *const c_void,
406 digestLen: usize,
407 signature: *const c_void,
408 signatureLen: usize,
409 ) -> TEE_Result;
410
411 pub fn TEE_DeriveKey(
414 operation: TEE_OperationHandle,
415 params: *const TEE_Attribute,
416 paramCount: u32,
417 derivedKey: TEE_ObjectHandle,
418 );
419
420 pub fn TEE_GenerateRandom(randomBuffer: *mut c_void, randomBufferLen: usize);
423
424 pub fn TEE_GetSystemTime(time: *mut TEE_Time);
427 pub fn TEE_Wait(timeout: u32) -> TEE_Result;
428 pub fn TEE_GetTAPersistentTime(time: *mut TEE_Time) -> TEE_Result;
429 pub fn TEE_SetTAPersistentTime(time: *const TEE_Time) -> TEE_Result;
430 pub fn TEE_GetREETime(time: *mut TEE_Time);
431
432 pub fn TEE_BigIntFMMSizeInU32(modulusSizeInBits: usize) -> usize;
435 pub fn TEE_BigIntFMMContextSizeInU32(modulusSizeInBits: usize) -> usize;
436
437 pub fn TEE_BigIntInit(bigInt: *mut TEE_BigInt, len: usize);
440 pub fn TEE_BigIntInitFMMContext(
441 context: *mut TEE_BigIntFMMContext,
442 len: usize,
443 modulus: *const TEE_BigInt,
444 );
445 pub fn TEE_BigIntInitFMM(bigIntFMM: *mut TEE_BigIntFMM, len: usize);
446
447 pub fn TEE_BigIntConvertFromOctetString(
450 dest: *mut TEE_BigInt,
451 buffer: *const u8,
452 bufferLen: usize,
453 sign: i32,
454 ) -> TEE_Result;
455 pub fn TEE_BigIntConvertToOctetString(
456 buffer: *mut u8,
457 bufferLen: *mut usize,
458 bigInt: *const TEE_BigInt,
459 ) -> TEE_Result;
460 pub fn TEE_BigIntConvertFromS32(dest: *mut TEE_BigInt, shortVal: i32);
461 pub fn TEE_BigIntConvertToS32(dest: *mut i32, src: *const TEE_BigInt) -> TEE_Result;
462
463 pub fn TEE_BigIntCmp(op1: *const TEE_BigInt, op2: *const TEE_BigInt) -> i32;
466 pub fn TEE_BigIntCmpS32(op: *const TEE_BigInt, shortVal: i32) -> i32;
467 pub fn TEE_BigIntShiftRight(dest: *mut TEE_BigInt, op: *const TEE_BigInt, bits: size_t);
468 pub fn TEE_BigIntGetBit(src: *const TEE_BigInt, bitIndex: u32) -> bool;
469 pub fn TEE_BigIntGetBitCount(src: *const TEE_BigInt) -> u32;
470 pub fn TEE_BigIntSetBit(src: *mut TEE_BigInt, bitIndex: u32, value: bool) -> TEE_Result;
471 pub fn TEE_BigIntAssign(dest: *mut TEE_BigInt, src: *const TEE_BigInt) -> TEE_Result;
472 pub fn TEE_BigIntAbs(dest: *mut TEE_BigInt, src: *const TEE_BigInt) -> TEE_Result;
473 pub fn TEE_BigIntAdd(dest: *mut TEE_BigInt, op1: *const TEE_BigInt, op2: *const TEE_BigInt);
474 pub fn TEE_BigIntSub(dest: *mut TEE_BigInt, op1: *const TEE_BigInt, op2: *const TEE_BigInt);
475 pub fn TEE_BigIntNeg(dest: *mut TEE_BigInt, op: *const TEE_BigInt);
476 pub fn TEE_BigIntMul(dest: *mut TEE_BigInt, op1: *const TEE_BigInt, op2: *const TEE_BigInt);
477 pub fn TEE_BigIntSquare(dest: *mut TEE_BigInt, op: *const TEE_BigInt);
478 pub fn TEE_BigIntDiv(
479 dest_q: *mut TEE_BigInt,
480 dest_r: *mut TEE_BigInt,
481 op1: *const TEE_BigInt,
482 op2: *const TEE_BigInt,
483 );
484
485 pub fn TEE_BigIntMod(dest: *mut TEE_BigInt, op: *const TEE_BigInt, n: *const TEE_BigInt);
488 pub fn TEE_BigIntAddMod(
489 dest: *mut TEE_BigInt,
490 op1: *const TEE_BigInt,
491 op2: *const TEE_BigInt,
492 n: *const TEE_BigInt,
493 );
494 pub fn TEE_BigIntSubMod(
495 dest: *mut TEE_BigInt,
496 op1: *const TEE_BigInt,
497 op2: *const TEE_BigInt,
498 n: *const TEE_BigInt,
499 );
500 pub fn TEE_BigIntMulMod(
501 dest: *mut TEE_BigInt,
502 op1: *const TEE_BigInt,
503 op2: *const TEE_BigInt,
504 n: *const TEE_BigInt,
505 );
506 pub fn TEE_BigIntSquareMod(
507 dest: *mut TEE_BigInt,
508 op: *const TEE_BigInt,
509 n: *const TEE_BigInt,
510 );
511 pub fn TEE_BigIntInvMod(dest: *mut TEE_BigInt, op: *const TEE_BigInt, n: *const TEE_BigInt);
512 pub fn TEE_BigIntExpMod(
513 dest: *mut TEE_BigInt,
514 op1: *const TEE_BigInt,
515 op2: *const TEE_BigInt,
516 n: *const TEE_BigInt,
517 context: *const TEE_BigIntFMMContext,
518 ) -> TEE_Result;
519
520 pub fn TEE_BigIntRelativePrime(op1: *const TEE_BigInt, op2: *const TEE_BigInt) -> bool;
523 pub fn TEE_BigIntComputeExtendedGcd(
524 gcd: *mut TEE_BigInt,
525 u: *mut TEE_BigInt,
526 v: *mut TEE_BigInt,
527 op1: *const TEE_BigInt,
528 op2: *const TEE_BigInt,
529 );
530 pub fn TEE_BigIntIsProbablePrime(op: *const TEE_BigInt, confidenceLevel: u32) -> i32;
531
532 pub fn TEE_BigIntConvertToFMM(
535 dest: *mut TEE_BigIntFMM,
536 src: *const TEE_BigInt,
537 n: *const TEE_BigInt,
538 context: *const TEE_BigIntFMMContext,
539 );
540 pub fn TEE_BigIntConvertFromFMM(
541 dest: *mut TEE_BigInt,
542 src: *const TEE_BigIntFMM,
543 n: *const TEE_BigInt,
544 context: *const TEE_BigIntFMMContext,
545 );
546 pub fn TEE_BigIntComputeFMM(
547 dest: *mut TEE_BigIntFMM,
548 op1: *const TEE_BigIntFMM,
549 op2: *const TEE_BigIntFMM,
550 n: *const TEE_BigInt,
551 context: *const TEE_BigIntFMMContext,
552 );
553 }
554}