Skip to main content

optee_utee_sys/
tee_api.rs

1// Licensed to the Apache Software Foundation (ASF) under one
2// or more contributor license agreements.  See the NOTICE file
3// distributed with this work for additional information
4// regarding copyright ownership.  The ASF licenses this file
5// to you under the Apache License, Version 2.0 (the
6// "License"); you may not use this file except in compliance
7// with the License.  You may obtain a copy of the License at
8//
9//   http://www.apache.org/licenses/LICENSE-2.0
10//
11// Unless required by applicable law or agreed to in writing,
12// software distributed under the License is distributed on an
13// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14// KIND, either express or implied.  See the License for the
15// specific language governing permissions and limitations
16// under the License.
17
18#[cfg_attr(feature = "mock", mockall::automock)]
19pub mod api {
20    use crate::*;
21    use core::ffi::*;
22
23    unsafe extern "C" {
24        // Property access functions
25
26        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        // System API - Misc
78
79        pub fn TEE_Panic(panicCode: TEE_Result);
80
81        // System API - Internal Client API
82
83        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        // System API - Cancellations
102
103        pub fn TEE_GetCancellationFlag() -> bool;
104        pub fn TEE_UnmaskCancellation() -> bool;
105        pub fn TEE_MaskCancellation() -> bool;
106
107        // System API - Memory Management
108
109        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        // Data and Key Storage API  - Generic Object Functions
124
125        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        /* Data and Key Storage API  - Transient Object Functions */
147
148        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        // Data and Key Storage API  - Persistent Object Functions
180
181        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        // Data and Key Storage API  - Data Stream Access Functions
222
223        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        // Cryptographic Operations API - Generic Operation Functions
242
243        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        // Cryptographic Operations API - Message Digest Functions
276
277        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        // Cryptographic Operations API - Symmetric Cipher Functions
291
292        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        // Cryptographic Operations API - MAC Functions
309
310        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        // Cryptographic Operations API - Authenticated Encryption Functions
332
333        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        // Cryptographic Operations API - Asymmetric Functions
373
374        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        // Cryptographic Operations API - Key Derivation Functions
412
413        pub fn TEE_DeriveKey(
414            operation: TEE_OperationHandle,
415            params: *const TEE_Attribute,
416            paramCount: u32,
417            derivedKey: TEE_ObjectHandle,
418        );
419
420        // Cryptographic Operations API - Random Number Generation Functions
421
422        pub fn TEE_GenerateRandom(randomBuffer: *mut c_void, randomBufferLen: usize);
423
424        // Date & Time API
425
426        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        // TEE Arithmetical API - Memory allocation and size of objects
433
434        pub fn TEE_BigIntFMMSizeInU32(modulusSizeInBits: usize) -> usize;
435        pub fn TEE_BigIntFMMContextSizeInU32(modulusSizeInBits: usize) -> usize;
436
437        // TEE Arithmetical API - Initialization functions
438
439        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        // TEE Arithmetical API - Converter functions
448
449        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        // TEE Arithmetical API - Logical operations
464
465        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        // TEE Arithmetical API - Modular arithmetic operations
486
487        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        // TEE Arithmetical API - Other arithmetic operations
521
522        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        // TEE Arithmetical API - Fast modular multiplication operations
533
534        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}