1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * Copyright (c) 2014, STMicroelectronics International N.V.
4 * Copyright (c) 2020, Linaro Limited
5 */
6
7 #ifndef XML_INTERNAL_API_H_
8 #define XML_INTERNAL_API_H_
9
10 #include <arpa/inet.h>
11 #include <assert.h>
12 #include <pthread.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <sys/types.h>
17 #include <tee_api_defines.h>
18 #include <tee_client_api.h>
19 #include <unistd.h>
20
21 #include "xml_common_api.h"
22 #include "xtest_helpers.h"
23 #include "xtest_test.h"
24
25 #define Invoke_MaskUnmaskCancellations Invoke_Simple_Function
26 #define Invoke_ProcessTAInvoke_Payload_Value Invoke_Simple_Function
27 #define Invoke_ProcessTAInvoke_Payload_Value_In_Out Invoke_Simple_Function
28 #define Invoke_ProcessTAInvoke_Payload_Memref Invoke_Simple_Function
29
30 #define Invoke_GetPropertyAsBool_withoutEnum Invoke_GetPropertyAsXXX_withoutEnum
31 #define Invoke_GetPropertyAsU32_withoutEnum Invoke_GetPropertyAsXXX_withoutEnum
32 #define Invoke_GetPropertyAsUUID_withoutEnum Invoke_GetPropertyAsXXX_withoutEnum
33 #define Invoke_GetPropertyAsIdentity_withoutEnum \
34 Invoke_GetPropertyAsXXX_withoutEnum
35 #define Invoke_GetPropertyAsBinaryBlock_withoutEnum \
36 Invoke_GetPropertyAsXXX_withoutEnum
37 #define Invoke_GetPropertyAsString_withoutEnum \
38 Invoke_GetPropertyAsXXX_withoutEnum
39
40 #define Invoke_GetPropertyAsXXXX_fromEnum Invoke_StartPropertyEnumerator
41
42 #define Invoke_FreePropertyEnumerator Invoke_ResetPropertyEnumerator
43 #define Invoke_GetNextProperty_enumNotStarted Invoke_ResetPropertyEnumerator
44
45 #define Invoke_ProcessTAInvoke_DeadErrorSuccess \
46 Invoke_ProcessInvokeTAOpenSession
47
48 #define CLIENT_APP01 NULL
49
50 #define TEEC_UNDEFINED_ERROR 0xDEADDEAD
51
52 #define TEEC_ORIGIN_ANY_NOT_TRUSTED_APP 0x00000005
53 /* same as TEE_ORIGIN_NOT_TRUSTED_APP */
54
55 #define SIZE_ZERO 0
56
57 #define TEE_ERROR_TOO_SHORT_BUFFER TEE_ERROR_SHORT_BUFFER
58
59 #define CMD_TEE_GetPropertyAsString_withoutEnum 0x00000010
60 #define CMD_TEE_GetPropertyAsBool_withoutEnum 0x00000015
61 #define CMD_TEE_GetPropertyAsInt_withoutEnum 0x00000020
62 #define CMD_TEE_GetPropertyAsBinaryBlock_withoutEnum 0x00000025
63 #define CMD_TEE_GetPropertyAsUUID_withoutEnum 0x00000030
64 #define CMD_TEE_GetPropertyAsIdentity_withoutEnum 0x00000035
65 #define CMD_TEE_GetPropertyAsXXXX_fromEnum 0x00000045
66 #define CMD_TEE_AllocatePropertyEnumerator 0x00000060
67 #define CMD_TEE_StartPropertyEnumerator 0x00000065
68 #define CMD_TEE_ResetPropertyEnumerator 0x00000070
69 #define CMD_TEE_FreePropertyEnumerator 0x00000075
70 #define CMD_TEE_GetPropertyName 0x00000080
71 #define CMD_TEE_Malloc 0x00000100
72 #define CMD_TEE_Realloc 0x00000110
73 #define CMD_TEE_MemMove 0x00000120
74 #define CMD_TEE_MemCompare 0x00000130
75 #define CMD_TEE_MemFill 0x00000140
76 #define CMD_TEE_Panic 0x00000104
77 #define CMD_TEE_CheckMemoryAccessRight 0x00000103
78 #define CMD_TEE_GetCancellationFlag_RequestedCancel 0x00000105
79 #define CMD_TEE_MaskUnmaskCancellations 0x00000106
80 #define CMD_TEE_Free 0x00000107
81 #define CMD_ProcessInvokeTAOpenSession 0x00000200
82 #define CMD_ProcessTAInvokeTA_simple 0x00000201
83 #define CMD_ProcessTAInvokeTA_PayloadValue 0x00000202
84 #define CMD_TEE_GetNextPropertyEnumerator_notStarted 0x00000203
85 #define CMD_ProcessTAInvokeTA_PayloadMemref 0x00000204
86 #define CMD_ProcessTAInvokeTA_PayloadValue_In_Out 0x00000205
87 #define CMD_TEE_OpenTASession 0x00000300
88 #define CMD_TEE_InvokeTACommand 0x00000301
89 #define CMD_TEE_CloseTASession 0x00000302
90
91 #define CMD_SUCCESS 1
92 #define CMD_SET_PANIC_ON_DESTROY 1
93
94 static TEEC_SharedMemory share_mem[2];
95 static TEEC_SharedMemory *SHARE_MEM01 = share_mem;
96 static TEEC_SharedMemory *SHARE_MEM02 = share_mem + 1;
97 static TEEC_Session session[2];
98 static TEEC_Session *SESSION01 = session;
99 static TEEC_Session *SESSION02 = session + 1;
100 static TEEC_Context context[2];
101 static TEEC_Context *CONTEXT01 = context;
102 static TEEC_Context *CONTEXT02 = context + 1;
103
104 #define TA_SESSION01 0
105 #define TA_SESSION02 1
106 #define TA_SESSION_NULL 0xffffffff
107
108 static uint32_t BIG_SIZE = 1024;
109
110 static char *NO_DATA;
111 static uint32_t enumerator1;
112 static uint32_t *ENUMERATOR1 = &enumerator1;
113
114 #define ANY_OWNER_NOT_SET 0
115 #define ANY_OWNER_SET TEE_MEMORY_ACCESS_ANY_OWNER
116 #define ANY_OWNER_SET_ACCESS_READ (TEE_MEMORY_ACCESS_ANY_OWNER | \
117 TEE_MEMORY_ACCESS_READ)
118 #define ANY_OWNER_SET_ACCESS_WRITE (TEE_MEMORY_ACCESS_ANY_OWNER | \
119 TEE_MEMORY_ACCESS_WRITE)
120 #define ANY_OWNER_SET_ACCESS_READ_WRITE (TEE_MEMORY_ACCESS_ANY_OWNER | \
121 TEE_MEMORY_ACCESS_READ | \
122 TEE_MEMORY_ACCESS_WRITE)
123
124 #define SMALL_SIZE 0xA
125
126 #define CMD_TEE_GetInstanceData 0x00000101
127 #define CMD_TEE_SetInstanceData 0x00000102
128 #define CMD_TEE_GetPropertyAsU32_withoutEnum 0x00000020
129
130 #define NORMAL_SIZE_BUFFER 1
131 #define TOO_SHORT_BUFFER 0
132 #define CASE_NOT_NULL 1
133 #define CASE_NULL 0
134 #define CASE_BUFFER1_DIFFERS_FIRST 1
135 #define CASE_BUFFER2_DIFFERS_FIRST 2
136 #define CASE_EQUAL 0
137 #define CASE_ERROR_ICA2 3
138 #define CASE_PAYLOAD_VALUE 4
139 #define CASE_SUCCESS_ICA2 2
140 #define CASE_TARGET_DEAD_ICA2 1
141 #define CASE_CANCEL_TIMEOUT 2
142 #define CASE_ITEM_NOT_FOUND 3
143 #define CASE_SUCCESS 0
144 #define CASE_TARGET_BUSY 4
145 #define CASE_TARGET_DEAD 1
146 #define RESULT_EQUAL 0
147 #define RESULT_INTEGER_GREATER_THAN_ZERO 1
148 #define RESULT_INTEGER_LOWER_THAN_ZERO 2
149
150 #define HINT_ZERO 0
151 #define SIZE_OVER_MEMORY 0xFFFFFFFE
152
153 #define TEE_ORIGIN_NOT_TRUSTED_APP 5
154 /* same as TEEC_ORIGIN_ANY_NOT_TRUSTED_APP */
155 #define TEE_PROPSET_IMPLEMENTATION TEE_PROPSET_TEE_IMPLEMENTATION
156
157 static char VALUE_PREDEFINED_STRING[] = "this is a test string";
158 static char VALUE_PREDEFINED_U32[] = "48059";
159 static char VALUE_PREDEFINED_UUID[] = "534D4152-542D-4353-4C54-2D54412D3031";
160 static char VALUE_PREDEFINED_IDENTITY[] =
161 "F0000000:534D4152-542D-4353-4C54-2D54412D3031";
162
163 static char *VALUE_NONE;
164 static char VALUE_PREDEFINED_BINARY_BLOCK[] =
165 "VGhpcyBpcyBhIHRleHQgYmluYXJ5IGJsb2Nr";
166 static char VALUE_PREDEFINED_BOOLEAN[] = "true";
167
168 static uint8_t CHAR1[] = { 0x10 };
169
170 static char GPD_CLIENT_identity[] = "gpd.client.identity\0";
171 static char GPD_TA_appID[] = "gpd.ta.appID\0";
172 static char GPD_TA_dataSize[] = "gpd.ta.dataSize\0";
173 static char GPD_TA_instanceKeepAlive[] = "gpd.ta.instanceKeepAlive\0";
174 static char GPD_TA_multiSession[] = "gpd.ta.multiSession\0";
175 static char GPD_TA_singleInstance[] = "gpd.ta.singleInstance\0";
176 static char GPD_TA_stackSize[] = "gpd.ta.stackSize\0";
177 static char GPD_TEE_ARITH_maxBigIntSize[] = "gpd.tee.arith.maxBigIntSize\0";
178 static char GPD_TEE_SYSTEM_TIME_protectionLevel[] =
179 "gpd.tee.systemTime.protectionLevel\0";
180 static char GPD_TEE_TA_PERSISTENT_TIME_protectionLevel[] =
181 "gpd.tee.TAPersistentTime.protectionLevel\0";
182 static char GPD_TEE_apiversion[] = "gpd.tee.apiversion\0";
183 static char GPD_TEE_description[] = "gpd.tee.description\0";
184 static char GPD_TEE_deviceID[] = "gpd.tee.deviceID\0";
185 static char PROPERTY_NAME_NOT_VALID_ENCODING[] = "gpd.\t\n\r\0";
186 static char PROPERTY_NAME_UNKNOWN[] = "unknown\0";
187 static char SMC_TA_testuuid[] = "smc.ta.testuuid\0";
188 static char SMC_TA_testbinaryblock[] = "smc.ta.testbinaryblock\0";
189 static char SMC_TA_testbooltrue[] = "smc.ta.testbooltrue\0";
190 static char SMC_TA_testidentity[] = "smc.ta.testidentity\0";
191 static char SMC_TA_teststring[] = "smc.ta.teststring\0";
192 static char SMC_TA_testu32[] = "smc.ta.testu32\0";
193 static char STRING_SAMPLE_SIZE_4_CHAR[] = "TEE\0";
194
195
196 /** ALL_TEEC_UUID
197 *
198 * These constants are the UUID of existing
199 * Trusted Applications
200 */
201 static TEEC_UUID UUID_TTA_testingInternalAPI_TrustedCoreFramework = {
202 0x534D4152, 0x542D, 0x4353,
203 { 0x4C, 0x54, 0x2D, 0x54, 0x41, 0x2D, 0x30, 0x31 }
204 };
205 static TEEC_UUID UUID_TTA_testingInternalAPI_TrustedCoreFramework_ICA = {
206 0x534D4152, 0x5443, 0x534C,
207 { 0x54, 0x41, 0x54, 0x43, 0x46, 0x49, 0x43, 0x41 }
208 };
209 static TEEC_UUID UUID_TTA_testingInternalAPI_TrustedCoreFramework_ICA2 = {
210 0x534D4152, 0x5443, 0x534C,
211 { 0x54, 0x54, 0x43, 0x46, 0x49, 0x43, 0x41, 0x32 }
212 };
213 static TEEC_UUID
214 UUID_TTA_testingInternalAPI_TrustedCoreFramework_MultipleInstanceTA = {
215 0x534D4152, 0x5443, 0x534C,
216 { 0x4D, 0x4C, 0x54, 0x49, 0x4E, 0x53, 0x54, 0x43 }
217 };
218 static TEEC_UUID
219 UUID_TTA_testingInternalAPI_TrustedCoreFramework_SingleInstanceTA = {
220 0x534D4152, 0x5443, 0x534C,
221 { 0x53, 0x47, 0x4C, 0x49, 0x4E, 0x53, 0x54, 0x43 }
222 };
223 static TEEC_UUID UUID_Unknown = {
224 0x534D4152, 0x542D, 0x4355,
225 { 0x4E, 0x4B, 0x2D, 0x4E, 0x4F, 0x2D, 0x57, 0x4E }
226 };
227
228 static TEEC_UUID
229 UUID_TTA_testingInternalAPI_TrustedCoreFramework_PanicAtCloseSession = {
230 0x534D4152, 0x5443, 0x534C,
231 { 0x43, 0x4C, 0x4F, 0x50, 0x41, 0x4E, 0x49, 0x43 }
232 };
233
234 static TEEC_UUID
235 UUID_TTA_testingInternalAPI_TrustedCoreFramework_PanicAtCreation = {
236 0x534D4152, 0x5443, 0x534C,
237 { 0x54, 0x43, 0x52, 0x50, 0x41, 0x4E, 0x49, 0x43 }
238 };
239
cancellation_thread(void * arg)240 static void __maybe_unused *cancellation_thread(void *arg)
241 {
242 TEEC_RequestCancellation((TEEC_Operation *)arg);
243 return NULL;
244 }
245
246 #define RequestCancellation(op) \
247 (void)ADBG_EXPECT(c, 0, \
248 pthread_create(&THREAD02, NULL, cancellation_thread, \
249 (void *)op)); \
250 (void)ADBG_EXPECT(c, 0, pthread_join(THREAD02, NULL));
251
Invoke_MemFill(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,uint32_t memoryFillSize,uint8_t * charFill)252 static TEEC_Result Invoke_MemFill(ADBG_Case_t *c, TEEC_Session *sess,
253 uint32_t cmdId, uint32_t memoryFillSize,
254 uint8_t *charFill)
255 {
256 return Invoke_Simple_Function_v2(c, sess, cmdId, memoryFillSize, 0,
257 *charFill, 0);
258 }
259
Invoke_GetPropertyAsXXX_withoutEnum(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,TEE_PropSetHandle propSet,char * name,uint32_t kindBuffer,char * expectedValue)260 static TEEC_Result Invoke_GetPropertyAsXXX_withoutEnum(
261 ADBG_Case_t *c, TEEC_Session *sess, uint32_t cmdId,
262 TEE_PropSetHandle propSet, char *name, uint32_t kindBuffer,
263 char *expectedValue)
264 {
265 TEEC_Result res = TEE_ERROR_NOT_SUPPORTED;
266 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
267 uint32_t org;
268 uint32_t nameLen = 0;
269 uint32_t expectedValueLen = 0;
270
271 nameLen = strlen(name) + 1;
272 ALLOCATE_AND_FILL_SHARED_MEMORY(sess->ctx, SHARE_MEM01, BIG_SIZE,
273 TEEC_MEM_INPUT, nameLen, name, mem01_exit)
274
275 if (kindBuffer == TOO_SHORT_BUFFER) {
276 ALLOCATE_SHARED_MEMORY(sess->ctx, SHARE_MEM02, 1,
277 TEEC_MEM_OUTPUT, mem02_exit)
278 } else {
279 ALLOCATE_SHARED_MEMORY(sess->ctx, SHARE_MEM02, BIG_SIZE,
280 TEEC_MEM_OUTPUT, mem02_exit)
281 }
282
283 op.params[0].value.a = (unsigned long)propSet;
284 SET_SHARED_MEMORY_OPERATION_PARAMETER(1, 0, SHARE_MEM01, nameLen)
285 SET_SHARED_MEMORY_OPERATION_PARAMETER(2, 0, SHARE_MEM02,
286 SHARE_MEM02->size)
287
288 op.paramTypes = TEEC_PARAM_TYPES(
289 TEEC_VALUE_INPUT, TEEC_MEMREF_PARTIAL_INPUT,
290 TEEC_MEMREF_PARTIAL_OUTPUT, TEEC_NONE);
291
292 res = TEEC_InvokeCommand(sess, cmdId, &op, &org);
293
294 if (res)
295 goto exit;
296
297 if (expectedValue != VALUE_NONE) {
298 expectedValueLen = strlen(expectedValue);
299 if (cmdId != CMD_TEE_GetPropertyAsBool_withoutEnum &&
300 cmdId != CMD_TEE_GetPropertyAsIdentity_withoutEnum &&
301 cmdId != CMD_TEE_GetPropertyAsUUID_withoutEnum &&
302 cmdId != CMD_TEE_GetPropertyAsU32_withoutEnum)
303 expectedValueLen++;
304 if (!ADBG_EXPECT_BUFFER(c, expectedValue, expectedValueLen,
305 op.params[2].memref.parent->buffer,
306 op.params[2].memref.size))
307 res = TEEC_ERROR_GENERIC;
308 }
309
310 exit:
311 TEEC_ReleaseSharedMemory(SHARE_MEM02);
312 mem02_exit:
313 TEEC_ReleaseSharedMemory(SHARE_MEM01);
314 mem01_exit:
315 return res;
316 }
317
Invoke_MemCompare(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,uint32_t memorySize,uint32_t Case,uint32_t compareResult)318 static TEEC_Result Invoke_MemCompare(
319 ADBG_Case_t *c, TEEC_Session *sess, uint32_t cmdId,
320 uint32_t memorySize, uint32_t Case, uint32_t compareResult)
321 {
322 TEEC_Result res = TEE_ERROR_NOT_SUPPORTED;
323 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
324 uint32_t org;
325 uint32_t outValue = 0;
326
327 op.params[0].value.a = memorySize;
328 op.params[1].value.a = Case;
329 op.params[2].value.a = outValue;
330
331 op.paramTypes = TEEC_PARAM_TYPES(
332 TEEC_VALUE_INPUT, TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT,
333 TEEC_NONE);
334
335 res = TEEC_InvokeCommand(sess, cmdId, &op, &org);
336
337 if (res != TEEC_SUCCESS)
338 goto exit;
339
340 if (compareResult == RESULT_EQUAL) {
341 (void)ADBG_EXPECT_COMPARE_SIGNED(c, op.params[2].value.a, ==,
342 0);
343 } else if (compareResult == RESULT_INTEGER_GREATER_THAN_ZERO) {
344 (void)ADBG_EXPECT_COMPARE_SIGNED(c,
345 (int32_t)op.params[2].value.a,
346 >, 0);
347 } else if (compareResult == RESULT_INTEGER_LOWER_THAN_ZERO) {
348 (void)ADBG_EXPECT_COMPARE_SIGNED(c,
349 (int32_t)op.params[2].value.a,
350 <, 0);
351 }
352
353 exit:
354 return res;
355 }
356
Invoke_SetInstanceData(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,char * data)357 static TEEC_Result Invoke_SetInstanceData(ADBG_Case_t *c,
358 TEEC_Session *sess, uint32_t cmdId,
359 char *data)
360 {
361 TEEC_Result res = TEE_ERROR_NOT_SUPPORTED;
362 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
363 size_t data_size = strlen(data) + 1;
364 uint32_t org;
365
366 ALLOCATE_AND_FILL_SHARED_MEMORY(sess->ctx, SHARE_MEM01, BIG_SIZE,
367 TEEC_MEM_INPUT,
368 data_size, data, mem01_exit)
369
370 SET_SHARED_MEMORY_OPERATION_PARAMETER(0, 0, SHARE_MEM01, data_size)
371
372 op.paramTypes = TEEC_PARAM_TYPES(
373 TEEC_MEMREF_PARTIAL_INPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
374
375 res = TEEC_InvokeCommand(sess, cmdId, &op, &org);
376
377 TEEC_ReleaseSharedMemory(SHARE_MEM01);
378 mem01_exit:
379 return res;
380 }
381
Invoke_GetInstanceData(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,char * expectedData,uint32_t expectedDataSize)382 static TEEC_Result Invoke_GetInstanceData(
383 ADBG_Case_t *c, TEEC_Session *sess, uint32_t cmdId, char *expectedData,
384 uint32_t expectedDataSize)
385 {
386 TEEC_Result res = TEE_ERROR_NOT_SUPPORTED;
387 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
388 uint32_t org;
389
390 ALLOCATE_SHARED_MEMORY(sess->ctx, SHARE_MEM01, BIG_SIZE,
391 TEEC_MEM_OUTPUT, mem01_exit)
392
393 SET_SHARED_MEMORY_OPERATION_PARAMETER(0, 0, SHARE_MEM01,
394 SHARE_MEM01->size)
395
396 op.paramTypes = TEEC_PARAM_TYPES(
397 TEEC_MEMREF_PARTIAL_OUTPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
398
399 res = TEEC_InvokeCommand(sess, cmdId, &op, &org);
400
401 if (res != TEEC_SUCCESS)
402 goto exit;
403
404 if (res != TEE_ERROR_GENERIC) {
405 if (!ADBG_EXPECT_BUFFER(c, expectedData, expectedDataSize,
406 SHARE_MEM01->buffer,
407 op.params[0].memref.size))
408 res = TEE_ERROR_GENERIC;
409 }
410
411 exit:
412 TEEC_ReleaseSharedMemory(SHARE_MEM01);
413 mem01_exit:
414 return res;
415 }
416
Invoke_ProcessInvokeTAOpenSession(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,uint32_t TACmd,TEEC_UUID * UUID,uint32_t returnOrigin)417 static TEEC_Result Invoke_ProcessInvokeTAOpenSession(
418 ADBG_Case_t *c, TEEC_Session *sess, uint32_t cmdId,
419 uint32_t TACmd, TEEC_UUID *UUID, uint32_t returnOrigin)
420 {
421 TEEC_Result res = TEE_ERROR_NOT_SUPPORTED;
422 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
423 TEEC_UUID swapped_uuid = *UUID;
424 uint32_t org;
425
426 swapped_uuid.timeLow = htonl(swapped_uuid.timeLow);
427 swapped_uuid.timeMid = htons(swapped_uuid.timeMid);
428 swapped_uuid.timeHiAndVersion = htons(swapped_uuid.timeHiAndVersion);
429
430 ALLOCATE_AND_FILL_SHARED_MEMORY(sess->ctx, SHARE_MEM01, BIG_SIZE,
431 TEEC_MEM_INPUT, 16, &swapped_uuid,
432 mem01_exit)
433
434 op.params[0].value.a = TACmd;
435 SET_SHARED_MEMORY_OPERATION_PARAMETER(1, 0, SHARE_MEM01, 16)
436 op.params[2].value.a = returnOrigin;
437
438 op.paramTypes = TEEC_PARAM_TYPES(
439 TEEC_VALUE_INPUT, TEEC_MEMREF_PARTIAL_INPUT, TEEC_VALUE_OUTPUT,
440 TEEC_NONE);
441
442 res = TEEC_InvokeCommand(sess, cmdId, &op, &org);
443
444 if (TEE_ORIGIN_NOT_TRUSTED_APP == returnOrigin) {
445 ADBG_EXPECT_COMPARE_UNSIGNED(c, op.params[2].value.a, !=,
446 TEE_ORIGIN_TRUSTED_APP);
447 } else {
448 ADBG_EXPECT_COMPARE_UNSIGNED(c, op.params[2].value.a, ==,
449 returnOrigin);
450 }
451
452 TEEC_ReleaseSharedMemory(SHARE_MEM01);
453 mem01_exit:
454 return res;
455 }
456
Invoke_CheckMemoryAccessRight(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,uint32_t memoryParamType,uint32_t memoryAccessFlags)457 static TEEC_Result Invoke_CheckMemoryAccessRight(ADBG_Case_t *c,
458 TEEC_Session *sess,
459 uint32_t cmdId,
460 uint32_t memoryParamType,
461 uint32_t memoryAccessFlags)
462 {
463 TEEC_Result res = TEE_ERROR_NOT_SUPPORTED;
464 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
465 uint32_t org;
466 uint32_t memory_flag;
467
468 switch (memoryParamType) {
469 case TEEC_MEMREF_TEMP_INPUT:
470 case TEEC_MEMREF_PARTIAL_INPUT:
471 memory_flag = TEEC_MEM_INPUT;
472 break;
473 case TEEC_MEMREF_TEMP_OUTPUT:
474 case TEEC_MEMREF_PARTIAL_OUTPUT:
475 memory_flag = TEEC_MEM_OUTPUT;
476 break;
477 case TEEC_MEMREF_TEMP_INOUT:
478 case TEEC_MEMREF_PARTIAL_INOUT:
479 case TEEC_MEMREF_WHOLE:
480 memory_flag = TEEC_MEM_INPUT | TEEC_MEM_OUTPUT;
481 break;
482 default:
483 memory_flag = 0;
484 break;
485 }
486
487 ALLOCATE_SHARED_MEMORY(sess->ctx, SHARE_MEM01, BIG_SIZE,
488 memory_flag, mem01_exit)
489
490 op.params[0].value.a = memoryAccessFlags;
491 SET_SHARED_MEMORY_OPERATION_PARAMETER(1, 0, SHARE_MEM01,
492 SHARE_MEM01->size)
493
494 op.paramTypes = TEEC_PARAM_TYPES(
495 TEEC_VALUE_INPUT, memoryParamType, TEEC_NONE, TEEC_NONE);
496
497 res = TEEC_InvokeCommand(sess, cmdId, &op, &org);
498
499 TEEC_ReleaseSharedMemory(SHARE_MEM01);
500 mem01_exit:
501 return res;
502 }
503
Invoke_MemMove(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,uint32_t memorySize)504 static TEEC_Result Invoke_MemMove(ADBG_Case_t *c, TEEC_Session *sess,
505 uint32_t cmdId, uint32_t memorySize)
506 {
507 return Invoke_Simple_Function_v1(c, sess, cmdId, memorySize, 0);
508 }
509
Invoke_AllocatePropertyEnumerator(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,uint32_t * enumerator)510 static TEEC_Result Invoke_AllocatePropertyEnumerator(ADBG_Case_t *c,
511 TEEC_Session *sess,
512 uint32_t cmdId,
513 uint32_t *enumerator)
514 {
515 TEEC_Result res = TEE_ERROR_NOT_SUPPORTED;
516 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
517 uint32_t org;
518
519 op.paramTypes = TEEC_PARAM_TYPES(
520 TEEC_VALUE_OUTPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
521
522 res = TEEC_InvokeCommand(sess, cmdId, &op, &org);
523
524 if (res != TEEC_SUCCESS)
525 goto exit;
526
527 *enumerator = op.params[0].value.a;
528 exit:
529 return res;
530 }
531
Invoke_StartPropertyEnumerator(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,uint32_t * enumerator,TEE_PropSetHandle propSet)532 static TEEC_Result Invoke_StartPropertyEnumerator(ADBG_Case_t *c,
533 TEEC_Session *sess,
534 uint32_t cmdId,
535 uint32_t *enumerator,
536 TEE_PropSetHandle propSet)
537 {
538 return Invoke_Simple_Function_v2(c, sess, cmdId, *enumerator, 0,
539 (unsigned long)propSet, 0);
540 }
541
Invoke_ResetPropertyEnumerator(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,uint32_t * enumerator)542 static TEEC_Result Invoke_ResetPropertyEnumerator(ADBG_Case_t *c,
543 TEEC_Session *sess,
544 uint32_t cmdId,
545 uint32_t *enumerator)
546 {
547 return Invoke_Simple_Function_v1(c, sess, cmdId, *enumerator, 0);
548 }
549
Invoke_GetPropertyName(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,uint32_t * enumerator,char * propertyName,uint32_t kindBuffer)550 static TEEC_Result Invoke_GetPropertyName(ADBG_Case_t *c, TEEC_Session *sess,
551 uint32_t cmdId, uint32_t *enumerator,
552 char *propertyName,
553 uint32_t kindBuffer)
554 {
555 TEEC_Result res = TEE_ERROR_NOT_SUPPORTED;
556 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
557 uint32_t org;
558 uint32_t strLen = 0;
559
560 if (kindBuffer == TOO_SHORT_BUFFER) {
561 ALLOCATE_SHARED_MEMORY(sess->ctx, SHARE_MEM01, 1,
562 TEEC_MEM_OUTPUT, mem01_exit)
563 } else {
564 ALLOCATE_SHARED_MEMORY(sess->ctx, SHARE_MEM01, BIG_SIZE,
565 TEEC_MEM_OUTPUT, mem01_exit)
566 }
567
568 op.params[0].value.a = *enumerator;
569 SET_SHARED_MEMORY_OPERATION_PARAMETER(1, 0, SHARE_MEM01,
570 SHARE_MEM01->size)
571
572 op.paramTypes = TEEC_PARAM_TYPES(
573 TEEC_VALUE_INPUT, TEEC_MEMREF_PARTIAL_OUTPUT, TEEC_NONE,
574 TEEC_NONE);
575
576 res = TEEC_InvokeCommand(sess, cmdId, &op, &org);
577
578 if (res != TEEC_SUCCESS)
579 goto exit;
580
581 strLen = strlen(propertyName) + 1;
582
583 (void)ADBG_EXPECT_COMPARE_SIGNED(c, op.params[1].memref.size, ==,
584 strLen);
585
586 (void)ADBG_EXPECT_COMPARE_SIGNED(c,
587 0, ==,
588 memcmp(SHARE_MEM01->buffer,
589 propertyName, strLen));
590
591 exit:
592 TEEC_ReleaseSharedMemory(SHARE_MEM01);
593 mem01_exit:
594 return res;
595 }
596
Invoke_Malloc(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,uint32_t memorySize,uint32_t hint)597 static TEEC_Result Invoke_Malloc(ADBG_Case_t *c, TEEC_Session *sess,
598 uint32_t cmdId, uint32_t memorySize,
599 uint32_t hint)
600 {
601 return Invoke_Simple_Function_v2(c, sess, cmdId, memorySize, 0, hint,
602 0);
603 }
604
Invoke_Panic(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId)605 static TEEC_Result Invoke_Panic(ADBG_Case_t *c, TEEC_Session *sess,
606 uint32_t cmdId)
607 {
608 TEEC_Result res = TEE_ERROR_NOT_SUPPORTED;
609 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
610 uint32_t org;
611
612 op.paramTypes = TEEC_PARAM_TYPES(
613 TEEC_NONE, TEEC_NONE, TEEC_NONE, TEEC_NONE);
614
615 res = TEEC_InvokeCommand(sess, cmdId, &op, &org);
616
617 if (res != TEEC_SUCCESS)
618 goto exit;
619
620 ADBG_EXPECT_COMPARE_SIGNED(c, org, ==, TEE_ORIGIN_TEE);
621
622 exit:
623 return res;
624 }
625
Invoke_Realloc(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,uint32_t oldMemorySize,uint32_t newMemorySize)626 static TEEC_Result Invoke_Realloc(ADBG_Case_t *c, TEEC_Session *sess,
627 uint32_t cmdId, uint32_t oldMemorySize,
628 uint32_t newMemorySize)
629 {
630 return Invoke_Simple_Function_v2(c, sess, cmdId, oldMemorySize, 0,
631 newMemorySize, 0);
632 }
633
Invoke_Free(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmdId,uint32_t Case)634 static TEEC_Result Invoke_Free(ADBG_Case_t *c, TEEC_Session *sess,
635 uint32_t cmdId, uint32_t Case)
636 {
637 return Invoke_Simple_Function_v1(c, sess, cmdId, Case, 0);
638 }
639
Invoke_OpenTASession(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmd_id,uint32_t ta_session,TEEC_UUID * uuid,uint32_t exp_eo)640 static TEEC_Result Invoke_OpenTASession(ADBG_Case_t *c, TEEC_Session *sess,
641 uint32_t cmd_id, uint32_t ta_session,
642 TEEC_UUID *uuid, uint32_t exp_eo)
643 {
644 TEEC_Result res = TEEC_SUCCESS;
645 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
646 uint32_t eo = 0;
647 TEEC_UUID swapped_uuid = *uuid;
648 TEEC_SharedMemory shm = {
649 .flags = TEEC_MEM_INPUT,
650 .buffer = &swapped_uuid,
651 .size = sizeof(*uuid),
652 };
653
654 swapped_uuid.timeLow = htonl(swapped_uuid.timeLow);
655 swapped_uuid.timeMid = htons(swapped_uuid.timeMid);
656 swapped_uuid.timeHiAndVersion = htons(swapped_uuid.timeHiAndVersion);
657
658 res = TEEC_RegisterSharedMemory(sess->ctx, &shm);
659 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
660 return res;
661
662 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT,
663 TEEC_MEMREF_PARTIAL_INPUT,
664 TEEC_VALUE_OUTPUT, TEEC_NONE);
665 op.params[0].value.a = ta_session;
666
667 op.params[1].memref.offset = 0;
668 op.params[1].memref.size = sizeof(*uuid);
669 op.params[1].memref.parent = &shm;
670
671 res = TEEC_InvokeCommand(sess, cmd_id, &op, &eo);
672 TEEC_ReleaseSharedMemory(&shm);
673
674 if (!ADBG_EXPECT(c, TEE_ORIGIN_TRUSTED_APP, eo))
675 return TEEC_ERROR_GENERIC;
676 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
677 return res;
678 ADBG_EXPECT(c, exp_eo, op.params[2].value.b);
679 return op.params[2].value.a;
680 }
681
Invoke_InvokeTACommand(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmd_id,uint32_t ta_session,uint32_t ta_cmd_id,uint32_t exp_eo)682 static TEEC_Result Invoke_InvokeTACommand(ADBG_Case_t *c, TEEC_Session *sess,
683 uint32_t cmd_id, uint32_t ta_session,
684 uint32_t ta_cmd_id, uint32_t exp_eo)
685 {
686 TEEC_Result res = TEEC_SUCCESS;
687 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
688 uint32_t eo = 0;
689
690 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT,
691 TEEC_NONE, TEEC_NONE);
692 op.params[0].value.a = ta_session;
693 op.params[0].value.b = ta_cmd_id;
694
695 res = TEEC_InvokeCommand(sess, cmd_id, &op, &eo);
696
697 if (!ADBG_EXPECT(c, TEE_ORIGIN_TRUSTED_APP, eo))
698 return TEEC_ERROR_GENERIC;
699 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
700 return res;
701 ADBG_EXPECT(c, exp_eo, op.params[1].value.b);
702 return op.params[1].value.a;
703 }
704
Invoke_CloseTASession(ADBG_Case_t * c,TEEC_Session * sess,uint32_t cmd_id,uint32_t ta_session)705 static TEEC_Result Invoke_CloseTASession(ADBG_Case_t *c, TEEC_Session *sess,
706 uint32_t cmd_id, uint32_t ta_session)
707 {
708 TEEC_Result res = TEEC_SUCCESS;
709 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
710 uint32_t eo = 0;
711
712 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
713 TEEC_NONE, TEEC_NONE);
714 op.params[0].value.a = ta_session;
715
716 res = TEEC_InvokeCommand(sess, cmd_id, &op, &eo);
717
718 ADBG_EXPECT(c, TEE_ORIGIN_TRUSTED_APP, eo);
719 return res;
720 }
721 #endif /* XML_INTERNAL_API_H_ */
722