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 use super::*;
19 
20 #[cfg(feature = "std")]
21 use std::os::raw::*;
22 #[cfg(not(feature = "std"))]
23 use core::ffi::*;
24 
25 extern "C" {
26     // Property access functions
27 
TEE_GetPropertyAsString( propsetOrEnumerator: TEE_PropSetHandle, name: *const c_char, valueBuffer: *mut c_char, valueBufferLen: *mut usize, ) -> TEE_Result28     pub fn TEE_GetPropertyAsString(
29         propsetOrEnumerator: TEE_PropSetHandle,
30         name: *const c_char,
31         valueBuffer: *mut c_char,
32         valueBufferLen: *mut usize,
33     ) -> TEE_Result;
TEE_GetPropertyAsBool( propsetOrEnumerator: TEE_PropSetHandle, name: *const c_char, value: *mut bool, ) -> TEE_Result34     pub fn TEE_GetPropertyAsBool(
35         propsetOrEnumerator: TEE_PropSetHandle,
36         name: *const c_char,
37         value: *mut bool,
38     ) -> TEE_Result;
TEE_GetPropertyAsU32( propsetOrEnumerator: TEE_PropSetHandle, name: *const c_char, value: *mut u32, ) -> TEE_Result39     pub fn TEE_GetPropertyAsU32(
40         propsetOrEnumerator: TEE_PropSetHandle,
41         name: *const c_char,
42         value: *mut u32,
43     ) -> TEE_Result;
TEE_GetPropertyAsU64( propsetOrEnumerator: TEE_PropSetHandle, name: *const c_char, value: *mut u64, ) -> TEE_Result44     pub fn TEE_GetPropertyAsU64(
45         propsetOrEnumerator: TEE_PropSetHandle,
46         name: *const c_char,
47         value: *mut u64,
48     ) -> TEE_Result;
TEE_GetPropertyAsBinaryBlock( propsetOrEnumerator: TEE_PropSetHandle, name: *const c_char, valueBuffer: *mut c_void, valueBufferLen: *mut usize, ) -> TEE_Result49     pub fn TEE_GetPropertyAsBinaryBlock(
50         propsetOrEnumerator: TEE_PropSetHandle,
51         name: *const c_char,
52         valueBuffer: *mut c_void,
53         valueBufferLen: *mut usize,
54     ) -> TEE_Result;
TEE_GetPropertyAsUUID( propsetOrEnumerator: TEE_PropSetHandle, name: *const c_char, value: *mut TEE_UUID, ) -> TEE_Result55     pub fn TEE_GetPropertyAsUUID(
56         propsetOrEnumerator: TEE_PropSetHandle,
57         name: *const c_char,
58         value: *mut TEE_UUID,
59     ) -> TEE_Result;
TEE_GetPropertyAsIdentity( propsetOrEnumerator: TEE_PropSetHandle, name: *const c_char, value: *mut TEE_Identity, ) -> TEE_Result60     pub fn TEE_GetPropertyAsIdentity(
61         propsetOrEnumerator: TEE_PropSetHandle,
62         name: *const c_char,
63         value: *mut TEE_Identity,
64     ) -> TEE_Result;
TEE_AllocatePropertyEnumerator(enumerator: *mut TEE_PropSetHandle) -> TEE_Result65     pub fn TEE_AllocatePropertyEnumerator(enumerator: *mut TEE_PropSetHandle) -> TEE_Result;
TEE_FreePropertyEnumerator(enumerator: TEE_PropSetHandle)66     pub fn TEE_FreePropertyEnumerator(enumerator: TEE_PropSetHandle);
TEE_StartPropertyEnumerator(enumerator: TEE_PropSetHandle, propSet: TEE_PropSetHandle)67     pub fn TEE_StartPropertyEnumerator(enumerator: TEE_PropSetHandle, propSet: TEE_PropSetHandle);
TEE_ResetPropertyEnumerator(enumerator: TEE_PropSetHandle)68     pub fn TEE_ResetPropertyEnumerator(enumerator: TEE_PropSetHandle);
TEE_GetPropertyName( enumerator: TEE_PropSetHandle, nameBuffer: *mut c_void, nameBufferLen: *mut usize, ) -> TEE_Result69     pub fn TEE_GetPropertyName(
70         enumerator: TEE_PropSetHandle,
71         nameBuffer: *mut c_void,
72         nameBufferLen: *mut usize,
73     ) -> TEE_Result;
TEE_GetNextProperty(enumerator: TEE_PropSetHandle) -> TEE_Result74     pub fn TEE_GetNextProperty(enumerator: TEE_PropSetHandle) -> TEE_Result;
75 
76     // System API - Misc
77 
TEE_Panic(panicCode: TEE_Result)78     pub fn TEE_Panic(panicCode: TEE_Result);
79 
80     // System API - Internal Client API
81 
TEE_OpenTASession( destination: *const TEE_UUID, cancellationRequestTimeout: u32, paramTypes: u32, params: *mut TEE_Param, session: *mut TEE_TASessionHandle, returnOrigin: *mut u32, ) -> TEE_Result82     pub fn TEE_OpenTASession(
83         destination: *const TEE_UUID,
84         cancellationRequestTimeout: u32,
85         paramTypes: u32,
86         params: *mut TEE_Param,
87         session: *mut TEE_TASessionHandle,
88         returnOrigin: *mut u32,
89     ) -> TEE_Result;
TEE_CloseTASession(session: TEE_TASessionHandle)90     pub fn TEE_CloseTASession(session: TEE_TASessionHandle);
TEE_InvokeTACommand( session: TEE_TASessionHandle, cancellationRequestTimeout: u32, commandID: u32, paramTypes: u32, params: *mut TEE_Param, returnOrigin: *mut u32, ) -> TEE_Result91     pub fn TEE_InvokeTACommand(
92         session: TEE_TASessionHandle,
93         cancellationRequestTimeout: u32,
94         commandID: u32,
95         paramTypes: u32,
96         params: *mut TEE_Param,
97         returnOrigin: *mut u32,
98     ) -> TEE_Result;
99 
100     // System API - Cancellations
101 
TEE_GetCancellationFlag() -> bool102     pub fn TEE_GetCancellationFlag() -> bool;
TEE_UnmaskCancellation() -> bool103     pub fn TEE_UnmaskCancellation() -> bool;
TEE_MaskCancellation() -> bool104     pub fn TEE_MaskCancellation() -> bool;
105 
106     // System API - Memory Management
107 
TEE_CheckMemoryAccessRights( accessFlags: u32, buffer: *mut c_void, size: usize, ) -> TEE_Result108     pub fn TEE_CheckMemoryAccessRights(
109         accessFlags: u32,
110         buffer: *mut c_void,
111         size: usize,
112     ) -> TEE_Result;
TEE_SetInstanceData(instanceData: *const c_void)113     pub fn TEE_SetInstanceData(instanceData: *const c_void);
TEE_GetInstanceData() -> *const c_void114     pub fn TEE_GetInstanceData() -> *const c_void;
TEE_Malloc(size: usize, hint: u32) -> *mut c_void115     pub fn TEE_Malloc(size: usize, hint: u32) -> *mut c_void;
TEE_Realloc(buffer: *mut c_void, newSize: usize) -> *mut c_void116     pub fn TEE_Realloc(buffer: *mut c_void, newSize: usize) -> *mut c_void;
TEE_Free(buffer: *mut c_void)117     pub fn TEE_Free(buffer: *mut c_void);
TEE_MemMove(dest: *mut c_void, src: *const c_void, size: usize) -> *mut c_void118     pub fn TEE_MemMove(dest: *mut c_void, src: *const c_void, size: usize) -> *mut c_void;
TEE_MemCompare( buffer1: *const c_void, buffer2: *const c_void, size: usize, ) -> i32119     pub fn TEE_MemCompare(
120         buffer1: *const c_void,
121         buffer2: *const c_void,
122         size: usize,
123     ) -> i32;
TEE_MemFill(buff: *mut c_void, x: u32, size: usize) -> *mut c_void124     pub fn TEE_MemFill(buff: *mut c_void, x: u32, size: usize) -> *mut c_void;
125 
126     // Data and Key Storage API  - Generic Object Functions
127 
TEE_GetObjectInfo(object: TEE_ObjectHandle, objectInfo: *mut TEE_ObjectInfo)128     pub fn TEE_GetObjectInfo(object: TEE_ObjectHandle, objectInfo: *mut TEE_ObjectInfo);
TEE_GetObjectInfo1( object: TEE_ObjectHandle, objectInfo: *mut TEE_ObjectInfo, ) -> TEE_Result129     pub fn TEE_GetObjectInfo1(
130         object: TEE_ObjectHandle,
131         objectInfo: *mut TEE_ObjectInfo,
132     ) -> TEE_Result;
TEE_RestrictObjectUsage(object: TEE_ObjectHandle, objectUsage: u32)133     pub fn TEE_RestrictObjectUsage(object: TEE_ObjectHandle, objectUsage: u32);
TEE_RestrictObjectUsage1(object: TEE_ObjectHandle, objectUsage: u32) -> TEE_Result134     pub fn TEE_RestrictObjectUsage1(object: TEE_ObjectHandle, objectUsage: u32) -> TEE_Result;
TEE_GetObjectBufferAttribute( object: TEE_ObjectHandle, attributeID: u32, buffer: *mut c_void, size: *mut usize, ) -> TEE_Result135     pub fn TEE_GetObjectBufferAttribute(
136         object: TEE_ObjectHandle,
137         attributeID: u32,
138         buffer: *mut c_void,
139         size: *mut usize,
140     ) -> TEE_Result;
TEE_GetObjectValueAttribute( object: TEE_ObjectHandle, attributeID: u32, a: *mut u32, b: *mut u32, ) -> TEE_Result141     pub fn TEE_GetObjectValueAttribute(
142         object: TEE_ObjectHandle,
143         attributeID: u32,
144         a: *mut u32,
145         b: *mut u32,
146     ) -> TEE_Result;
TEE_CloseObject(object: TEE_ObjectHandle)147     pub fn TEE_CloseObject(object: TEE_ObjectHandle);
148 
149     /* Data and Key Storage API  - Transient Object Functions */
150 
TEE_AllocateTransientObject( objectType: TEE_ObjectType, maxObjectSize: u32, object: *mut TEE_ObjectHandle, ) -> TEE_Result151     pub fn TEE_AllocateTransientObject(
152         objectType: TEE_ObjectType,
153         maxObjectSize: u32,
154         object: *mut TEE_ObjectHandle,
155     ) -> TEE_Result;
TEE_FreeTransientObject(object: TEE_ObjectHandle) -> c_void156     pub fn TEE_FreeTransientObject(object: TEE_ObjectHandle) -> c_void;
TEE_ResetTransientObject(object: TEE_ObjectHandle) -> c_void157     pub fn TEE_ResetTransientObject(object: TEE_ObjectHandle) -> c_void;
TEE_PopulateTransientObject( object: TEE_ObjectHandle, attrs: *const TEE_Attribute, attrCount: u32, ) -> TEE_Result158     pub fn TEE_PopulateTransientObject(
159         object: TEE_ObjectHandle,
160         attrs: *const TEE_Attribute,
161         attrCount: u32,
162     ) -> TEE_Result;
TEE_InitRefAttribute( attr: *mut TEE_Attribute, attributeID: u32, buffer: *const c_void, length: usize, ) -> c_void163     pub fn TEE_InitRefAttribute(
164         attr: *mut TEE_Attribute,
165         attributeID: u32,
166         buffer: *const c_void,
167         length: usize,
168     ) -> c_void;
TEE_InitValueAttribute( attr: *mut TEE_Attribute, attributeID: u32, a: u32, b: u32, ) -> c_void169     pub fn TEE_InitValueAttribute(
170         attr: *mut TEE_Attribute,
171         attributeID: u32,
172         a: u32,
173         b: u32,
174     ) -> c_void;
TEE_CopyObjectAttributes( destObject: TEE_ObjectHandle, srcObject: TEE_ObjectHandle, ) -> c_void175     pub fn TEE_CopyObjectAttributes(
176         destObject: TEE_ObjectHandle,
177         srcObject: TEE_ObjectHandle,
178     ) -> c_void;
TEE_CopyObjectAttributes1( destObject: TEE_ObjectHandle, srcObject: TEE_ObjectHandle, ) -> TEE_Result179     pub fn TEE_CopyObjectAttributes1(
180         destObject: TEE_ObjectHandle,
181         srcObject: TEE_ObjectHandle,
182     ) -> TEE_Result;
TEE_GenerateKey( object: TEE_ObjectHandle, keySize: u32, params: *const TEE_Attribute, paramCount: u32, ) -> TEE_Result183     pub fn TEE_GenerateKey(
184         object: TEE_ObjectHandle,
185         keySize: u32,
186         params: *const TEE_Attribute,
187         paramCount: u32,
188     ) -> TEE_Result;
189 
190     // Data and Key Storage API  - Persistent Object Functions
191 
TEE_OpenPersistentObject( storageID: u32, objectID: *const c_void, objectIDLen: usize, flags: u32, object: *mut TEE_ObjectHandle, ) -> TEE_Result192     pub fn TEE_OpenPersistentObject(
193         storageID: u32,
194         objectID: *const c_void,
195         objectIDLen: usize,
196         flags: u32,
197         object: *mut TEE_ObjectHandle,
198     ) -> TEE_Result;
TEE_CreatePersistentObject( storageID: u32, objectID: *const c_void, objectIDLen: usize, flags: u32, attributes: TEE_ObjectHandle, initialData: *const c_void, initialDataLen: usize, object: *mut TEE_ObjectHandle, ) -> TEE_Result199     pub fn TEE_CreatePersistentObject(
200         storageID: u32,
201         objectID: *const c_void,
202         objectIDLen: usize,
203         flags: u32,
204         attributes: TEE_ObjectHandle,
205         initialData: *const c_void,
206         initialDataLen: usize,
207         object: *mut TEE_ObjectHandle,
208     ) -> TEE_Result;
TEE_CloseAndDeletePersistentObject(object: TEE_ObjectHandle)209     pub fn TEE_CloseAndDeletePersistentObject(object: TEE_ObjectHandle);
TEE_CloseAndDeletePersistentObject1(object: TEE_ObjectHandle) -> TEE_Result210     pub fn TEE_CloseAndDeletePersistentObject1(object: TEE_ObjectHandle) -> TEE_Result;
TEE_RenamePersistentObject( object: TEE_ObjectHandle, newObjectID: *const c_void, newObjectIDLen: usize, ) -> TEE_Result211     pub fn TEE_RenamePersistentObject(
212         object: TEE_ObjectHandle,
213         newObjectID: *const c_void,
214         newObjectIDLen: usize,
215     ) -> TEE_Result;
TEE_AllocatePersistentObjectEnumerator( objectEnumerator: *mut TEE_ObjectEnumHandle, ) -> TEE_Result216     pub fn TEE_AllocatePersistentObjectEnumerator(
217         objectEnumerator: *mut TEE_ObjectEnumHandle,
218     ) -> TEE_Result;
TEE_FreePersistentObjectEnumerator(objectEnumerator: TEE_ObjectEnumHandle)219     pub fn TEE_FreePersistentObjectEnumerator(objectEnumerator: TEE_ObjectEnumHandle);
TEE_ResetPersistentObjectEnumerator(objectEnumerator: TEE_ObjectEnumHandle)220     pub fn TEE_ResetPersistentObjectEnumerator(objectEnumerator: TEE_ObjectEnumHandle);
TEE_StartPersistentObjectEnumerator( objectEnumerator: TEE_ObjectEnumHandle, storageID: u32, ) -> TEE_Result221     pub fn TEE_StartPersistentObjectEnumerator(
222         objectEnumerator: TEE_ObjectEnumHandle,
223         storageID: u32,
224     ) -> TEE_Result;
TEE_GetNextPersistentObject( objectEnumerator: TEE_ObjectEnumHandle, objectInfo: *mut TEE_ObjectInfo, objectID: *mut c_void, objectIDLen: *mut usize, ) -> TEE_Result225     pub fn TEE_GetNextPersistentObject(
226         objectEnumerator: TEE_ObjectEnumHandle,
227         objectInfo: *mut TEE_ObjectInfo,
228         objectID: *mut c_void,
229         objectIDLen: *mut usize,
230     ) -> TEE_Result;
231 
232     // Data and Key Storage API  - Data Stream Access Functions
233 
TEE_ReadObjectData( object: TEE_ObjectHandle, buffer: *mut c_void, size: usize, count: *mut usize, ) -> TEE_Result234     pub fn TEE_ReadObjectData(
235         object: TEE_ObjectHandle,
236         buffer: *mut c_void,
237         size: usize,
238         count: *mut usize,
239     ) -> TEE_Result;
TEE_WriteObjectData( object: TEE_ObjectHandle, buffer: *const c_void, size: usize, ) -> TEE_Result240     pub fn TEE_WriteObjectData(
241         object: TEE_ObjectHandle,
242         buffer: *const c_void,
243         size: usize,
244     ) -> TEE_Result;
TEE_TruncateObjectData(object: TEE_ObjectHandle, size: usize) -> TEE_Result245     pub fn TEE_TruncateObjectData(object: TEE_ObjectHandle, size: usize) -> TEE_Result;
TEE_SeekObjectData( object: TEE_ObjectHandle, offset: i32, whence: TEE_Whence, ) -> TEE_Result246     pub fn TEE_SeekObjectData(
247         object: TEE_ObjectHandle,
248         offset: i32, //intmax_t
249         whence: TEE_Whence,
250     ) -> TEE_Result;
251 
252     // Cryptographic Operations API - Generic Operation Functions
253 
TEE_AllocateOperation( operation: *mut TEE_OperationHandle, algorithm: u32, mode: u32, maxKeySize: u32, ) -> TEE_Result254     pub fn TEE_AllocateOperation(
255         operation: *mut TEE_OperationHandle,
256         algorithm: u32,
257         mode: u32,
258         maxKeySize: u32,
259     ) -> TEE_Result;
TEE_FreeOperation(operation: TEE_OperationHandle) -> c_void260     pub fn TEE_FreeOperation(operation: TEE_OperationHandle) -> c_void;
TEE_GetOperationInfo( operation: TEE_OperationHandle, operationInfo: *mut TEE_OperationInfo, ) -> c_void261     pub fn TEE_GetOperationInfo(
262         operation: TEE_OperationHandle,
263         operationInfo: *mut TEE_OperationInfo,
264     ) -> c_void;
TEE_GetOperationInfoMultiple( operation: TEE_OperationHandle, operationInfoMultiple: *mut TEE_OperationInfoMultiple, operationSize: *mut usize, ) -> TEE_Result265     pub fn TEE_GetOperationInfoMultiple(
266         operation: TEE_OperationHandle,
267         operationInfoMultiple: *mut TEE_OperationInfoMultiple,
268         operationSize: *mut usize,
269     ) -> TEE_Result;
TEE_ResetOperation(operation: TEE_OperationHandle) -> c_void270     pub fn TEE_ResetOperation(operation: TEE_OperationHandle) -> c_void;
TEE_SetOperationKey(operation: TEE_OperationHandle, key: TEE_ObjectHandle) -> TEE_Result271     pub fn TEE_SetOperationKey(operation: TEE_OperationHandle, key: TEE_ObjectHandle)
272         -> TEE_Result;
TEE_SetOperationKey2( operation: TEE_OperationHandle, key1: TEE_ObjectHandle, key2: TEE_ObjectHandle, ) -> TEE_Result273     pub fn TEE_SetOperationKey2(
274         operation: TEE_OperationHandle,
275         key1: TEE_ObjectHandle,
276         key2: TEE_ObjectHandle,
277     ) -> TEE_Result;
TEE_CopyOperation( dstOperation: TEE_OperationHandle, srcOperation: TEE_OperationHandle, ) -> c_void278     pub fn TEE_CopyOperation(
279         dstOperation: TEE_OperationHandle,
280         srcOperation: TEE_OperationHandle,
281     ) -> c_void;
TEE_IsAlgorithmSupported( algId: u32, element: u32, ) -> TEE_Result282     pub fn TEE_IsAlgorithmSupported(
283         algId: u32,
284         element: u32,
285     ) -> TEE_Result;
286 
287     // Cryptographic Operations API - Message Digest Functions
288 
TEE_DigestUpdate( operation: TEE_OperationHandle, chunk: *const c_void, chunkSize: usize, ) -> c_void289     pub fn TEE_DigestUpdate(
290         operation: TEE_OperationHandle,
291         chunk: *const c_void,
292         chunkSize: usize,
293     ) -> c_void;
TEE_DigestDoFinal( operation: TEE_OperationHandle, chunk: *const c_void, chunkLen: usize, hash: *mut c_void, hashLen: *mut usize, ) -> TEE_Result294     pub fn TEE_DigestDoFinal(
295         operation: TEE_OperationHandle,
296         chunk: *const c_void,
297         chunkLen: usize,
298         hash: *mut c_void,
299         hashLen: *mut usize,
300     ) -> TEE_Result;
301 
302     // Cryptographic Operations API - Symmetric Cipher Functions
303 
TEE_CipherInit( operation: TEE_OperationHandle, IV: *const c_void, IVLen: usize, ) -> c_void304     pub fn TEE_CipherInit(
305         operation: TEE_OperationHandle,
306         IV: *const c_void,
307         IVLen: usize,
308     ) -> c_void;
TEE_CipherUpdate( operation: TEE_OperationHandle, srcData: *const c_void, srcLen: usize, destData: *mut c_void, destLen: *mut usize, ) -> TEE_Result309     pub fn TEE_CipherUpdate(
310         operation: TEE_OperationHandle,
311         srcData: *const c_void,
312         srcLen: usize,
313         destData: *mut c_void,
314         destLen: *mut usize,
315     ) -> TEE_Result;
TEE_CipherDoFinal( operation: TEE_OperationHandle, srcData: *const c_void, srcLen: usize, destData: *mut c_void, destLen: *mut usize, ) -> TEE_Result316     pub fn TEE_CipherDoFinal(
317         operation: TEE_OperationHandle,
318         srcData: *const c_void,
319         srcLen: usize,
320         destData: *mut c_void,
321         destLen: *mut usize,
322     ) -> TEE_Result;
323 
324     // Cryptographic Operations API - MAC Functions
325 
TEE_MACInit( operation: TEE_OperationHandle, IV: *const c_void, IVLen: usize, ) -> c_void326     pub fn TEE_MACInit(
327         operation: TEE_OperationHandle,
328         IV: *const c_void,
329         IVLen: usize,
330     ) -> c_void;
TEE_MACUpdate( operation: TEE_OperationHandle, chunk: *const c_void, chunkSize: usize, ) -> c_void331     pub fn TEE_MACUpdate(
332         operation: TEE_OperationHandle,
333         chunk: *const c_void,
334         chunkSize: usize,
335     ) -> c_void;
TEE_MACComputeFinal( operation: TEE_OperationHandle, message: *const c_void, messageLen: usize, mac: *mut c_void, macLen: *mut usize, ) -> TEE_Result336     pub fn TEE_MACComputeFinal(
337         operation: TEE_OperationHandle,
338         message: *const c_void,
339         messageLen: usize,
340         mac: *mut c_void,
341         macLen: *mut usize,
342     ) -> TEE_Result;
TEE_MACCompareFinal( operation: TEE_OperationHandle, message: *const c_void, messageLen: usize, mac: *const c_void, macLen: usize, ) -> TEE_Result343     pub fn TEE_MACCompareFinal(
344         operation: TEE_OperationHandle,
345         message: *const c_void,
346         messageLen: usize,
347         mac: *const c_void,
348         macLen: usize,
349     ) -> TEE_Result;
350 
351     // Cryptographic Operations API - Authenticated Encryption Functions
352 
TEE_AEInit( operation: TEE_OperationHandle, nonce: *const c_void, nonceLen: usize, tagLen: u32, AADLen: usize, payloadLen: usize, ) -> TEE_Result353     pub fn TEE_AEInit(
354         operation: TEE_OperationHandle,
355         nonce: *const c_void,
356         nonceLen: usize,
357         tagLen: u32,
358         AADLen: usize,
359         payloadLen: usize,
360     ) -> TEE_Result;
TEE_AEUpdateAAD( operation: TEE_OperationHandle, AADdata: *const c_void, AADdataLen: usize, ) -> c_void361     pub fn TEE_AEUpdateAAD(
362         operation: TEE_OperationHandle,
363         AADdata: *const c_void,
364         AADdataLen: usize,
365     ) -> c_void;
TEE_AEUpdate( operation: TEE_OperationHandle, srcData: *const c_void, srcLen: usize, destData: *mut c_void, destLen: *mut usize, ) -> TEE_Result366     pub fn TEE_AEUpdate(
367         operation: TEE_OperationHandle,
368         srcData: *const c_void,
369         srcLen: usize,
370         destData: *mut c_void,
371         destLen: *mut usize,
372     ) -> TEE_Result;
TEE_AEEncryptFinal( operation: TEE_OperationHandle, srcData: *const c_void, srcLen: usize, destData: *mut c_void, destLen: *mut usize, tag: *mut c_void, tagLen: *mut usize, ) -> TEE_Result373     pub fn TEE_AEEncryptFinal(
374         operation: TEE_OperationHandle,
375         srcData: *const c_void,
376         srcLen: usize,
377         destData: *mut c_void,
378         destLen: *mut usize,
379         tag: *mut c_void,
380         tagLen: *mut usize,
381     ) -> TEE_Result;
TEE_AEDecryptFinal( operation: TEE_OperationHandle, srcData: *const c_void, srcLen: usize, destData: *mut c_void, destLen: *mut usize, tag: *mut c_void, tagLen: usize, ) -> TEE_Result382     pub fn TEE_AEDecryptFinal(
383         operation: TEE_OperationHandle,
384         srcData: *const c_void,
385         srcLen: usize,
386         destData: *mut c_void,
387         destLen: *mut usize,
388         tag: *mut c_void,
389         tagLen: usize,
390     ) -> TEE_Result;
391 
392     // Cryptographic Operations API - Asymmetric Functions
393 
TEE_AsymmetricEncrypt( operation: TEE_OperationHandle, params: *const TEE_Attribute, paramCount: u32, srcData: *const c_void, srcLen: usize, destData: *mut c_void, destLen: *mut usize, ) -> TEE_Result394     pub fn TEE_AsymmetricEncrypt(
395         operation: TEE_OperationHandle,
396         params: *const TEE_Attribute,
397         paramCount: u32,
398         srcData: *const c_void,
399         srcLen: usize,
400         destData: *mut c_void,
401         destLen: *mut usize,
402     ) -> TEE_Result;
TEE_AsymmetricDecrypt( operation: TEE_OperationHandle, params: *const TEE_Attribute, paramCount: u32, srcData: *const c_void, srcLen: usize, destData: *mut c_void, destLen: *mut usize, ) -> TEE_Result403     pub fn TEE_AsymmetricDecrypt(
404         operation: TEE_OperationHandle,
405         params: *const TEE_Attribute,
406         paramCount: u32,
407         srcData: *const c_void,
408         srcLen: usize,
409         destData: *mut c_void,
410         destLen: *mut usize,
411     ) -> TEE_Result;
TEE_AsymmetricSignDigest( operation: TEE_OperationHandle, params: *const TEE_Attribute, paramCount: u32, digest: *const c_void, digestLen: usize, signature: *mut c_void, signatureLen: *mut usize, ) -> TEE_Result412     pub fn TEE_AsymmetricSignDigest(
413         operation: TEE_OperationHandle,
414         params: *const TEE_Attribute,
415         paramCount: u32,
416         digest: *const c_void,
417         digestLen: usize,
418         signature: *mut c_void,
419         signatureLen: *mut usize,
420     ) -> TEE_Result;
TEE_AsymmetricVerifyDigest( operation: TEE_OperationHandle, params: *const TEE_Attribute, paramCount: u32, digest: *const c_void, digestLen: usize, signature: *const c_void, signatureLen: usize, ) -> TEE_Result421     pub fn TEE_AsymmetricVerifyDigest(
422         operation: TEE_OperationHandle,
423         params: *const TEE_Attribute,
424         paramCount: u32,
425         digest: *const c_void,
426         digestLen: usize,
427         signature: *const c_void,
428         signatureLen: usize,
429     ) -> TEE_Result;
430 
431     // Cryptographic Operations API - Key Derivation Functions
432 
TEE_DeriveKey( operation: TEE_OperationHandle, params: *const TEE_Attribute, paramCount: u32, derivedKey: TEE_ObjectHandle, ) -> c_void433     pub fn TEE_DeriveKey(
434         operation: TEE_OperationHandle,
435         params: *const TEE_Attribute,
436         paramCount: u32,
437         derivedKey: TEE_ObjectHandle,
438     ) -> c_void;
439 
440     // Cryptographic Operations API - Random Number Generation Functions
441 
TEE_GenerateRandom(randomBuffer: *mut c_void, randomBufferLen: usize) -> c_void442     pub fn TEE_GenerateRandom(randomBuffer: *mut c_void, randomBufferLen: usize) -> c_void;
443 
444     // Date & Time API
445 
TEE_GetSystemTime(time: *mut TEE_Time) -> c_void446     pub fn TEE_GetSystemTime(time: *mut TEE_Time) -> c_void;
TEE_Wait(timeout: u32) -> TEE_Result447     pub fn TEE_Wait(timeout: u32) -> TEE_Result;
TEE_GetTAPersistentTime(time: *mut TEE_Time) -> TEE_Result448     pub fn TEE_GetTAPersistentTime(time: *mut TEE_Time) -> TEE_Result;
TEE_SetTAPersistentTime(time: *const TEE_Time) -> TEE_Result449     pub fn TEE_SetTAPersistentTime(time: *const TEE_Time) -> TEE_Result;
TEE_GetREETime(time: *mut TEE_Time) -> c_void450     pub fn TEE_GetREETime(time: *mut TEE_Time) -> c_void;
451 
452     // TEE Arithmetical API - Memory allocation and size of objects
453 
TEE_BigIntFMMSizeInU32(modulusSizeInBits: usize) -> usize454     pub fn TEE_BigIntFMMSizeInU32(modulusSizeInBits: usize) -> usize;
TEE_BigIntFMMContextSizeInU32(modulusSizeInBits: usize) -> usize455     pub fn TEE_BigIntFMMContextSizeInU32(modulusSizeInBits: usize) -> usize;
456 
457     // TEE Arithmetical API - Initialization functions
458 
TEE_BigIntInit(bigInt: *mut TEE_BigInt, len: usize) -> c_void459     pub fn TEE_BigIntInit(bigInt: *mut TEE_BigInt, len: usize) -> c_void;
TEE_BigIntInitFMMContext( context: *mut TEE_BigIntFMMContext, len: usize, modulus: *const TEE_BigInt, ) -> c_void460     pub fn TEE_BigIntInitFMMContext(
461         context: *mut TEE_BigIntFMMContext,
462         len: usize,
463         modulus: *const TEE_BigInt,
464     ) -> c_void;
TEE_BigIntInitFMM(bigIntFMM: *mut TEE_BigIntFMM, len: usize) -> c_void465     pub fn TEE_BigIntInitFMM(bigIntFMM: *mut TEE_BigIntFMM, len: usize) -> c_void;
466 
467     // TEE Arithmetical API - Converter functions
468 
TEE_BigIntConvertFromOctetString( dest: *mut TEE_BigInt, buffer: *const u8, bufferLen: usize, sign: i32, ) -> TEE_Result469     pub fn TEE_BigIntConvertFromOctetString(
470         dest: *mut TEE_BigInt,
471         buffer: *const u8,
472         bufferLen: usize,
473         sign: i32,
474     ) -> TEE_Result;
TEE_BigIntConvertToOctetString( buffer: *mut u8, bufferLen: *mut usize, bigInt: *const TEE_BigInt, ) -> TEE_Result475     pub fn TEE_BigIntConvertToOctetString(
476         buffer: *mut u8,
477         bufferLen: *mut usize,
478         bigInt: *const TEE_BigInt,
479     ) -> TEE_Result;
TEE_BigIntConvertFromS32(dest: *mut TEE_BigInt, shortVal: i32) -> c_void480     pub fn TEE_BigIntConvertFromS32(dest: *mut TEE_BigInt, shortVal: i32) -> c_void;
TEE_BigIntConvertToS32(dest: *mut i32, src: *const TEE_BigInt) -> TEE_Result481     pub fn TEE_BigIntConvertToS32(dest: *mut i32, src: *const TEE_BigInt) -> TEE_Result;
482 
483     // TEE Arithmetical API - Logical operations
484 
TEE_BigIntCmp(op1: *const TEE_BigInt, op2: *const TEE_BigInt) -> i32485     pub fn TEE_BigIntCmp(op1: *const TEE_BigInt, op2: *const TEE_BigInt) -> i32;
TEE_BigIntCmpS32(op: *const TEE_BigInt, shortVal: i32) -> i32486     pub fn TEE_BigIntCmpS32(op: *const TEE_BigInt, shortVal: i32) -> i32;
TEE_BigIntShiftRight( dest: *mut TEE_BigInt, op: *const TEE_BigInt, bits: c_size_t, ) -> c_void487     pub fn TEE_BigIntShiftRight(
488         dest: *mut TEE_BigInt,
489         op: *const TEE_BigInt,
490         bits: c_size_t,
491     ) -> c_void;
TEE_BigIntGetBit(src: *const TEE_BigInt, bitIndex: u32) -> bool492     pub fn TEE_BigIntGetBit(src: *const TEE_BigInt, bitIndex: u32) -> bool;
TEE_BigIntGetBitCount(src: *const TEE_BigInt) -> u32493     pub fn TEE_BigIntGetBitCount(src: *const TEE_BigInt) -> u32;
TEE_BigIntSetBit(src: *const TEE_BigInt, bitIndex: u32, value: bool) -> TEE_Result494     pub fn TEE_BigIntSetBit(src: *const TEE_BigInt, bitIndex: u32, value: bool) -> TEE_Result;
TEE_BigIntAssign(dest: *mut TEE_BigInt, src: *const TEE_BigInt) -> TEE_Result495     pub fn TEE_BigIntAssign(dest: *mut TEE_BigInt, src: *const TEE_BigInt) -> TEE_Result;
TEE_BigIntAbs(dest: *mut TEE_BigInt, src: *const TEE_BigInt) -> TEE_Result496     pub fn TEE_BigIntAbs(dest: *mut TEE_BigInt, src: *const TEE_BigInt) -> TEE_Result;
TEE_BigIntAdd( dest: *mut TEE_BigInt, op1: *const TEE_BigInt, op2: *const TEE_BigInt, ) -> c_void497     pub fn TEE_BigIntAdd(
498         dest: *mut TEE_BigInt,
499         op1: *const TEE_BigInt,
500         op2: *const TEE_BigInt,
501     ) -> c_void;
TEE_BigIntSub( dest: *mut TEE_BigInt, op1: *const TEE_BigInt, op2: *const TEE_BigInt, ) -> c_void502     pub fn TEE_BigIntSub(
503         dest: *mut TEE_BigInt,
504         op1: *const TEE_BigInt,
505         op2: *const TEE_BigInt,
506     ) -> c_void;
TEE_BigIntNeg(dest: *mut TEE_BigInt, op: *const TEE_BigInt) -> c_void507     pub fn TEE_BigIntNeg(dest: *mut TEE_BigInt, op: *const TEE_BigInt) -> c_void;
TEE_BigIntMul( dest: *mut TEE_BigInt, op1: *const TEE_BigInt, op2: *const TEE_BigInt, ) -> c_void508     pub fn TEE_BigIntMul(
509         dest: *mut TEE_BigInt,
510         op1: *const TEE_BigInt,
511         op2: *const TEE_BigInt,
512     ) -> c_void;
TEE_BigIntSquare(dest: *mut TEE_BigInt, op: *const TEE_BigInt) -> c_void513     pub fn TEE_BigIntSquare(dest: *mut TEE_BigInt, op: *const TEE_BigInt) -> c_void;
TEE_BigIntDiv( dest_q: *mut TEE_BigInt, dest_r: *mut TEE_BigInt, op1: *const TEE_BigInt, op2: *const TEE_BigInt, ) -> c_void514     pub fn TEE_BigIntDiv(
515         dest_q: *mut TEE_BigInt,
516         dest_r: *mut TEE_BigInt,
517         op1: *const TEE_BigInt,
518         op2: *const TEE_BigInt,
519     ) -> c_void;
520 
521     // TEE Arithmetical API - Modular arithmetic operations
522 
TEE_BigIntMod( dest: *mut TEE_BigInt, op: *const TEE_BigInt, n: *const TEE_BigInt, ) -> c_void523     pub fn TEE_BigIntMod(
524         dest: *mut TEE_BigInt,
525         op: *const TEE_BigInt,
526         n: *const TEE_BigInt,
527     ) -> c_void;
TEE_BigIntAddMod( dest: *mut TEE_BigInt, op1: *const TEE_BigInt, op2: *const TEE_BigInt, n: *const TEE_BigInt, ) -> c_void528     pub fn TEE_BigIntAddMod(
529         dest: *mut TEE_BigInt,
530         op1: *const TEE_BigInt,
531         op2: *const TEE_BigInt,
532         n: *const TEE_BigInt,
533     ) -> c_void;
TEE_BigIntSubMod( dest: *mut TEE_BigInt, op1: *const TEE_BigInt, op2: *const TEE_BigInt, n: *const TEE_BigInt, ) -> c_void534     pub fn TEE_BigIntSubMod(
535         dest: *mut TEE_BigInt,
536         op1: *const TEE_BigInt,
537         op2: *const TEE_BigInt,
538         n: *const TEE_BigInt,
539     ) -> c_void;
TEE_BigIntMulMod( dest: *mut TEE_BigInt, op1: *const TEE_BigInt, op2: *const TEE_BigInt, n: *const TEE_BigInt, ) -> c_void540     pub fn TEE_BigIntMulMod(
541         dest: *mut TEE_BigInt,
542         op1: *const TEE_BigInt,
543         op2: *const TEE_BigInt,
544         n: *const TEE_BigInt,
545     ) -> c_void;
TEE_BigIntSquareMod( dest: *mut TEE_BigInt, op: *const TEE_BigInt, n: *const TEE_BigInt, ) -> c_void546     pub fn TEE_BigIntSquareMod(
547         dest: *mut TEE_BigInt,
548         op: *const TEE_BigInt,
549         n: *const TEE_BigInt,
550     ) -> c_void;
TEE_BigIntInvMod( dest: *mut TEE_BigInt, op: *const TEE_BigInt, n: *const TEE_BigInt, ) -> c_void551     pub fn TEE_BigIntInvMod(
552         dest: *mut TEE_BigInt,
553         op: *const TEE_BigInt,
554         n: *const TEE_BigInt,
555     ) -> c_void;
TEE_BigIntExpMod( dest: *mut TEE_BigInt, op1: *const TEE_BigInt, op2: *const TEE_BigInt, n: *const TEE_BigInt, context: *const TEE_BigIntFMMContext, ) -> TEE_Result556     pub fn TEE_BigIntExpMod(
557         dest: *mut TEE_BigInt,
558         op1: *const TEE_BigInt,
559         op2: *const TEE_BigInt,
560         n: *const TEE_BigInt,
561         context: *const TEE_BigIntFMMContext,
562     ) -> TEE_Result;
563 
564     // TEE Arithmetical API - Other arithmetic operations
565 
TEE_BigIntRelativePrime(op1: *const TEE_BigInt, op2: *const TEE_BigInt) -> bool566     pub fn TEE_BigIntRelativePrime(op1: *const TEE_BigInt, op2: *const TEE_BigInt) -> bool;
TEE_BigIntComputeExtendedGcd( gcd: *mut TEE_BigInt, u: *mut TEE_BigInt, v: *mut TEE_BigInt, op1: *const TEE_BigInt, op2: *const TEE_BigInt, ) -> c_void567     pub fn TEE_BigIntComputeExtendedGcd(
568         gcd: *mut TEE_BigInt,
569         u: *mut TEE_BigInt,
570         v: *mut TEE_BigInt,
571         op1: *const TEE_BigInt,
572         op2: *const TEE_BigInt,
573     ) -> c_void;
TEE_BigIntIsProbablePrime(op: *const TEE_BigInt, confidenceLevel: u32) -> i32574     pub fn TEE_BigIntIsProbablePrime(op: *const TEE_BigInt, confidenceLevel: u32) -> i32;
575 
576     // TEE Arithmetical API - Fast modular multiplication operations
577 
TEE_BigIntConvertToFMM( dest: *mut TEE_BigIntFMM, src: *const TEE_BigInt, n: *const TEE_BigInt, context: *const TEE_BigIntFMMContext, ) -> c_void578     pub fn TEE_BigIntConvertToFMM(
579         dest: *mut TEE_BigIntFMM,
580         src: *const TEE_BigInt,
581         n: *const TEE_BigInt,
582         context: *const TEE_BigIntFMMContext,
583     ) -> c_void;
TEE_BigIntConvertFromFMM( dest: *mut TEE_BigInt, src: *const TEE_BigIntFMM, n: *const TEE_BigInt, context: *const TEE_BigIntFMMContext, ) -> c_void584     pub fn TEE_BigIntConvertFromFMM(
585         dest: *mut TEE_BigInt,
586         src: *const TEE_BigIntFMM,
587         n: *const TEE_BigInt,
588         context: *const TEE_BigIntFMMContext,
589     ) -> c_void;
TEE_BigIntFMMConvertToBigInt( dest: *mut TEE_BigInt, src: *const TEE_BigIntFMM, n: *const TEE_BigInt, context: *const TEE_BigIntFMMContext, ) -> c_void590     pub fn TEE_BigIntFMMConvertToBigInt(
591         dest: *mut TEE_BigInt,
592         src: *const TEE_BigIntFMM,
593         n: *const TEE_BigInt,
594         context: *const TEE_BigIntFMMContext,
595     ) -> c_void;
TEE_BigIntComputeFMM( dest: *mut TEE_BigIntFMM, op1: *const TEE_BigIntFMM, op2: *const TEE_BigIntFMM, n: *const TEE_BigInt, context: *const TEE_BigIntFMMContext, ) -> c_void596     pub fn TEE_BigIntComputeFMM(
597         dest: *mut TEE_BigIntFMM,
598         op1: *const TEE_BigIntFMM,
599         op2: *const TEE_BigIntFMM,
600         n: *const TEE_BigInt,
601         context: *const TEE_BigIntFMMContext,
602     ) -> c_void;
603 }
604