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