1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2014, STMicroelectronics International N.V.
4 */
5
6 #include <string.h>
7 #include <stdio.h>
8 #include <pthread.h>
9
10 #include <adbg.h>
11 #include <xtest_test.h>
12 #include <xtest_helpers.h>
13
14 #include <tee_client_api.h>
15 #include <ta_storage.h>
16 #include <tee_api_defines.h>
17 #include <tee_api_defines_extensions.h>
18 #include <tee_api_types.h>
19 #include <util.h>
20
21 #define DEFINE_TEST_MULTIPLE_STORAGE_IDS(test_name) \
22 static void test_name(ADBG_Case_t *c) \
23 { \
24 size_t i; \
25 \
26 for (i = 0; i < ARRAY_SIZE(storage_ids); i++) { \
27 Do_ADBG_BeginSubCase(c, "Storage id: %08x", storage_ids[i]); \
28 test_name##_single(c, storage_ids[i]); \
29 Do_ADBG_EndSubCase(c, "Storage id: %08x", storage_ids[i]); \
30 } \
31 }
32
33 static uint32_t storage_ids[] = {
34 TEE_STORAGE_PRIVATE,
35 #ifdef CFG_REE_FS
36 TEE_STORAGE_PRIVATE_REE,
37 #endif
38 #ifdef CFG_RPMB_FS
39 TEE_STORAGE_PRIVATE_RPMB,
40 #endif
41 };
42
43 static uint8_t file_00[] = {
44 0x00, 0x6E, 0x04, 0x57, 0x08, 0xFB, 0x71, 0x96,
45 0xF0, 0x2E, 0x55, 0x3D, 0x02, 0xC3, 0xA6, 0x92,
46 0xE9, 0xC3, 0xEF, 0x8A, 0xB2, 0x34, 0x53, 0xE6,
47 0xF0, 0x74, 0x9C, 0xD6, 0x36, 0xE7, 0xA8, 0x8E
48 };
49
50 static uint8_t file_01[] = {
51 0x01, 0x00
52 };
53
54 static uint8_t file_02[] = {
55 0x02, 0x11, 0x02
56 };
57
58 static uint8_t file_03[] = {
59 0x03, 0x13, 0x03
60 };
61
62 static uint8_t file_04[] = {
63 0x00, 0x01, 0x02
64 };
65
66 static uint8_t data_00[] = {
67 0x00, 0x6E, 0x04, 0x57, 0x08, 0xFB, 0x71, 0x96,
68 0x00, 0x2E, 0x55, 0x3D, 0x02, 0xC3, 0xA6, 0x92,
69 0x00, 0xC3, 0xEF, 0x8A, 0xB2, 0x34, 0x53, 0xE6,
70 0x00, 0x74, 0x9C, 0xD6, 0x36, 0xE7, 0xA8, 0x00
71 };
72
73 static uint8_t data_01[] = {
74 0x01, 0x6E, 0x04, 0x57, 0x08, 0xFB, 0x71, 0x96,
75 0x01, 0x2E, 0x55, 0x3D, 0x02, 0xC3, 0xA6, 0x92,
76 0x01, 0xC3, 0xEF, 0x8A, 0xB2, 0x34, 0x53, 0xE6,
77 0x01, 0x74, 0x9C, 0xD6, 0x36, 0xE7, 0xA8, 0x01
78 };
79
fs_id_for_tee_storage_private(void)80 static uint32_t fs_id_for_tee_storage_private(void)
81 {
82 #if defined(CFG_REE_FS)
83 return TEE_STORAGE_PRIVATE_REE;
84 #elif defined(CFG_RPMB_FS)
85 return TEE_STORAGE_PRIVATE_RPMB;
86 #endif
87 }
88
real_id_for(uint32_t id)89 static uint32_t real_id_for(uint32_t id)
90 {
91 if (id == TEE_STORAGE_PRIVATE)
92 return fs_id_for_tee_storage_private();
93 return id;
94 }
95
storage_is(uint32_t id1,uint32_t id2)96 static bool storage_is(uint32_t id1, uint32_t id2)
97 {
98 return (real_id_for(id1) == real_id_for(id2));
99 }
100
fs_open(TEEC_Session * sess,void * id,uint32_t id_size,uint32_t flags,uint32_t * obj,uint32_t storage_id)101 static TEEC_Result fs_open(TEEC_Session *sess, void *id, uint32_t id_size,
102 uint32_t flags, uint32_t *obj, uint32_t storage_id)
103 {
104 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
105 TEEC_Result res = TEEC_ERROR_GENERIC;
106 uint32_t org = 0;
107
108 op.params[0].tmpref.buffer = id;
109 op.params[0].tmpref.size = id_size;
110 op.params[1].value.a = flags;
111 op.params[1].value.b = 0;
112 op.params[2].value.a = storage_id;
113
114 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
115 TEEC_VALUE_INOUT, TEEC_VALUE_INPUT,
116 TEEC_NONE);
117
118 res = TEEC_InvokeCommand(sess, TA_STORAGE_CMD_OPEN, &op, &org);
119
120 if (res == TEEC_SUCCESS)
121 *obj = op.params[1].value.b;
122
123 return res;
124 }
125
fs_create(TEEC_Session * sess,void * id,uint32_t id_size,uint32_t flags,uint32_t attr,void * data,uint32_t data_size,uint32_t * obj,uint32_t storage_id)126 static TEEC_Result fs_create(TEEC_Session *sess, void *id, uint32_t id_size,
127 uint32_t flags, uint32_t attr, void *data,
128 uint32_t data_size, uint32_t *obj,
129 uint32_t storage_id)
130 {
131 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
132 TEEC_Result res = TEEC_ERROR_GENERIC;
133 uint32_t org = 0;
134
135 op.params[0].tmpref.buffer = id;
136 op.params[0].tmpref.size = id_size;
137 op.params[1].value.a = flags;
138 op.params[1].value.b = 0;
139 op.params[2].value.a = attr;
140 op.params[2].value.b = storage_id;
141 op.params[3].tmpref.buffer = data;
142 op.params[3].tmpref.size = data_size;
143
144 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
145 TEEC_VALUE_INOUT, TEEC_VALUE_INPUT,
146 TEEC_MEMREF_TEMP_INPUT);
147
148 res = TEEC_InvokeCommand(sess, TA_STORAGE_CMD_CREATE, &op, &org);
149
150 if (res == TEEC_SUCCESS)
151 *obj = op.params[1].value.b;
152
153 return res;
154 }
155
fs_create_overwrite(TEEC_Session * sess,void * id,uint32_t id_size,uint32_t storage_id)156 static TEEC_Result fs_create_overwrite(TEEC_Session *sess, void *id,
157 uint32_t id_size, uint32_t storage_id)
158 {
159 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
160 TEEC_Result res = TEEC_ERROR_GENERIC;
161 uint32_t org = 0;
162
163 op.params[0].tmpref.buffer = id;
164 op.params[0].tmpref.size = id_size;
165 op.params[1].value.a = storage_id;
166
167 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
168 TEEC_VALUE_INPUT, TEEC_NONE,
169 TEEC_NONE);
170
171 res = TEEC_InvokeCommand(sess, TA_STORAGE_CMD_CREATE_OVERWRITE, &op, &org);
172
173 return res;
174 }
175
fs_close(TEEC_Session * sess,uint32_t obj)176 static TEEC_Result fs_close(TEEC_Session *sess, uint32_t obj)
177 {
178 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
179 uint32_t org = 0;
180
181 op.params[0].value.a = obj;
182
183 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
184 TEEC_NONE, TEEC_NONE);
185
186 return TEEC_InvokeCommand(sess, TA_STORAGE_CMD_CLOSE, &op, &org);
187 }
188
fs_read(TEEC_Session * sess,uint32_t obj,void * data,uint32_t data_size,uint32_t * count)189 static TEEC_Result fs_read(TEEC_Session *sess, uint32_t obj, void *data,
190 uint32_t data_size, uint32_t *count)
191 {
192 TEEC_Result res = TEEC_ERROR_GENERIC;
193 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
194 uint32_t org = 0;
195
196 op.params[0].tmpref.buffer = data;
197 op.params[0].tmpref.size = data_size;
198 op.params[1].value.a = obj;
199 op.params[1].value.b = 0;
200
201 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT,
202 TEEC_VALUE_INOUT, TEEC_NONE,
203 TEEC_NONE);
204
205 res = TEEC_InvokeCommand(sess, TA_STORAGE_CMD_READ, &op, &org);
206
207 if (res == TEEC_SUCCESS)
208 *count = op.params[1].value.b;
209
210 return res;
211 }
212
fs_write(TEEC_Session * sess,uint32_t obj,void * data,uint32_t data_size)213 static TEEC_Result fs_write(TEEC_Session *sess, uint32_t obj, void *data,
214 uint32_t data_size)
215 {
216 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
217 uint32_t org = 0;
218
219 op.params[0].tmpref.buffer = data;
220 op.params[0].tmpref.size = data_size;
221 op.params[1].value.a = obj;
222 op.params[1].value.b = 0;
223
224 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
225 TEEC_VALUE_INPUT, TEEC_NONE,
226 TEEC_NONE);
227
228 return TEEC_InvokeCommand(sess, TA_STORAGE_CMD_WRITE, &op, &org);
229 }
230
fs_seek(TEEC_Session * sess,uint32_t obj,int32_t offset,int32_t whence)231 static TEEC_Result fs_seek(TEEC_Session *sess, uint32_t obj, int32_t offset,
232 int32_t whence)
233 {
234 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
235 uint32_t org = 0;
236
237 op.params[0].value.a = obj;
238 op.params[0].value.b = *(uint32_t *)&offset;
239 op.params[1].value.a = whence;
240
241 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INOUT,
242 TEEC_NONE, TEEC_NONE);
243
244 return TEEC_InvokeCommand(sess, TA_STORAGE_CMD_SEEK, &op, &org);
245 }
246
fs_unlink(TEEC_Session * sess,uint32_t obj)247 static TEEC_Result fs_unlink(TEEC_Session *sess, uint32_t obj)
248 {
249 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
250 uint32_t org = 0;
251
252 op.params[0].value.a = obj;
253
254 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
255 TEEC_NONE, TEEC_NONE);
256
257 return TEEC_InvokeCommand(sess, TA_STORAGE_CMD_UNLINK, &op, &org);
258 }
259
fs_trunc(TEEC_Session * sess,uint32_t obj,uint32_t len)260 static TEEC_Result fs_trunc(TEEC_Session *sess, uint32_t obj, uint32_t len)
261 {
262 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
263 uint32_t org = 0;
264
265 op.params[0].value.a = obj;
266 op.params[0].value.b = len;
267
268 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
269 TEEC_NONE, TEEC_NONE);
270
271 return TEEC_InvokeCommand(sess, TA_STORAGE_CMD_TRUNC, &op, &org);
272 }
273
fs_rename(TEEC_Session * sess,uint32_t obj,void * id,uint32_t id_size)274 static TEEC_Result fs_rename(TEEC_Session *sess, uint32_t obj, void *id,
275 uint32_t id_size)
276 {
277 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
278 uint32_t org = 0;
279
280 op.params[0].value.a = obj;
281 op.params[1].tmpref.buffer = id;
282 op.params[1].tmpref.size = id_size;
283
284 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT,
285 TEEC_MEMREF_TEMP_INPUT, TEEC_NONE,
286 TEEC_NONE);
287
288 return TEEC_InvokeCommand(sess, TA_STORAGE_CMD_RENAME, &op, &org);
289 }
290
fs_alloc_enum(TEEC_Session * sess,uint32_t * e)291 static TEEC_Result fs_alloc_enum(TEEC_Session *sess, uint32_t *e)
292 {
293 TEEC_Result res = TEEC_ERROR_GENERIC;
294 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
295 uint32_t org = 0;
296
297 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_OUTPUT, TEEC_NONE,
298 TEEC_NONE, TEEC_NONE);
299
300 res = TEEC_InvokeCommand(sess, TA_STORAGE_CMD_ALLOC_ENUM, &op, &org);
301
302 if (res == TEEC_SUCCESS)
303 *e = op.params[0].value.a;
304
305 return res;
306 }
307
fs_reset_enum(TEEC_Session * sess,uint32_t e)308 static TEEC_Result fs_reset_enum(TEEC_Session *sess, uint32_t e)
309 {
310 TEEC_Result res = TEEC_ERROR_GENERIC;
311 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
312 uint32_t org = 0;
313
314 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
315 TEEC_NONE, TEEC_NONE);
316
317 op.params[0].value.a = e;
318 res = TEEC_InvokeCommand(sess, TA_STORAGE_CMD_RESET_ENUM, &op, &org);
319
320 return res;
321 }
322
fs_free_enum(TEEC_Session * sess,uint32_t e)323 static TEEC_Result fs_free_enum(TEEC_Session *sess, uint32_t e)
324 {
325 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
326 uint32_t org = 0;
327
328 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE, TEEC_NONE,
329 TEEC_NONE);
330
331 op.params[0].value.a = e;
332
333 return TEEC_InvokeCommand(sess, TA_STORAGE_CMD_FREE_ENUM, &op, &org);
334 }
335
fs_start_enum(TEEC_Session * sess,uint32_t e,uint32_t storage_id)336 static TEEC_Result fs_start_enum(TEEC_Session *sess, uint32_t e,
337 uint32_t storage_id)
338 {
339 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
340 uint32_t org = 0;
341
342 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
343 TEEC_NONE, TEEC_NONE);
344
345 op.params[0].value.a = e;
346 op.params[0].value.b = storage_id;
347
348 return TEEC_InvokeCommand(sess, TA_STORAGE_CMD_START_ENUM, &op, &org);
349 }
350
fs_next_enum(TEEC_Session * sess,uint32_t e,void * obj_info,size_t info_size,void * id,uint32_t id_size)351 static TEEC_Result fs_next_enum(TEEC_Session *sess, uint32_t e, void *obj_info,
352 size_t info_size, void *id, uint32_t id_size)
353 {
354 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
355 uint32_t org = 0;
356
357 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
358 TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE);
359 if (obj_info && info_size)
360 op.paramTypes |= (TEEC_MEMREF_TEMP_OUTPUT << 4);
361
362 op.params[0].value.a = e;
363 op.params[1].tmpref.buffer = obj_info;
364 op.params[1].tmpref.size = info_size;
365 op.params[2].tmpref.buffer = id;
366 op.params[2].tmpref.size = id_size;
367
368 return TEEC_InvokeCommand(sess, TA_STORAGE_CMD_NEXT_ENUM, &op, &org);
369 }
370
fs_restrict_usage(TEEC_Session * sess,uint32_t obj,uint32_t obj_usage)371 static TEEC_Result fs_restrict_usage(TEEC_Session *sess, uint32_t obj,
372 uint32_t obj_usage)
373 {
374 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
375 uint32_t org = 0;
376
377 op.params[0].value.a = obj;
378 op.params[0].value.b = obj_usage;
379
380 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
381 TEEC_NONE, TEEC_NONE);
382
383 return TEEC_InvokeCommand(sess, TA_STORAGE_CMD_RESTRICT_USAGE,
384 &op, &org);
385 }
386
fs_alloc_obj(TEEC_Session * sess,uint32_t obj_type,uint32_t max_key_size,uint32_t * obj)387 static TEEC_Result fs_alloc_obj(TEEC_Session *sess, uint32_t obj_type,
388 uint32_t max_key_size, uint32_t *obj)
389 {
390 TEEC_Result res = TEEC_ERROR_GENERIC;
391 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
392 uint32_t org = 0;
393
394 op.params[0].value.a = obj_type;
395 op.params[0].value.b = max_key_size;
396
397 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT,
398 TEEC_NONE, TEEC_NONE);
399
400 res = TEEC_InvokeCommand(sess, TA_STORAGE_CMD_ALLOC_OBJ, &op, &org);
401 *obj = op.params[1].value.a;
402 return res;
403 }
404
fs_free_obj(TEEC_Session * sess,uint32_t obj)405 static TEEC_Result fs_free_obj(TEEC_Session *sess, uint32_t obj)
406 {
407 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
408 uint32_t org = 0;
409
410 op.params[0].value.a = obj;
411
412 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
413 TEEC_NONE, TEEC_NONE);
414
415 return TEEC_InvokeCommand(sess, TA_STORAGE_CMD_FREE_OBJ, &op, &org);
416 }
417
fs_reset_obj(TEEC_Session * sess,uint32_t obj)418 static TEEC_Result fs_reset_obj(TEEC_Session *sess, uint32_t obj)
419 {
420 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
421 uint32_t org = 0;
422
423 op.params[0].value.a = obj;
424
425 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
426 TEEC_NONE, TEEC_NONE);
427
428 return TEEC_InvokeCommand(sess, TA_STORAGE_CMD_RESET_OBJ, &op, &org);
429 }
430
fs_get_obj_info(TEEC_Session * sess,uint32_t obj,void * obj_info,size_t info_size)431 static TEEC_Result fs_get_obj_info(TEEC_Session *sess, uint32_t obj,
432 void *obj_info, size_t info_size)
433 {
434 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
435 uint32_t org = 0;
436
437 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT,
438 TEEC_MEMREF_TEMP_OUTPUT,
439 TEEC_NONE, TEEC_NONE);
440
441 op.params[0].value.a = obj;
442 op.params[1].tmpref.buffer = obj_info;
443 op.params[1].tmpref.size = info_size;
444
445 return TEEC_InvokeCommand(sess, TA_STORAGE_CMD_GET_OBJ_INFO, &op, &org);
446 }
447
448 /* trunc */
test_truncate_file_length(ADBG_Case_t * c,uint32_t storage_id)449 static void test_truncate_file_length(ADBG_Case_t *c, uint32_t storage_id)
450 {
451 TEEC_Session sess = { };
452 uint32_t obj = 0;
453 uint8_t out[10] = { };
454 uint32_t count = 0;
455 uint32_t orig = 0;
456
457 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
458 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
459 return;
460
461 /* create */
462 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
463 fs_create(&sess, file_01, sizeof(file_01),
464 TEE_DATA_FLAG_ACCESS_WRITE |
465 TEE_DATA_FLAG_ACCESS_READ |
466 TEE_DATA_FLAG_ACCESS_WRITE_META, 0, data_00,
467 sizeof(data_00), &obj, storage_id)))
468 goto exit;
469
470 /* trunc */
471 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_trunc(&sess, obj, 10)))
472 goto exit;
473
474 /* seek */
475 if (!ADBG_EXPECT_TEEC_SUCCESS(
476 c, fs_seek(&sess, obj, 5, TEE_DATA_SEEK_SET)))
477 goto exit;
478
479 /* verify */
480 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_read(&sess, obj, out, 10, &count)))
481 goto exit;
482
483 /* check buffer */
484 (void)ADBG_EXPECT_BUFFER(c, &data_00[5], 5, out, count);
485
486 /* close */
487 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
488 goto exit;
489
490 /* open */
491 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_open(&sess, file_01, sizeof(file_01),
492 TEE_DATA_FLAG_ACCESS_WRITE |
493 TEE_DATA_FLAG_ACCESS_READ |
494 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj, storage_id)))
495 goto exit;
496
497 /* seek */
498 if (!ADBG_EXPECT_TEEC_SUCCESS(
499 c, fs_seek(&sess, obj, 5, TEE_DATA_SEEK_SET)))
500 goto exit;
501
502 /* verify */
503 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_read(&sess, obj, out, 10, &count)))
504 goto exit;
505
506 /* check buffer */
507 (void)ADBG_EXPECT_BUFFER(c, &data_00[5], 5, out, count);
508
509 /* clean */
510 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj)))
511 goto exit;
512
513 exit:
514 TEEC_CloseSession(&sess);
515 }
516
517 /* extend */
test_extend_file_length(ADBG_Case_t * c,uint32_t storage_id)518 static void test_extend_file_length(ADBG_Case_t *c, uint32_t storage_id)
519 {
520 TEEC_Session sess = { };
521 uint32_t obj = 0;
522 uint8_t out[10] = { };
523 uint8_t expect[10] = { };
524 uint32_t count = 0;
525 uint32_t orig = 0;
526
527 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
528 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
529 return;
530
531 /* create */
532 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
533 fs_create(&sess, file_01, sizeof(file_01),
534 TEE_DATA_FLAG_ACCESS_WRITE |
535 TEE_DATA_FLAG_ACCESS_READ |
536 TEE_DATA_FLAG_ACCESS_WRITE_META, 0, data_00,
537 sizeof(data_00), &obj, storage_id)))
538 goto exit;
539
540 /* extend */
541 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_trunc(&sess, obj, 40)))
542 goto exit;
543
544 /* seek */
545 if (!ADBG_EXPECT_TEEC_SUCCESS(
546 c, fs_seek(&sess, obj, 30, TEE_DATA_SEEK_SET)))
547 goto exit;
548
549 /* verify */
550 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_read(&sess, obj, out, 10, &count)))
551 goto exit;
552
553 /* check buffer */
554 expect[0] = data_00[30];
555 expect[1] = data_00[31];
556 (void)ADBG_EXPECT_BUFFER(c, &expect[0], 10, out, count);
557
558 /* close */
559 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
560 goto exit;
561
562 /* open */
563 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_open(&sess, file_01, sizeof(file_01),
564 TEE_DATA_FLAG_ACCESS_WRITE |
565 TEE_DATA_FLAG_ACCESS_READ |
566 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj, storage_id)))
567 goto exit;
568
569 /* seek */
570 if (!ADBG_EXPECT_TEEC_SUCCESS(
571 c, fs_seek(&sess, obj, 30, TEE_DATA_SEEK_SET)))
572 goto exit;
573
574 /* verify */
575 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_read(&sess, obj, out, 10, &count)))
576 goto exit;
577
578 /* check buffer */
579 expect[0] = data_00[30];
580 expect[1] = data_00[31];
581 (void)ADBG_EXPECT_BUFFER(c, &expect[0], 10, out, count);
582
583 /* clean */
584 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj)))
585 goto exit;
586
587 exit:
588 TEEC_CloseSession(&sess);
589 }
590
591 /* file hole */
test_file_hole(ADBG_Case_t * c,uint32_t storage_id)592 static void test_file_hole(ADBG_Case_t *c, uint32_t storage_id)
593 {
594 TEEC_Session sess = { };
595 uint32_t obj = 0;
596 uint8_t out[10] = { };
597 uint8_t expect[10] = { };
598 uint32_t count = 0;
599 uint32_t orig = 0;
600
601 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
602 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
603 return;
604
605 /* create */
606 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
607 fs_create(&sess, file_01, sizeof(file_01),
608 TEE_DATA_FLAG_ACCESS_WRITE |
609 TEE_DATA_FLAG_ACCESS_READ |
610 TEE_DATA_FLAG_ACCESS_WRITE_META, 0, data_00,
611 sizeof(data_00), &obj, storage_id)))
612 goto exit;
613
614 /* seek */
615 if (!ADBG_EXPECT_TEEC_SUCCESS(
616 c, fs_seek(&sess, obj, 80, TEE_DATA_SEEK_SET)))
617 goto exit;
618
619 /* write */
620 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_write(&sess, obj, data_00,
621 sizeof(data_00))))
622 goto exit;
623
624 /* seek */
625 if (!ADBG_EXPECT_TEEC_SUCCESS(
626 c, fs_seek(&sess, obj, 74, TEE_DATA_SEEK_SET)))
627 goto exit;
628
629 /* verify */
630 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_read(&sess, obj, out, 10, &count)))
631 goto exit;
632
633 /* check buffer */
634 expect[6] = data_00[0];
635 expect[7] = data_00[1];
636 expect[8] = data_00[2];
637 expect[9] = data_00[3];
638 (void)ADBG_EXPECT_BUFFER(c, &expect[0], 10, out, count);
639
640 /* close */
641 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
642 goto exit;
643
644 /* open */
645 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_open(&sess, file_01, sizeof(file_01),
646 TEE_DATA_FLAG_ACCESS_WRITE |
647 TEE_DATA_FLAG_ACCESS_READ |
648 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj, storage_id)))
649 goto exit;
650
651 /* seek */
652 if (!ADBG_EXPECT_TEEC_SUCCESS(
653 c, fs_seek(&sess, obj, 74, TEE_DATA_SEEK_SET)))
654 goto exit;
655
656 /* verify */
657 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_read(&sess, obj, out, 10, &count)))
658 goto exit;
659
660 /* check buffer */
661 expect[6] = data_00[0];
662 expect[7] = data_00[1];
663 expect[8] = data_00[2];
664 expect[9] = data_00[3];
665 (void)ADBG_EXPECT_BUFFER(c, &expect[0], 10, out, count);
666
667 /* clean */
668 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj)))
669 goto exit;
670
671 exit:
672 TEEC_CloseSession(&sess);
673 }
674
675 /* create */
xtest_tee_test_6001_single(ADBG_Case_t * c,uint32_t storage_id)676 static void xtest_tee_test_6001_single(ADBG_Case_t *c, uint32_t storage_id)
677 {
678 TEEC_Session sess = { };
679 uint32_t obj = 0;
680 uint32_t orig = 0;
681
682 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
683 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
684 return;
685
686 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
687 fs_create(&sess, file_00, sizeof(file_00),
688 TEE_DATA_FLAG_ACCESS_WRITE |
689 TEE_DATA_FLAG_ACCESS_WRITE_META, 0, data_00,
690 sizeof(data_00), &obj, storage_id)))
691 goto exit;
692
693 /* clean */
694 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj)))
695 goto exit;
696
697 exit:
698 TEEC_CloseSession(&sess);
699 }
700 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6001)
701 ADBG_CASE_DEFINE(regression, 6001, xtest_tee_test_6001,
702 "Test TEE_CreatePersistentObject");
703
704 /* open */
xtest_tee_test_6002_single(ADBG_Case_t * c,uint32_t storage_id)705 static void xtest_tee_test_6002_single(ADBG_Case_t *c, uint32_t storage_id)
706 {
707 TEEC_Session sess = { };
708 uint32_t obj = 0;
709 uint32_t orig = 0;
710
711 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
712 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
713 return;
714
715 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
716 fs_create(&sess, file_01, sizeof(file_01),
717 TEE_DATA_FLAG_ACCESS_WRITE, 0, data_00,
718 sizeof(data_00), &obj, storage_id)))
719 goto exit;
720
721 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
722 goto exit;
723
724 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
725 fs_open(&sess, file_01, sizeof(file_01),
726 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj, storage_id)))
727 goto exit;
728
729 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
730 goto exit;
731
732 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
733 fs_open(&sess, file_01, sizeof(file_01),
734 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj, storage_id)))
735 goto exit;
736
737 /* clean */
738 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj)))
739 goto exit;
740
741 exit:
742 TEEC_CloseSession(&sess);
743 }
744 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6002)
745 ADBG_CASE_DEFINE(regression, 6002, xtest_tee_test_6002,
746 "Test TEE_OpenPersistentObject");
747
748 /* read */
xtest_tee_test_6003_single(ADBG_Case_t * c,uint32_t storage_id)749 static void xtest_tee_test_6003_single(ADBG_Case_t *c, uint32_t storage_id)
750 {
751 TEEC_Session sess = { };
752 uint32_t obj = 0;
753 uint8_t out[10] = { };
754 uint32_t count = 0;
755 uint32_t orig = 0;
756
757 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
758 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
759 return;
760
761 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
762 fs_create(&sess, file_02, sizeof(file_02),
763 TEE_DATA_FLAG_ACCESS_WRITE, 0, data_01,
764 sizeof(data_01), &obj, storage_id)))
765 goto exit;
766
767 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
768 goto exit;
769
770 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
771 fs_open(&sess, file_02, sizeof(file_02),
772 TEE_DATA_FLAG_ACCESS_READ |
773 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj, storage_id)))
774 goto exit;
775
776 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_read(&sess, obj, out, 10, &count)))
777 goto exit;
778
779 (void)ADBG_EXPECT_BUFFER(c, data_01, 10, out, count);
780
781 /* clean */
782 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj)))
783 goto exit;
784
785 exit:
786 TEEC_CloseSession(&sess);
787 }
788 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6003)
789 ADBG_CASE_DEFINE(regression, 6003, xtest_tee_test_6003,
790 "Test TEE_ReadObjectData");
791
792 /* write */
xtest_tee_test_6004_single(ADBG_Case_t * c,uint32_t storage_id)793 static void xtest_tee_test_6004_single(ADBG_Case_t *c, uint32_t storage_id)
794 {
795 TEEC_Session sess = { };
796 uint32_t obj = 0;
797 uint8_t out[10] = { };
798 uint32_t count = 0;
799 uint32_t orig = 0;
800
801 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
802 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
803 return;
804
805 /* create */
806 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
807 fs_create(&sess, file_02, sizeof(file_02),
808 TEE_DATA_FLAG_ACCESS_WRITE, 0, data_01,
809 sizeof(data_01), &obj, storage_id)))
810 goto exit;
811
812 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
813 goto exit;
814
815 /* write new data */
816 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
817 fs_open(&sess, file_02, sizeof(file_02),
818 TEE_DATA_FLAG_ACCESS_WRITE, &obj, storage_id)))
819 goto exit;
820
821 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
822 fs_write(&sess, obj, data_00, sizeof(data_00))))
823 goto exit;
824
825 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
826 goto exit;
827
828 /* verify */
829 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
830 fs_open(&sess, file_02, sizeof(file_02),
831 TEE_DATA_FLAG_ACCESS_READ |
832 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj, storage_id)))
833 goto exit;
834
835 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_read(&sess, obj, out, 10, &count)))
836 goto exit;
837
838 (void)ADBG_EXPECT_BUFFER(c, data_00, 10, out, count);
839
840 /* clean */
841 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj)))
842 goto exit;
843
844 exit:
845 TEEC_CloseSession(&sess);
846 }
847 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6004)
848 ADBG_CASE_DEFINE(regression, 6004, xtest_tee_test_6004,
849 "Test TEE_WriteObjectData");
850
851 /* seek */
xtest_tee_test_6005_single(ADBG_Case_t * c,uint32_t storage_id)852 static void xtest_tee_test_6005_single(ADBG_Case_t *c, uint32_t storage_id)
853 {
854 TEEC_Session sess = { };
855 uint32_t obj = 0;
856 uint8_t out[10] = { };
857 uint32_t count = 0;
858 uint32_t orig = 0;
859
860 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
861 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
862 return;
863
864 /* create */
865 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
866 fs_create(&sess, file_01, sizeof(file_01),
867 TEE_DATA_FLAG_ACCESS_WRITE |
868 TEE_DATA_FLAG_ACCESS_READ |
869 TEE_DATA_FLAG_ACCESS_WRITE_META, 0, data_00,
870 sizeof(data_00), &obj, storage_id)))
871 goto exit;
872
873 /* seek */
874 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
875 fs_seek(&sess, obj, 10, TEE_DATA_SEEK_SET)))
876 goto exit;
877
878 /* verify */
879 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_read(&sess, obj, out, 10, &count)))
880 goto exit;
881
882 (void)ADBG_EXPECT_BUFFER(c, &data_00[10], 10, out, count);
883
884 /* clean */
885 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj)))
886 goto exit;
887
888 exit:
889 TEEC_CloseSession(&sess);
890 }
891 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6005)
892 ADBG_CASE_DEFINE(regression, 6005, xtest_tee_test_6005,
893 "Test TEE_SeekObjectData");
894
895 /* unlink */
xtest_tee_test_6006_single(ADBG_Case_t * c,uint32_t storage_id)896 static void xtest_tee_test_6006_single(ADBG_Case_t *c, uint32_t storage_id)
897 {
898 TEEC_Session sess = { };
899 uint32_t obj = 0;
900 uint32_t orig = 0;
901
902 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
903 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
904 return;
905
906 /* create */
907 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
908 fs_create(&sess, file_01, sizeof(file_01),
909 TEE_DATA_FLAG_ACCESS_WRITE_META, 0, data_00,
910 sizeof(data_00), &obj, storage_id)))
911 goto exit;
912
913 /* del & close */
914 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj)))
915 goto exit;
916
917 /* check result */
918 if (!ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_ITEM_NOT_FOUND,
919 fs_open(&sess, file_01, sizeof(file_01),
920 TEE_DATA_FLAG_ACCESS_READ, &obj, storage_id)))
921 goto exit;
922
923 exit:
924 TEEC_CloseSession(&sess);
925 }
926 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6006)
927 ADBG_CASE_DEFINE(regression, 6006, xtest_tee_test_6006,
928 "Test TEE_CloseAndDeletePersistentObject");
929
xtest_tee_test_6007_single(ADBG_Case_t * c,uint32_t storage_id)930 static void xtest_tee_test_6007_single(ADBG_Case_t *c, uint32_t storage_id)
931 {
932 Do_ADBG_BeginSubCase(c, "Test truncate file length");
933 test_truncate_file_length(c, storage_id);
934 Do_ADBG_EndSubCase(c, "Test truncate file length");
935
936 Do_ADBG_BeginSubCase(c, "Test extend file length");
937 test_extend_file_length(c, storage_id);
938 Do_ADBG_EndSubCase(c, "Test extend file length");
939
940 Do_ADBG_BeginSubCase(c, "Test file hole");
941 test_file_hole(c, storage_id);
942 Do_ADBG_EndSubCase(c, "Test file hole");
943 }
944 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6007)
945 ADBG_CASE_DEFINE(regression, 6007, xtest_tee_test_6007,
946 "Test TEE_TruncateObjectData");
947
xtest_tee_test_6008_single(ADBG_Case_t * c,uint32_t storage_id)948 static void xtest_tee_test_6008_single(ADBG_Case_t *c, uint32_t storage_id)
949 {
950 TEEC_Session sess = { };
951 uint32_t obj = 0;
952 uint8_t out[10] = { };
953 uint32_t count = 0;
954 uint32_t orig = 0;
955
956 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
957 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
958 return;
959
960 /* create */
961 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
962 fs_create(&sess, file_02, sizeof(file_02),
963 TEE_DATA_FLAG_ACCESS_WRITE, 0, data_01,
964 sizeof(data_01), &obj, storage_id)))
965 goto exit;
966
967 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
968 goto exit;
969
970 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
971 fs_open(&sess, file_02, sizeof(file_02),
972 TEE_DATA_FLAG_ACCESS_WRITE |
973 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj, storage_id)))
974 goto exit;
975
976 /* write new data */
977 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
978 fs_write(&sess, obj, data_00, sizeof(data_00))))
979 goto exit;
980
981 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
982 fs_rename(&sess, obj, file_03, sizeof(file_03))))
983 goto exit;
984
985 /* close */
986 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
987 goto exit;
988
989 /* verify */
990 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
991 fs_open(&sess, file_03, sizeof(file_03),
992 TEE_DATA_FLAG_ACCESS_READ |
993 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj, storage_id)))
994 goto exit;
995
996 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_read(&sess, obj, out, 10, &count)))
997 goto exit;
998
999 /* check buffer */
1000 (void)ADBG_EXPECT_BUFFER(c, data_00, 10, out, count);
1001
1002 /* clean */
1003 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj)))
1004 goto exit;
1005
1006 exit:
1007 TEEC_CloseSession(&sess);
1008 }
1009 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6008)
1010 ADBG_CASE_DEFINE(regression, 6008, xtest_tee_test_6008,
1011 "Test TEE_RenamePersistentObject");
1012
xtest_tee_test_6009_single(ADBG_Case_t * c,uint32_t storage_id)1013 static void xtest_tee_test_6009_single(ADBG_Case_t *c, uint32_t storage_id)
1014 {
1015 TEEC_Session sess = { };
1016 uint32_t obj0 = 0;
1017 uint32_t obj1 = 0;
1018 uint32_t obj2 = 0;
1019 uint32_t e = 0;
1020 uint8_t info[200] = { };
1021 uint8_t id[200] = { };
1022 uint32_t orig = 0;
1023
1024 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1025 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1026 return;
1027
1028 /* create file 00 */
1029 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1030 fs_create(&sess, file_00, sizeof(file_00),
1031 TEE_DATA_FLAG_ACCESS_WRITE, 0, data_01,
1032 sizeof(data_01), &obj0, storage_id)))
1033 goto exit;
1034
1035 /* create file 01 */
1036 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1037 fs_create(&sess, file_01, sizeof(file_01),
1038 TEE_DATA_FLAG_ACCESS_WRITE, 0, data_01,
1039 sizeof(data_01), &obj1, storage_id)))
1040 goto exit;
1041
1042 /* create file 02 */
1043 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1044 fs_create(&sess, file_02, sizeof(file_02),
1045 TEE_DATA_FLAG_ACCESS_WRITE, 0, data_01,
1046 sizeof(data_01), &obj2, storage_id)))
1047 goto exit;
1048
1049 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj0)))
1050 goto exit;
1051
1052 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj1)))
1053 goto exit;
1054
1055 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj2)))
1056 goto exit;
1057
1058 /* iterate */
1059 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_alloc_enum(&sess, &e)))
1060 goto exit;
1061
1062 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_start_enum(&sess, e, storage_id)))
1063 goto exit;
1064
1065 /* get 00 */
1066 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1067 fs_next_enum(&sess, e, info, sizeof(info), id, sizeof(id))))
1068 goto exit;
1069
1070 /* get 01 */
1071 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1072 fs_next_enum(&sess, e, NULL, 0, id, sizeof(id))))
1073 goto exit;
1074
1075 /* get 02 */
1076 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1077 fs_next_enum(&sess, e, info, sizeof(info), id, sizeof(id))))
1078 goto exit;
1079
1080 /* we should not have more files */
1081 if (!ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_ITEM_NOT_FOUND,
1082 fs_next_enum(&sess, e, info, sizeof(info), id, sizeof(id))))
1083 goto exit;
1084
1085 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_free_enum(&sess, e)))
1086 goto exit;
1087
1088 /* clean */
1089 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1090 fs_open(&sess, file_00, sizeof(file_00),
1091 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj0, storage_id)))
1092 goto exit;
1093
1094 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj0)))
1095 goto exit;
1096
1097 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1098 fs_open(&sess, file_01, sizeof(file_01),
1099 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj1, storage_id)))
1100 goto exit;
1101
1102 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj1)))
1103 goto exit;
1104
1105 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1106 fs_open(&sess, file_02, sizeof(file_02),
1107 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj2, storage_id)))
1108 goto exit;
1109
1110 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj2)))
1111 goto exit;
1112
1113 exit:
1114 TEEC_CloseSession(&sess);
1115 }
1116 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6009)
1117 ADBG_CASE_DEFINE(regression, 6009, xtest_tee_test_6009,
1118 "Test TEE Internal API Persistent Object Enumeration Functions");
1119
xtest_tee_test_6010_single(ADBG_Case_t * c,uint32_t storage_id)1120 static void xtest_tee_test_6010_single(ADBG_Case_t *c, uint32_t storage_id)
1121 {
1122 TEEC_Session sess = { };
1123 uint32_t orig = 0;
1124 uint32_t o1 = 0;
1125 uint32_t o2 = 0;
1126 uint32_t e = 0;
1127 uint32_t f = 0;
1128 uint8_t data[1024] = { };
1129 uint8_t out[1024] = { };
1130 uint32_t n = 0;
1131
1132 for (n = 0; n < ARRAY_SIZE(data); n++)
1133 data[n] = n;
1134
1135 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1136 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1137 return;
1138
1139 Do_ADBG_BeginSubCase(c, "CreatePersistentObject AccessConflict");
1140
1141 o1 = TEE_HANDLE_NULL;
1142 o2 = TEE_HANDLE_NULL;
1143 f = TEE_DATA_FLAG_ACCESS_READ | TEE_DATA_FLAG_ACCESS_WRITE |
1144 TEE_DATA_FLAG_ACCESS_WRITE_META | TEE_DATA_FLAG_SHARE_READ |
1145 TEE_DATA_FLAG_SHARE_WRITE | TEE_DATA_FLAG_OVERWRITE;
1146
1147 ADBG_EXPECT_TEEC_SUCCESS(c,
1148 fs_create(&sess, file_00, sizeof(file_00), f, 0, data,
1149 sizeof(data), &o1, storage_id));
1150
1151 f = TEE_DATA_FLAG_ACCESS_READ | TEE_DATA_FLAG_ACCESS_WRITE;
1152 ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_ACCESS_CONFLICT,
1153 fs_create(&sess, file_00, sizeof(file_00), f, 0, data,
1154 sizeof(data), &o2, storage_id));
1155
1156 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, o1));
1157 if (o2)
1158 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, o2));
1159
1160 Do_ADBG_EndSubCase(c, "CreatePersistentObject AccessConflict");
1161
1162
1163
1164 Do_ADBG_BeginSubCase(c, "RestrictObjectUsage Panic");
1165 ADBG_EXPECT_TEEC_RESULT(c, TEE_ERROR_TARGET_DEAD,
1166 fs_restrict_usage(&sess, 0xffffbad0, 0xffffffff));
1167 Do_ADBG_EndSubCase(c, "RestrictObjectUsage Panic");
1168
1169 TEEC_CloseSession(&sess);
1170 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1171 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1172 return;
1173
1174 Do_ADBG_BeginSubCase(c, "SeekObjectData BadHandle");
1175 ADBG_EXPECT_TEEC_RESULT(c, TEE_ERROR_TARGET_DEAD,
1176 fs_seek(&sess, 0xffffbad0, 5, TEE_DATA_SEEK_SET));
1177 Do_ADBG_EndSubCase(c, "SeekObjectData BadHandle");
1178
1179 TEEC_CloseSession(&sess);
1180 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1181 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1182 return;
1183
1184 Do_ADBG_BeginSubCase(c, "SeekObjectData NotPersist");
1185 o1 = 0;
1186 ADBG_EXPECT_TEEC_SUCCESS(c,
1187 fs_alloc_obj(&sess, TEE_TYPE_AES, 256, &o1));
1188 ADBG_EXPECT_TEEC_RESULT(c, TEE_ERROR_TARGET_DEAD,
1189 fs_seek(&sess, o1, 5, TEE_DATA_SEEK_SET));
1190 Do_ADBG_EndSubCase(c, "SeekObjectData NotPersist");
1191
1192 TEEC_CloseSession(&sess);
1193 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1194 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1195 return;
1196
1197 Do_ADBG_BeginSubCase(c, "SeekWriteRead");
1198 o1 = 0;
1199 f = TEE_DATA_FLAG_ACCESS_READ | TEE_DATA_FLAG_ACCESS_WRITE |
1200 TEE_DATA_FLAG_ACCESS_WRITE_META | TEE_DATA_FLAG_SHARE_READ |
1201 TEE_DATA_FLAG_SHARE_WRITE | TEE_DATA_FLAG_OVERWRITE;
1202 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1203 fs_create(&sess, file_00, sizeof(file_00), f, 0, data,
1204 sizeof(data), &o1, storage_id)))
1205 goto seek_write_read_out;
1206
1207 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1208 fs_seek(&sess, o1, 2, TEE_DATA_SEEK_SET)))
1209 goto seek_write_read_out;
1210
1211 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1212 fs_seek(&sess, o1, 0, TEE_DATA_SEEK_END)))
1213 goto seek_write_read_out;
1214
1215 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1216 fs_write(&sess, o1, data, sizeof(data))))
1217 goto seek_write_read_out;
1218
1219 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1220 fs_seek(&sess, o1, sizeof(data), TEE_DATA_SEEK_SET)))
1221 goto seek_write_read_out;
1222
1223 memset(out, 0xab, sizeof(out));
1224 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1225 fs_read(&sess, o1, out, sizeof(out), &n)))
1226 goto seek_write_read_out;
1227
1228 ADBG_EXPECT_BUFFER(c, data, sizeof(data), out, n);
1229
1230 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1231 fs_seek(&sess, o1, 10, TEE_DATA_SEEK_END)))
1232 goto seek_write_read_out;
1233
1234 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1235 fs_read(&sess, o1, out, sizeof(out), &n)))
1236 goto seek_write_read_out;
1237 ADBG_EXPECT_COMPARE_UNSIGNED(c, n, ==, 0);
1238
1239 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1240 fs_seek(&sess, o1, -(int32_t)sizeof(data) / 2,
1241 TEE_DATA_SEEK_END)))
1242 goto seek_write_read_out;
1243
1244 memset(out, 0xab, sizeof(out) / 2);
1245 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1246 fs_read(&sess, o1, out, sizeof(out) / 2, &n)))
1247 goto seek_write_read_out;
1248
1249 ADBG_EXPECT_BUFFER(c,
1250 data + sizeof(data) / 2, sizeof(data) / 2,
1251 out, n);
1252
1253 seek_write_read_out:
1254 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, o1));
1255 Do_ADBG_EndSubCase(c, "SeekWriteRead");
1256
1257 Do_ADBG_BeginSubCase(c, "Rename Access Conflict");
1258
1259 o1 = TEE_HANDLE_NULL;
1260 o2 = TEE_HANDLE_NULL;
1261 f = TEE_DATA_FLAG_ACCESS_READ | TEE_DATA_FLAG_ACCESS_WRITE |
1262 TEE_DATA_FLAG_ACCESS_WRITE_META | TEE_DATA_FLAG_SHARE_READ |
1263 TEE_DATA_FLAG_SHARE_WRITE | TEE_DATA_FLAG_OVERWRITE;
1264 ADBG_EXPECT_TEEC_SUCCESS(c,
1265 fs_create(&sess, file_00, sizeof(file_00), f, 0, data,
1266 sizeof(data), &o1, storage_id));
1267 ADBG_EXPECT_TEEC_SUCCESS(c,
1268 fs_create(&sess, file_01, sizeof(file_01), f, 0, data,
1269 sizeof(data) / 2, &o2, storage_id));
1270
1271 ADBG_EXPECT_TEEC_RESULT(c, TEE_ERROR_ACCESS_CONFLICT,
1272 fs_rename(&sess, o2, file_00, sizeof(file_00)));
1273
1274 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, o1));
1275 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, o2));
1276
1277 Do_ADBG_EndSubCase(c, "Rename Access Conflict");
1278
1279 Do_ADBG_BeginSubCase(c, "Rename Access Conflict 2");
1280
1281 o1 = TEE_HANDLE_NULL;
1282 o2 = TEE_HANDLE_NULL;
1283 f = TEE_DATA_FLAG_ACCESS_READ | TEE_DATA_FLAG_ACCESS_WRITE |
1284 TEE_DATA_FLAG_ACCESS_WRITE_META | TEE_DATA_FLAG_SHARE_READ |
1285 TEE_DATA_FLAG_SHARE_WRITE | TEE_DATA_FLAG_OVERWRITE;
1286 ADBG_EXPECT_TEEC_SUCCESS(c,
1287 fs_create(&sess, file_00, sizeof(file_00), f, 0, data,
1288 sizeof(data), &o1, storage_id));
1289 ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, o1));
1290
1291 ADBG_EXPECT_TEEC_SUCCESS(c,
1292 fs_create(&sess, file_01, sizeof(file_01), f, 0, data,
1293 sizeof(data) / 2, &o2, storage_id));
1294 ADBG_EXPECT_TEEC_RESULT(c, TEE_ERROR_ACCESS_CONFLICT,
1295 fs_rename(&sess, o2, file_00, sizeof(file_00)));
1296
1297 ADBG_EXPECT_TEEC_SUCCESS(c,
1298 fs_create(&sess, file_00, sizeof(file_00), f, 0, data,
1299 sizeof(data), &o1, storage_id));
1300
1301 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, o1));
1302 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, o2));
1303
1304 Do_ADBG_EndSubCase(c, "Rename Access Conflict 2");
1305
1306 Do_ADBG_BeginSubCase(c, "AllocPersistentObjectEnumerator + "
1307 "ResetPersistentObjectEnumerator");
1308 e = TEE_HANDLE_NULL;
1309 ADBG_EXPECT_TEEC_SUCCESS(c, fs_alloc_enum(&sess, &e));
1310 ADBG_EXPECT_TEEC_SUCCESS(c, fs_reset_enum(&sess, e));
1311 Do_ADBG_EndSubCase(c, "AllocPersistentObjectEnumerator + "
1312 "ResetPersistentObjectEnumerator");
1313
1314 Do_ADBG_BeginSubCase(c, "StartPersistentObjectEnumerator ItemNotFound");
1315 e = TEE_HANDLE_NULL;
1316 ADBG_EXPECT_TEEC_SUCCESS(c, fs_alloc_enum(&sess, &e));
1317 ADBG_EXPECT_TEEC_RESULT(c, TEE_ERROR_ITEM_NOT_FOUND,
1318 fs_next_enum(&sess, e, NULL, 0, out, sizeof(out)));
1319 ADBG_EXPECT_TEEC_RESULT(c, TEE_ERROR_ITEM_NOT_FOUND,
1320 fs_start_enum(&sess, e, storage_id));
1321 ADBG_EXPECT_TEEC_SUCCESS(c, fs_free_enum(&sess, e));
1322 Do_ADBG_EndSubCase(c, "StartPersistentObjectEnumerator ItemNotFound");
1323
1324 Do_ADBG_BeginSubCase(c, "RenamePersistent ReadWrite");
1325 o1 = TEE_HANDLE_NULL;
1326 f = TEE_DATA_FLAG_ACCESS_READ | TEE_DATA_FLAG_ACCESS_WRITE |
1327 TEE_DATA_FLAG_ACCESS_WRITE_META | TEE_DATA_FLAG_SHARE_READ |
1328 TEE_DATA_FLAG_SHARE_WRITE | TEE_DATA_FLAG_OVERWRITE;
1329 ADBG_EXPECT_TEEC_SUCCESS(c,
1330 fs_create(&sess, file_00, sizeof(file_00), f, 0, data,
1331 sizeof(data), &o1, storage_id));
1332 ADBG_EXPECT_TEEC_SUCCESS(c,
1333 fs_rename(&sess, o1, file_01, sizeof(file_01)));
1334 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, o1));
1335 Do_ADBG_EndSubCase(c, "RenamePersistent ReadWrite");
1336
1337 Do_ADBG_BeginSubCase(c, "Close Free Reset Null");
1338 ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, TEE_HANDLE_NULL));
1339 ADBG_EXPECT_TEEC_SUCCESS(c, fs_free_obj(&sess, TEE_HANDLE_NULL));
1340 ADBG_EXPECT_TEEC_SUCCESS(c, fs_reset_obj(&sess, TEE_HANDLE_NULL));
1341 Do_ADBG_EndSubCase(c, "Close Free Reset Null");
1342
1343 TEEC_CloseSession(&sess);
1344 }
1345 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6010)
1346 ADBG_CASE_DEFINE(regression, 6010, xtest_tee_test_6010, "Test Storage");
1347
xtest_tee_test_6012_single(ADBG_Case_t * c,uint32_t storage_id)1348 static void xtest_tee_test_6012_single(ADBG_Case_t *c, uint32_t storage_id)
1349 {
1350 TEEC_Session sess = { };
1351 uint32_t orig = 0;
1352 uint32_t obj = 0;
1353
1354 /*
1355 * create the object a first time (forced through with overwrite attribute)
1356 */
1357 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1358 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1359 return;
1360
1361 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1362 fs_create_overwrite(&sess, file_04, sizeof(file_04), storage_id)))
1363 goto bail1;
1364
1365 TEEC_CloseSession(&sess);
1366
1367 /*
1368 * re-create the object two times with overwrite attribute
1369 */
1370 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1371 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1372 return;
1373
1374 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1375 fs_create_overwrite(&sess, file_04, sizeof(file_04),
1376 storage_id)))
1377 goto bail1;
1378
1379 /* re-create it with an object */
1380 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1381 fs_create(&sess, file_04, sizeof(file_04),
1382 TEE_DATA_FLAG_ACCESS_WRITE |
1383 TEE_DATA_FLAG_ACCESS_WRITE_META |
1384 TEE_DATA_FLAG_OVERWRITE, 0, NULL, 0, &obj,
1385 storage_id)))
1386 goto bail2;
1387
1388 TEEC_CloseSession(&sess);
1389
1390 /*
1391 * re-create it again without overwrite flag: should fail and
1392 * existing object should not be altered.
1393 */
1394 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1395 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1396 return;
1397
1398 if (!ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_ACCESS_CONFLICT,
1399 fs_create(&sess, file_04, sizeof(file_04),
1400 TEE_DATA_FLAG_ACCESS_WRITE |
1401 TEE_DATA_FLAG_ACCESS_WRITE_META, 0, NULL, 0, &obj,
1402 storage_id)))
1403 goto bail2;
1404
1405 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1406 fs_open(&sess, file_04, sizeof(file_04),
1407 TEE_DATA_FLAG_ACCESS_READ |
1408 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj,
1409 storage_id)))
1410 goto bail1;
1411
1412 bail2:
1413 /* remove the object so that xtest 600x can be replayed */
1414 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj));
1415 bail1:
1416 TEEC_CloseSession(&sess);
1417 }
1418 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6012)
1419 ADBG_CASE_DEFINE(regression, 6012, xtest_tee_test_6012,
1420 "Test TEE GP TTA DS init objects");
1421
xtest_tee_test_6013_single(ADBG_Case_t * c,uint32_t storage_id)1422 static void xtest_tee_test_6013_single(ADBG_Case_t *c, uint32_t storage_id)
1423 {
1424 TEEC_Session sess = { };
1425 uint32_t orig = 0;
1426 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
1427
1428 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1429 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1430 return;
1431
1432 op.params[0].value.a = storage_id;
1433 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
1434 TEEC_NONE, TEEC_NONE);
1435
1436 ADBG_EXPECT_TEEC_SUCCESS(c,
1437 TEEC_InvokeCommand(&sess, TA_STORAGE_CMD_KEY_IN_PERSISTENT,
1438 &op, &orig));
1439
1440 TEEC_CloseSession(&sess);
1441 }
1442 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6013)
1443 ADBG_CASE_DEFINE(regression, 6013, xtest_tee_test_6013,
1444 "Key usage in Persistent objects");
1445
xtest_tee_test_6014_single(ADBG_Case_t * c,uint32_t storage_id)1446 static void xtest_tee_test_6014_single(ADBG_Case_t *c, uint32_t storage_id)
1447 {
1448 TEEC_Session sess = { };
1449 uint32_t orig = 0;
1450 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
1451
1452 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1453 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1454 return;
1455
1456 op.params[0].value.a = storage_id;
1457 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
1458 TEEC_NONE, TEEC_NONE);
1459
1460 ADBG_EXPECT_TEEC_SUCCESS(c,
1461 TEEC_InvokeCommand(&sess, TA_STORAGE_CMD_LOOP, &op, &orig));
1462
1463 TEEC_CloseSession(&sess);
1464 }
1465 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6014)
1466 ADBG_CASE_DEFINE(regression, 6014, xtest_tee_test_6014,
1467 "Loop on Persistent objects");
1468
xtest_tee_test_6015_single(ADBG_Case_t * c,uint32_t storage_id)1469 static void xtest_tee_test_6015_single(ADBG_Case_t *c, uint32_t storage_id)
1470 {
1471 TEEC_Session sess = { };
1472 TEEC_Session sess2 = { };
1473 uint32_t orig = 0;
1474 uint32_t obj = 0;
1475 uint32_t obj2 = 0;
1476
1477 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1478 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1479 return;
1480
1481 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1482 xtest_teec_open_session(&sess2, &storage2_ta_uuid, NULL,
1483 &orig)))
1484 goto exit2;
1485
1486 /* TA #1 creates a persistent object */
1487 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1488 fs_create(&sess, file_01, sizeof(file_01),
1489 TEE_DATA_FLAG_ACCESS_WRITE |
1490 TEE_DATA_FLAG_ACCESS_READ |
1491 TEE_DATA_FLAG_ACCESS_WRITE_META, 0, data_00,
1492 sizeof(data_00), &obj, storage_id)))
1493 goto exit;
1494
1495 /* TA #2 tries to open the object created by TA #1 */
1496 if (!ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_ITEM_NOT_FOUND,
1497 fs_open(&sess2, file_01, sizeof(file_01),
1498 TEE_DATA_FLAG_ACCESS_READ, &obj2, storage_id)))
1499 goto clean;
1500
1501 clean:
1502 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj));
1503 exit:
1504 TEEC_CloseSession(&sess2);
1505 exit2:
1506 TEEC_CloseSession(&sess);
1507 }
1508 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6015)
1509 ADBG_CASE_DEFINE(regression, 6015, xtest_tee_test_6015, "Storage isolation");
1510
1511 struct test_6016_thread_arg {
1512 ADBG_Case_t *case_t;
1513 uint32_t storage_id;
1514 char file_name[8];
1515 TEEC_Session session;
1516 };
1517
test_6016_thread(void * arg)1518 static void *test_6016_thread(void *arg)
1519 {
1520 struct test_6016_thread_arg *a = arg;
1521 TEEC_Session sess = a->session;
1522 uint32_t obj = 0;
1523 uint8_t out[10] = { };
1524 uint32_t count = 0;
1525
1526 /* create */
1527 if (!ADBG_EXPECT_TEEC_SUCCESS(a->case_t,
1528 fs_create(&sess, a->file_name, sizeof(a->file_name),
1529 TEE_DATA_FLAG_ACCESS_WRITE, 0, data_01,
1530 sizeof(data_01), &obj, a->storage_id)))
1531 goto exit;
1532
1533 if (!ADBG_EXPECT_TEEC_SUCCESS(a->case_t, fs_close(&sess, obj)))
1534 goto exit;
1535
1536 /* write new data */
1537 if (!ADBG_EXPECT_TEEC_SUCCESS(a->case_t,
1538 fs_open(&sess, a->file_name, sizeof(a->file_name),
1539 TEE_DATA_FLAG_ACCESS_WRITE, &obj, a->storage_id)))
1540 goto exit;
1541
1542 if (!ADBG_EXPECT_TEEC_SUCCESS(a->case_t,
1543 fs_write(&sess, obj, data_00, sizeof(data_00))))
1544 goto exit;
1545
1546 if (!ADBG_EXPECT_TEEC_SUCCESS(a->case_t, fs_close(&sess, obj)))
1547 goto exit;
1548
1549 /* verify */
1550 if (!ADBG_EXPECT_TEEC_SUCCESS(a->case_t,
1551 fs_open(&sess, a->file_name, sizeof(a->file_name),
1552 TEE_DATA_FLAG_ACCESS_READ |
1553 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj, a->storage_id)))
1554 goto exit;
1555
1556 if (!ADBG_EXPECT_TEEC_SUCCESS(a->case_t,
1557 fs_read(&sess, obj, out, 10, &count)))
1558 goto exit;
1559
1560 (void)ADBG_EXPECT_BUFFER(a->case_t, data_00, 10, out, count);
1561
1562 /* clean */
1563 if (!ADBG_EXPECT_TEEC_SUCCESS(a->case_t, fs_unlink(&sess, obj)))
1564 goto exit;
1565
1566 exit:
1567 return NULL;
1568 }
1569
1570
1571 #define NUM_THREADS 4
xtest_tee_test_6016_loop(ADBG_Case_t * c,uint32_t storage_id)1572 static void xtest_tee_test_6016_loop(ADBG_Case_t *c, uint32_t storage_id)
1573 {
1574 struct test_6016_thread_arg arg[NUM_THREADS] = { };
1575 uint32_t orig = 0;
1576 size_t i = 0;
1577 size_t n = 0;
1578 size_t m = 0;
1579 pthread_t thr[NUM_THREADS] = { };
1580
1581 for (m = 0; m < NUM_THREADS; m++)
1582 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1583 xtest_teec_open_session(&arg[m].session,
1584 &storage_ta_uuid, NULL, &orig)))
1585 goto out;
1586
1587 for (n = 0; n < NUM_THREADS; n++) {
1588 arg[n].case_t = c;
1589 arg[n].storage_id = storage_id;
1590 snprintf(arg[n].file_name, sizeof(arg[n].file_name),
1591 "file_%zu", n);
1592 if (!ADBG_EXPECT(c, 0, pthread_create(thr + n, NULL,
1593 test_6016_thread, arg + n)))
1594 goto out;
1595 }
1596
1597 out:
1598 for (i = 0; i < n; i++)
1599 ADBG_EXPECT(c, 0, pthread_join(thr[i], NULL));
1600 for (i = 0; i < m; i++)
1601 TEEC_CloseSession(&arg[i].session);
1602 }
1603
1604 /* concurency */
xtest_tee_test_6016_single(ADBG_Case_t * c,uint32_t storage_id)1605 static void xtest_tee_test_6016_single(ADBG_Case_t *c, uint32_t storage_id)
1606 {
1607 int i = 0;
1608 int loops = 8;
1609
1610 Do_ADBG_Log(" threads: %d, loops: %d", NUM_THREADS, loops);
1611 for (i = 0; i < loops; i++)
1612 xtest_tee_test_6016_loop(c, storage_id);
1613 }
1614 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6016)
1615 ADBG_CASE_DEFINE(regression, 6016, xtest_tee_test_6016, "Storage concurency");
1616
xtest_tee_test_6017_single(ADBG_Case_t * c,uint32_t storage_id)1617 static void xtest_tee_test_6017_single(ADBG_Case_t *c, uint32_t storage_id)
1618 {
1619 TEEC_Session sess = { };
1620 TEE_ObjectInfo obj_info1 = { };
1621 TEE_ObjectInfo obj_info2 = { };
1622 uint32_t obj = 0;
1623 uint32_t orig = 0;
1624
1625 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1626 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1627 return;
1628
1629 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1630 fs_create(&sess, file_01, sizeof(file_01),
1631 TEE_DATA_FLAG_ACCESS_WRITE, 0, NULL,
1632 0, &obj, storage_id)))
1633 goto exit;
1634
1635 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1636 fs_write(&sess, obj, data_00, sizeof(data_00))))
1637 goto exit;
1638
1639 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1640 fs_get_obj_info(&sess, obj, &obj_info1,
1641 sizeof(TEE_ObjectInfo))))
1642 goto exit;
1643
1644 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
1645 goto exit;
1646
1647 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1648 fs_open(&sess, file_01, sizeof(file_01),
1649 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj, storage_id)))
1650 goto exit;
1651
1652 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1653 fs_get_obj_info(&sess, obj, &obj_info2,
1654 sizeof(TEE_ObjectInfo))))
1655 goto exit;
1656
1657 if (!ADBG_EXPECT_COMPARE_UNSIGNED(c,
1658 obj_info1.dataSize, ==, obj_info2.dataSize))
1659 goto exit;
1660
1661 /* clean */
1662 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj)))
1663 goto exit;
1664
1665 exit:
1666 TEEC_CloseSession(&sess);
1667 }
1668 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6017)
1669 ADBG_CASE_DEFINE(regression, 6017, xtest_tee_test_6017,
1670 "Test Persistent objects info");
1671
xtest_tee_test_6018_single(ADBG_Case_t * c,uint32_t storage_id)1672 static void xtest_tee_test_6018_single(ADBG_Case_t *c, uint32_t storage_id)
1673 {
1674 TEEC_Session sess = { };
1675 TEE_ObjectInfo obj_info1 = { };
1676 TEE_ObjectInfo obj_info2 = { };
1677 uint32_t obj = 0;
1678 uint32_t orig = 0;
1679 uint8_t block[32 * 1024] = { };
1680 size_t num_blocks = 0;
1681 size_t block_size = 0;
1682 size_t n = 0;
1683
1684 if (storage_is(storage_id, TEE_STORAGE_PRIVATE_RPMB)) {
1685 /* RPMB FS is a bit resource constrained */
1686 num_blocks = 10;
1687 block_size = 1024;
1688 } else {
1689 num_blocks = 20;
1690 block_size = sizeof(block);
1691 }
1692
1693 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1694 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1695 return;
1696
1697 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1698 fs_create(&sess, file_01, sizeof(file_01),
1699 TEE_DATA_FLAG_ACCESS_WRITE, 0, NULL,
1700 0, &obj, storage_id)))
1701 goto exit;
1702
1703 for (n = 0; n < num_blocks; n++) {
1704 memset(block, n, block_size);
1705
1706 Do_ADBG_Log("writing %zu", n);
1707 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1708 fs_write(&sess, obj, block, block_size)))
1709 goto exit;
1710 }
1711
1712 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1713 fs_get_obj_info(&sess, obj, &obj_info1,
1714 sizeof(TEE_ObjectInfo))))
1715 goto exit;
1716
1717 if (!ADBG_EXPECT_COMPARE_UNSIGNED(c,
1718 obj_info1.dataSize, ==, block_size * num_blocks))
1719 goto exit;
1720
1721 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
1722 goto exit;
1723
1724 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1725 fs_open(&sess, file_01, sizeof(file_01),
1726 TEE_DATA_FLAG_ACCESS_READ |
1727 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj, storage_id)))
1728 goto exit;
1729
1730 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1731 fs_get_obj_info(&sess, obj, &obj_info2,
1732 sizeof(TEE_ObjectInfo))))
1733 goto exit;
1734
1735 if (!ADBG_EXPECT_COMPARE_UNSIGNED(c,
1736 obj_info1.dataSize, ==, obj_info2.dataSize))
1737 goto exit;
1738
1739 for (n = 0; n < num_blocks; n++) {
1740 uint8_t br[block_size];
1741 uint32_t count = 0;
1742
1743 memset(br, 0, sizeof(br));
1744 memset(block, n, block_size);
1745
1746 Do_ADBG_Log("reading %zu", n);
1747 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1748 fs_read(&sess, obj, br, sizeof(br), &count)))
1749 goto exit;
1750 if (!ADBG_EXPECT_BUFFER(c, block, block_size, br, count))
1751 goto exit;
1752 }
1753
1754 /* clean */
1755 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj)))
1756 goto exit;
1757
1758 exit:
1759 TEEC_CloseSession(&sess);
1760 }
1761 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6018)
1762 ADBG_CASE_DEFINE(regression, 6018, xtest_tee_test_6018, "Large object");
1763
xtest_tee_test_6019_single(ADBG_Case_t * c,uint32_t storage_id)1764 static void xtest_tee_test_6019_single(ADBG_Case_t *c, uint32_t storage_id)
1765 {
1766 TEEC_Session sess = { };
1767 TEEC_Session sess2 = { };
1768 uint32_t orig = 0;
1769 uint32_t obj = 0;
1770 uint32_t obj2 = 0;
1771 uint8_t out[10] = { };
1772 uint32_t count = 0;
1773
1774 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1775 xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig)))
1776 return;
1777
1778 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1779 xtest_teec_open_session(&sess2, &storage2_ta_uuid, NULL,
1780 &orig)))
1781 goto exit3;
1782
1783 /* TA #1 creates a persistent object */
1784 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1785 fs_create(&sess, file_01, sizeof(file_01),
1786 TEE_DATA_FLAG_ACCESS_WRITE |
1787 TEE_DATA_FLAG_ACCESS_WRITE_META |
1788 TEE_DATA_FLAG_OVERWRITE, 0, data_00,
1789 sizeof(data_00), &obj, storage_id)))
1790 goto exit2;
1791
1792 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
1793 goto exit1;
1794
1795 /* TA #2 creates a persistent object */
1796 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1797 fs_create(&sess2, file_01, sizeof(file_01),
1798 TEE_DATA_FLAG_ACCESS_WRITE |
1799 TEE_DATA_FLAG_ACCESS_WRITE_META |
1800 TEE_DATA_FLAG_OVERWRITE, 0, data_01,
1801 sizeof(data_01), &obj2, storage_id)))
1802 goto exit1;
1803
1804 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess2, obj2)))
1805 goto exit;
1806
1807 /* TA #1 open and read */
1808 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1809 fs_open(&sess, file_01, sizeof(file_01),
1810 TEE_DATA_FLAG_ACCESS_READ |
1811 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj, storage_id)))
1812 goto exit;
1813
1814 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_read(&sess, obj, out, 10, &count)))
1815 goto exit;
1816
1817 /* verify */
1818 (void)ADBG_EXPECT_BUFFER(c, data_00, 10, out, count);
1819
1820 /* TA #2 open and read */
1821 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1822 fs_open(&sess2, file_01, sizeof(file_01),
1823 TEE_DATA_FLAG_ACCESS_READ |
1824 TEE_DATA_FLAG_ACCESS_WRITE_META, &obj2, storage_id)))
1825 goto exit;
1826
1827 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_read(&sess2, obj2, out, 10, &count)))
1828 goto exit;
1829
1830 /* verify */
1831 (void)ADBG_EXPECT_BUFFER(c, data_01, 10, out, count);
1832
1833 exit:
1834 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess2, obj2));
1835 exit1:
1836 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj));
1837 exit2:
1838 TEEC_CloseSession(&sess2);
1839 exit3:
1840 TEEC_CloseSession(&sess);
1841 }
1842 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6019)
1843 ADBG_CASE_DEFINE(regression, 6019, xtest_tee_test_6019, "Storage independence");
1844
1845 /*
1846 * According to the GP spec V1.1, the object_id in create/open/rename
1847 * functions is not allowed to reside in the shared memory.
1848 *
1849 * The function below replicates fs_open/fs_create/fs_rename but using
1850 * specific commands to ask the TA to use the client object ID buffer
1851 * from the shared memory when accessing the object through target APIs.
1852 * The TA is not expected to use such references and gets killed by the TEE.
1853 */
fs_access_with_bad_object_id_ref(TEEC_Session * sess,uint32_t command,void * id,uint32_t id_size,uint32_t flags,uint32_t attr,void * data,uint32_t data_size,uint32_t * obj,uint32_t storage_id)1854 static TEEC_Result fs_access_with_bad_object_id_ref(TEEC_Session *sess,
1855 uint32_t command,
1856 void *id, uint32_t id_size,
1857 uint32_t flags,
1858 uint32_t attr,
1859 void *data, uint32_t data_size,
1860 uint32_t *obj,
1861 uint32_t storage_id)
1862 {
1863 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
1864 TEEC_Result res = TEEC_ERROR_GENERIC;
1865 uint32_t org = 0;
1866
1867 switch (command) {
1868 case TA_STORAGE_CMD_OPEN_ID_IN_SHM:
1869 op.params[0].tmpref.buffer = id;
1870 op.params[0].tmpref.size = id_size;
1871 op.params[1].value.a = flags;
1872 op.params[1].value.b = 0;
1873 op.params[2].value.a = storage_id;
1874
1875 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
1876 TEEC_VALUE_INOUT,
1877 TEEC_VALUE_INPUT,
1878 TEEC_NONE);
1879 break;
1880 case TA_STORAGE_CMD_CREATE_ID_IN_SHM:
1881 op.params[0].tmpref.buffer = id;
1882 op.params[0].tmpref.size = id_size;
1883 op.params[1].value.a = flags;
1884 op.params[1].value.b = 0;
1885 op.params[2].value.a = attr;
1886 op.params[2].value.b = storage_id;
1887 op.params[3].tmpref.buffer = data;
1888 op.params[3].tmpref.size = data_size;
1889
1890 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
1891 TEEC_VALUE_INOUT,
1892 TEEC_VALUE_INPUT,
1893 TEEC_MEMREF_TEMP_INPUT);
1894 break;
1895 case TA_STORAGE_CMD_CREATEOVER_ID_IN_SHM:
1896 op.params[0].tmpref.buffer = id;
1897 op.params[0].tmpref.size = id_size;
1898 op.params[1].value.a = storage_id;
1899
1900 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
1901 TEEC_VALUE_INPUT,
1902 TEEC_NONE, TEEC_NONE);
1903 break;
1904 case TA_STORAGE_CMD_RENAME_ID_IN_SHM:
1905 op.params[0].value.a = *obj;
1906 op.params[1].tmpref.buffer = id;
1907 op.params[1].tmpref.size = id_size;
1908
1909 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT,
1910 TEEC_MEMREF_TEMP_INPUT,
1911 TEEC_NONE, TEEC_NONE);
1912 break;
1913 default:
1914 return TEE_ERROR_GENERIC;
1915 }
1916
1917 res = TEEC_InvokeCommand(sess, command, &op, &org);
1918
1919 switch (command) {
1920 case TA_STORAGE_CMD_OPEN_ID_IN_SHM:
1921 case TA_STORAGE_CMD_CREATE_ID_IN_SHM:
1922 if (res == TEEC_SUCCESS)
1923 *obj = op.params[1].value.b;
1924 break;
1925 default:
1926 break;
1927 }
1928
1929 return res;
1930 }
1931
xtest_tee_test_6020_single(ADBG_Case_t * c,uint32_t storage_id)1932 static void xtest_tee_test_6020_single(ADBG_Case_t *c, uint32_t storage_id)
1933 {
1934 TEEC_Result res = TEEC_ERROR_GENERIC;
1935 TEEC_Session sess = { };
1936 uint32_t orig = 0;
1937 uint32_t obj = 0;
1938
1939 /*
1940 * Invalid open request from the TA (object ID reference in SHM)
1941 */
1942 res = xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig);
1943 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
1944 return;
1945
1946 res = fs_create(&sess, file_01, sizeof(file_01),
1947 TEE_DATA_FLAG_ACCESS_WRITE |
1948 TEE_DATA_FLAG_ACCESS_WRITE_META |
1949 TEE_DATA_FLAG_OVERWRITE,
1950 0,
1951 data_00, sizeof(data_00),
1952 &obj,
1953 storage_id);
1954
1955 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
1956 goto exit1;
1957 if (!ADBG_EXPECT_TEEC_SUCCESS(c, fs_close(&sess, obj)))
1958 goto exit1;
1959
1960 res = fs_access_with_bad_object_id_ref(&sess,
1961 TA_STORAGE_CMD_OPEN_ID_IN_SHM,
1962 file_01, sizeof(file_01),
1963 TEE_DATA_FLAG_ACCESS_WRITE |
1964 TEE_DATA_FLAG_ACCESS_WRITE_META,
1965 0,
1966 NULL, 0,
1967 &obj,
1968 storage_id);
1969
1970 ADBG_EXPECT_TEEC_RESULT(c, TEE_ERROR_TARGET_DEAD, res);
1971
1972 /*
1973 * Invalid create-overwrite request from the TA (object ID reference in SHM)
1974 */
1975 TEEC_CloseSession(&sess);
1976 res = xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig);
1977 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
1978 return;
1979
1980 res = fs_access_with_bad_object_id_ref(&sess,
1981 TA_STORAGE_CMD_CREATEOVER_ID_IN_SHM,
1982 file_01, sizeof(file_01),
1983 0,
1984 0,
1985 NULL, 0,
1986 NULL,
1987 storage_id);
1988
1989 ADBG_EXPECT_TEEC_RESULT(c, TEE_ERROR_TARGET_DEAD, res);
1990
1991 /*
1992 * Invalid rename request from the TA (object ID reference in SHM)
1993 */
1994 TEEC_CloseSession(&sess);
1995 res = xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig);
1996 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
1997 return;
1998
1999 res = fs_open(&sess, file_01, sizeof(file_01),
2000 TEE_DATA_FLAG_ACCESS_WRITE |
2001 TEE_DATA_FLAG_ACCESS_WRITE_META,
2002 &obj,
2003 storage_id);
2004
2005 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
2006 goto exit1;
2007
2008 res = fs_access_with_bad_object_id_ref(&sess,
2009 TA_STORAGE_CMD_RENAME_ID_IN_SHM,
2010 file_01, sizeof(file_01) - 1,
2011 0,
2012 0,
2013 NULL, 0,
2014 &obj,
2015 0);
2016
2017 ADBG_EXPECT_TEEC_RESULT(c, TEE_ERROR_TARGET_DEAD, res);
2018
2019 /*
2020 * Invalid creation request from the TA (object ID reference in SHM)
2021 */
2022 TEEC_CloseSession(&sess);
2023 res = xtest_teec_open_session(&sess, &storage_ta_uuid, NULL, &orig);
2024 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
2025 return;
2026
2027 res = fs_open(&sess, file_01, sizeof(file_01),
2028 TEE_DATA_FLAG_ACCESS_WRITE |
2029 TEE_DATA_FLAG_ACCESS_WRITE_META,
2030 &obj,
2031 storage_id);
2032
2033 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
2034 goto exit1;
2035
2036 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj));
2037
2038 res = fs_access_with_bad_object_id_ref(&sess,
2039 TA_STORAGE_CMD_CREATE_ID_IN_SHM,
2040 file_01, sizeof(file_01),
2041 TEE_DATA_FLAG_ACCESS_WRITE |
2042 TEE_DATA_FLAG_ACCESS_WRITE_META |
2043 TEE_DATA_FLAG_OVERWRITE,
2044 0,
2045 data_00, sizeof(data_00),
2046 &obj,
2047 storage_id);
2048
2049 ADBG_EXPECT_TEEC_RESULT(c, TEE_ERROR_TARGET_DEAD, res);
2050 TEEC_CloseSession(&sess);
2051 return;
2052 exit1:
2053 ADBG_EXPECT_TEEC_SUCCESS(c, fs_unlink(&sess, obj));
2054 TEEC_CloseSession(&sess);
2055 }
2056 DEFINE_TEST_MULTIPLE_STORAGE_IDS(xtest_tee_test_6020)
2057 ADBG_CASE_DEFINE(regression, 6020, xtest_tee_test_6020,
2058 "Object IDs in SHM (negative)");
2059