blob: 8f31cc23ec1bca7e21626d10cd91895d0a5f04d7 [file] [log] [blame]
Pascal Brandc639ac82015-07-02 08:53:34 +02001/*
2 * Copyright (c) 2014, STMicroelectronics International N.V.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 */
13
Etienne Carrierea4653552017-01-11 10:04:24 +010014#include <limits.h>
15#include <pthread.h>
Pascal Brandc639ac82015-07-02 08:53:34 +020016#include <stdio.h>
Jens Wiklanderec545fb2017-11-24 16:58:07 +010017#include <stdlib.h>
Pascal Brandc639ac82015-07-02 08:53:34 +020018#include <string.h>
David Brownb2865ab2016-08-02 11:44:41 -060019#include <sys/stat.h>
20#include <sys/types.h>
Etienne Carrierea4653552017-01-11 10:04:24 +010021#include <unistd.h>
Pascal Brandc639ac82015-07-02 08:53:34 +020022
23#include "xtest_test.h"
24#include "xtest_helpers.h"
Jens Wiklander4441fe22015-10-23 16:53:02 +020025#include <signed_hdr.h>
Etienne Carriere92c34422018-02-09 13:11:40 +010026#include <util.h>
Pascal Brandc639ac82015-07-02 08:53:34 +020027
Etienne Carriere726d8bc2017-03-21 15:45:59 +010028#include <pta_invoke_tests.h>
Pascal Brandc639ac82015-07-02 08:53:34 +020029#include <ta_crypt.h>
30#include <ta_os_test.h>
31#include <ta_create_fail_test.h>
32#include <ta_rpc_test.h>
33#include <ta_sims_test.h>
Ovidiu Mihalachi15cecff2019-04-02 16:36:31 +030034#include <ta_miss_test.h>
35#include <ta_sims_keepalive_test.h>
Jens Wiklanderac27ec12015-07-15 15:23:14 +020036#include <ta_concurrent.h>
Etienne Carriere50abf9a2017-03-24 11:33:50 +010037#include <sdp_basic.h>
Jens Wiklanderec545fb2017-11-24 16:58:07 +010038#include <pta_secstor_ta_mgmt.h>
Jens Wiklanderec545fb2017-11-24 16:58:07 +010039
40#ifndef MIN
41#define MIN(a, b) ((a) < (b) ? (a) : (b))
42#endif
Pascal Brandc639ac82015-07-02 08:53:34 +020043
Pascal Brandc639ac82015-07-02 08:53:34 +020044struct xtest_crypto_session {
45 ADBG_Case_t *c;
46 TEEC_Session *session;
47 uint32_t cmd_id_sha256;
48 uint32_t cmd_id_aes256ecb_encrypt;
49 uint32_t cmd_id_aes256ecb_decrypt;
50};
51
52static void xtest_crypto_test(struct xtest_crypto_session *cs)
53{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +010054 uint32_t ret_orig = 0;
55 uint8_t crypt_out[16] = { };
Pascal Brandc639ac82015-07-02 08:53:34 +020056 uint8_t crypt_in[16] = { 22, 17 };
57
58 crypt_in[15] = 60;
59
60 Do_ADBG_BeginSubCase(cs->c, "AES encrypt");
61 {
62 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
63
64 op.params[0].tmpref.buffer = crypt_in;
65 op.params[0].tmpref.size = sizeof(crypt_in);
66 op.params[1].tmpref.buffer = crypt_out;
67 op.params[1].tmpref.size = sizeof(crypt_out);
68 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
69 TEEC_MEMREF_TEMP_OUTPUT,
70 TEEC_NONE, TEEC_NONE);
71
72 (void)ADBG_EXPECT_TEEC_SUCCESS(cs->c,
73 TEEC_InvokeCommand(cs->session,
74 cs->
75 cmd_id_aes256ecb_encrypt,
76 &op,
77 &ret_orig));
78 }
79 Do_ADBG_EndSubCase(cs->c, "AES encrypt");
80
81 Do_ADBG_BeginSubCase(cs->c, "AES decrypt");
82 {
83 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +010084 uint8_t out[16] = { };
Pascal Brandc639ac82015-07-02 08:53:34 +020085
86 op.params[0].tmpref.buffer = crypt_out;
87 op.params[0].tmpref.size = sizeof(crypt_out);
88 op.params[1].tmpref.buffer = out;
89 op.params[1].tmpref.size = sizeof(out);
90 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
91 TEEC_MEMREF_TEMP_OUTPUT,
92 TEEC_NONE, TEEC_NONE);
93
94 (void)ADBG_EXPECT_TEEC_SUCCESS(cs->c,
95 TEEC_InvokeCommand(cs->session,
96 cs->
97 cmd_id_aes256ecb_decrypt,
98 &op,
99 &ret_orig));
100
101 if (!ADBG_EXPECT(cs->c, 0,
102 memcmp(crypt_in, out, sizeof(crypt_in)))) {
103 Do_ADBG_Log("crypt_in:");
104 Do_ADBG_HexLog(crypt_in, sizeof(crypt_in), 16);
105 Do_ADBG_Log("out:");
106 Do_ADBG_HexLog(out, sizeof(out), 16);
107 }
108 }
109 Do_ADBG_EndSubCase(cs->c, "AES decrypt");
110
111 Do_ADBG_BeginSubCase(cs->c, "SHA-256 test, 3 bytes input");
112 {
113 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
114 static const uint8_t sha256_in[] = { 'a', 'b', 'c' };
115 static const uint8_t sha256_out[] = {
116 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
117 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23,
118 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
119 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad
120 };
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100121 uint8_t out[32] = { };
Pascal Brandc639ac82015-07-02 08:53:34 +0200122
123 op.params[0].tmpref.buffer = (void *)sha256_in;
124 op.params[0].tmpref.size = sizeof(sha256_in);
125 op.params[1].tmpref.buffer = out;
126 op.params[1].tmpref.size = sizeof(out);
127 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
128 TEEC_MEMREF_TEMP_OUTPUT,
129 TEEC_NONE, TEEC_NONE);
130
131 (void)ADBG_EXPECT_TEEC_SUCCESS(cs->c,
132 TEEC_InvokeCommand(cs->session,
133 cs->
134 cmd_id_sha256,
135 &op,
136 &ret_orig));
137
138 if (!ADBG_EXPECT(cs->c, 0, memcmp(sha256_out, out,
139 sizeof(sha256_out)))) {
140 Do_ADBG_Log("sha256_out:");
141 Do_ADBG_HexLog(sha256_out, sizeof(sha256_out), 16);
142 Do_ADBG_Log("out:");
143 Do_ADBG_HexLog(out, sizeof(out), 16);
144 }
145 }
146 Do_ADBG_EndSubCase(cs->c, "SHA-256 test, 3 bytes input");
147
Etienne Carrierea3198522017-10-26 09:48:55 +0200148 Do_ADBG_BeginSubCase(cs->c, "AES-256 ECB encrypt (32B, fixed key)");
Pascal Brandc639ac82015-07-02 08:53:34 +0200149 {
150 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
151 static const uint8_t in[] = {
152 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
153 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
154 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
155 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
156 };
157 static const uint8_t exp_out[] = {
158 0x5A, 0x6E, 0x04, 0x57, 0x08, 0xFB, 0x71, 0x96,
159 0xF0, 0x2E, 0x55, 0x3D, 0x02, 0xC3, 0xA6, 0x92,
160 0xE9, 0xC3, 0xEF, 0x8A, 0xB2, 0x34, 0x53, 0xE6,
161 0xF0, 0x74, 0x9C, 0xD6, 0x36, 0xE7, 0xA8, 0x8E
162 };
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100163 uint8_t out[sizeof(exp_out)] = { };
Pascal Brandc639ac82015-07-02 08:53:34 +0200164
165 op.params[0].tmpref.buffer = (void *)in;
166 op.params[0].tmpref.size = sizeof(in);
167 op.params[1].tmpref.buffer = out;
168 op.params[1].tmpref.size = sizeof(out);
169 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
170 TEEC_MEMREF_TEMP_OUTPUT,
171 TEEC_NONE, TEEC_NONE);
172
173 (void)ADBG_EXPECT_TEEC_SUCCESS(cs->c,
174 TEEC_InvokeCommand(cs->session,
175 cs->
176 cmd_id_aes256ecb_encrypt,
177 &op,
178 &ret_orig));
179
180 if (!ADBG_EXPECT(cs->c, 0,
181 memcmp(exp_out, out, sizeof(exp_out)))) {
182 Do_ADBG_Log("exp_out:");
183 Do_ADBG_HexLog(exp_out, sizeof(exp_out), 16);
184 Do_ADBG_Log("out:");
185 Do_ADBG_HexLog(out, sizeof(out), 16);
186 }
187 }
Etienne Carrierea3198522017-10-26 09:48:55 +0200188 Do_ADBG_EndSubCase(cs->c, "AES-256 ECB encrypt (32B, fixed key)");
Pascal Brandc639ac82015-07-02 08:53:34 +0200189
Etienne Carrierea3198522017-10-26 09:48:55 +0200190 Do_ADBG_BeginSubCase(cs->c, "AES-256 ECB decrypt (32B, fixed key)");
Pascal Brandc639ac82015-07-02 08:53:34 +0200191 {
192 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
193 static const uint8_t in[] = {
194 0x5A, 0x6E, 0x04, 0x57, 0x08, 0xFB, 0x71, 0x96,
195 0xF0, 0x2E, 0x55, 0x3D, 0x02, 0xC3, 0xA6, 0x92,
196 0xE9, 0xC3, 0xEF, 0x8A, 0xB2, 0x34, 0x53, 0xE6,
197 0xF0, 0x74, 0x9C, 0xD6, 0x36, 0xE7, 0xA8, 0x8E
198 };
199 static const uint8_t exp_out[] = {
200 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
201 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
202 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
203 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
204 };
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100205 uint8_t out[sizeof(exp_out)] = { };
Pascal Brandc639ac82015-07-02 08:53:34 +0200206
207 op.params[0].tmpref.buffer = (void *)in;
208 op.params[0].tmpref.size = sizeof(in);
209 op.params[1].tmpref.buffer = out;
210 op.params[1].tmpref.size = sizeof(out);
211 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
212 TEEC_MEMREF_TEMP_OUTPUT,
213 TEEC_NONE, TEEC_NONE);
214
215 (void)ADBG_EXPECT_TEEC_SUCCESS(cs->c,
216 TEEC_InvokeCommand(cs->session,
217 cs->
218 cmd_id_aes256ecb_decrypt,
219 &op,
220 &ret_orig));
221
222 if (!ADBG_EXPECT(cs->c, 0,
223 memcmp(exp_out, out, sizeof(exp_out)))) {
224 Do_ADBG_Log("exp_out:");
225 Do_ADBG_HexLog(exp_out, sizeof(exp_out), 16);
226 Do_ADBG_Log("out:");
227 Do_ADBG_HexLog(out, sizeof(out), 16);
228 }
229 }
Etienne Carrierea3198522017-10-26 09:48:55 +0200230 Do_ADBG_EndSubCase(cs->c, "AES-256 ECB decrypt (32B, fixed key)");
Pascal Brandc639ac82015-07-02 08:53:34 +0200231}
232
233static void xtest_tee_test_1001(ADBG_Case_t *c)
234{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100235 TEEC_Result res = TEEC_ERROR_GENERIC;
236 TEEC_Session session = { };
237 uint32_t ret_orig = 0;
Pascal Brandc639ac82015-07-02 08:53:34 +0200238
Etienne Carriere11093162017-10-26 09:49:04 +0200239 /* Pseudo TA is optional: warn and nicely exit if not found */
Etienne Carriere726d8bc2017-03-21 15:45:59 +0100240 res = xtest_teec_open_session(&session, &pta_invoke_tests_ta_uuid, NULL,
Jens Wiklandercf16e842016-02-10 09:07:09 +0100241 &ret_orig);
Etienne Carriere11093162017-10-26 09:49:04 +0200242 if (res == TEEC_ERROR_ITEM_NOT_FOUND) {
243 Do_ADBG_Log(" - 1001 - skip test, pseudo TA not found");
Jens Wiklandercf16e842016-02-10 09:07:09 +0100244 return;
Etienne Carriere11093162017-10-26 09:49:04 +0200245 }
246 ADBG_EXPECT_TEEC_SUCCESS(c, res);
Pascal Brandc639ac82015-07-02 08:53:34 +0200247
Jens Wiklandercf16e842016-02-10 09:07:09 +0100248 (void)ADBG_EXPECT_TEEC_SUCCESS(c, TEEC_InvokeCommand(
Etienne Carriere726d8bc2017-03-21 15:45:59 +0100249 &session, PTA_INVOKE_TESTS_CMD_SELF_TESTS, NULL, &ret_orig));
Jens Wiklandercf16e842016-02-10 09:07:09 +0100250 TEEC_CloseSession(&session);
Pascal Brandc639ac82015-07-02 08:53:34 +0200251}
Jens Wiklander14f48872018-06-29 15:30:13 +0200252ADBG_CASE_DEFINE(regression, 1001, xtest_tee_test_1001, "Core self tests");
Pascal Brandc639ac82015-07-02 08:53:34 +0200253
Jens Wiklander1d70a112017-10-16 15:16:39 +0200254static void xtest_tee_test_1002(ADBG_Case_t *c)
255{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100256 TEEC_Result res = TEEC_ERROR_GENERIC;
257 TEEC_Session session = { };
Jens Wiklander1d70a112017-10-16 15:16:39 +0200258 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100259 uint32_t ret_orig = 0;
260 uint8_t buf[16 * 1024] = { };
Jens Wiklander1d70a112017-10-16 15:16:39 +0200261 uint8_t exp_sum = 0;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100262 size_t n = 0;
Jens Wiklander1d70a112017-10-16 15:16:39 +0200263
Etienne Carriere11093162017-10-26 09:49:04 +0200264 /* Pseudo TA is optional: warn and nicely exit if not found */
Jens Wiklander1d70a112017-10-16 15:16:39 +0200265 res = xtest_teec_open_session(&session, &pta_invoke_tests_ta_uuid, NULL,
266 &ret_orig);
Etienne Carriere11093162017-10-26 09:49:04 +0200267 if (res == TEEC_ERROR_ITEM_NOT_FOUND) {
268 Do_ADBG_Log(" - 1002 - skip test, pseudo TA not found");
Jens Wiklander1d70a112017-10-16 15:16:39 +0200269 return;
Etienne Carriere11093162017-10-26 09:49:04 +0200270 }
271 ADBG_EXPECT_TEEC_SUCCESS(c, res);
Jens Wiklander1d70a112017-10-16 15:16:39 +0200272
273 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, TEEC_NONE,
274 TEEC_NONE, TEEC_NONE);
275 op.params[0].tmpref.size = sizeof(buf);
276 op.params[0].tmpref.buffer = buf;
277
278 for (n = 0; n < sizeof(buf); n++)
279 buf[n] = n + 1;
280 for (n = 0; n < sizeof(buf); n++)
281 exp_sum += buf[n];
282
283 if (!ADBG_EXPECT_TEEC_SUCCESS(c, TEEC_InvokeCommand(
284 &session, PTA_INVOKE_TESTS_CMD_PARAMS, &op, &ret_orig)))
285 goto out;
286
287 ADBG_EXPECT_COMPARE_SIGNED(c, exp_sum, ==, buf[0]);
288out:
289 TEEC_CloseSession(&session);
290}
Jens Wiklander14f48872018-06-29 15:30:13 +0200291ADBG_CASE_DEFINE(regression, 1002, xtest_tee_test_1002, "PTA parameters");
Jens Wiklander1d70a112017-10-16 15:16:39 +0200292
Jens Wiklander0c86bc32017-11-13 19:52:03 +0100293struct test_1003_arg {
294 uint32_t test_type;
295 size_t repeat;
296 size_t max_before_lockers;
297 size_t max_during_lockers;
298 size_t before_lockers;
299 size_t during_lockers;
300 TEEC_Result res;
301 uint32_t error_orig;
302};
Jens Wiklander1d70a112017-10-16 15:16:39 +0200303
Jens Wiklander0c86bc32017-11-13 19:52:03 +0100304static void *test_1003_thread(void *arg)
305{
306 struct test_1003_arg *a = arg;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100307 TEEC_Session session = { };
Jens Wiklander0c86bc32017-11-13 19:52:03 +0100308 size_t rounds = 64 * 1024;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100309 size_t n = 0;
Jens Wiklander0c86bc32017-11-13 19:52:03 +0100310
311 a->res = xtest_teec_open_session(&session, &pta_invoke_tests_ta_uuid,
312 NULL, &a->error_orig);
313 if (a->res != TEEC_SUCCESS)
314 return NULL;
315
316 for (n = 0; n < a->repeat; n++) {
317 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
318
319 op.params[0].value.a = a->test_type;
320 op.params[0].value.b = rounds;
321
322 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT,
323 TEEC_VALUE_OUTPUT,
324 TEEC_NONE, TEEC_NONE);
325 a->res = TEEC_InvokeCommand(&session,
326 PTA_INVOKE_TESTS_CMD_MUTEX,
327 &op, &a->error_orig);
328 if (a->test_type == PTA_MUTEX_TEST_WRITER &&
329 op.params[1].value.b != 1) {
330 Do_ADBG_Log("n %zu %" PRIu32, n, op.params[1].value.b);
331 a->res = TEEC_ERROR_BAD_STATE;
332 a->error_orig = 42;
333 break;
334 }
335
336 if (a->test_type == PTA_MUTEX_TEST_READER) {
337 if (op.params[1].value.a > a->max_before_lockers)
338 a->max_before_lockers = op.params[1].value.a;
339
340 if (op.params[1].value.b > a->max_during_lockers)
341 a->max_during_lockers = op.params[1].value.b;
342
343 a->before_lockers += op.params[1].value.a;
344 a->during_lockers += op.params[1].value.b;
345 }
346 }
347 TEEC_CloseSession(&session);
348
349 return NULL;
350}
351
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100352#define TEST_1003_THREAD_COUNT (3 * 2)
353
Jens Wiklander0c86bc32017-11-13 19:52:03 +0100354static void xtest_tee_test_1003(ADBG_Case_t *c)
355{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100356 TEEC_Result res = TEEC_ERROR_GENERIC;
357 TEEC_Session session = { };
358 uint32_t ret_orig = 0;
Jens Wiklander0c86bc32017-11-13 19:52:03 +0100359 size_t repeat = 20;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100360 struct test_1003_arg arg[TEST_1003_THREAD_COUNT] = { };
Jens Wiklander0c86bc32017-11-13 19:52:03 +0100361 size_t max_read_concurrency = 0;
362 size_t max_read_waiters = 0;
363 size_t num_concurrent_read_lockers = 0;
364 size_t num_concurrent_read_waiters = 0;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100365 size_t n = 0;
366 size_t nt = TEST_1003_THREAD_COUNT;
367 double mean_read_concurrency = 0;
368 double mean_read_waiters = 0;
Jens Wiklander0c86bc32017-11-13 19:52:03 +0100369 size_t num_writers = 0;
370 size_t num_readers = 0;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100371 pthread_t thr[TEST_1003_THREAD_COUNT] = { };
Jens Wiklander0c86bc32017-11-13 19:52:03 +0100372
373 /* Pseudo TA is optional: warn and nicely exit if not found */
374 res = xtest_teec_open_session(&session, &pta_invoke_tests_ta_uuid, NULL,
375 &ret_orig);
376 if (res == TEEC_ERROR_ITEM_NOT_FOUND) {
377 Do_ADBG_Log(" - 1003 - skip test, pseudo TA not found");
378 return;
379 }
380 ADBG_EXPECT_TEEC_SUCCESS(c, res);
381 TEEC_CloseSession(&session);
382
Jens Wiklander0c86bc32017-11-13 19:52:03 +0100383 for (n = 0; n < nt; n++) {
384 if (n % 3) {
385 arg[n].test_type = PTA_MUTEX_TEST_READER;
386 num_readers++;
387 } else {
388 arg[n].test_type = PTA_MUTEX_TEST_WRITER;
389 num_writers++;
390 }
391 arg[n].repeat = repeat;
392 if (!ADBG_EXPECT(c, 0, pthread_create(thr + n, NULL,
393 test_1003_thread, arg + n)))
394 nt = n; /* break loop and start cleanup */
395 }
396
397 for (n = 0; n < nt; n++) {
398 ADBG_EXPECT(c, 0, pthread_join(thr[n], NULL));
399 if (!ADBG_EXPECT_TEEC_SUCCESS(c, arg[n].res))
400 Do_ADBG_Log("error origin %" PRIu32,
401 arg[n].error_orig);
402 if (arg[n].test_type == PTA_MUTEX_TEST_READER) {
403 if (arg[n].max_during_lockers > max_read_concurrency)
404 max_read_concurrency =
405 arg[n].max_during_lockers;
406
407 if (arg[n].max_before_lockers > max_read_waiters)
408 max_read_waiters = arg[n].max_before_lockers;
409
410 num_concurrent_read_lockers += arg[n].during_lockers;
411 num_concurrent_read_waiters += arg[n].before_lockers;
412 }
413 }
414
415 mean_read_concurrency = (double)num_concurrent_read_lockers /
416 (double)(repeat * num_readers);
417 mean_read_waiters = (double)num_concurrent_read_waiters /
418 (double)(repeat * num_readers);
419
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100420 Do_ADBG_Log(" Number of parallel threads: %d (%zu writers and %zu readers)",
421 TEST_1003_THREAD_COUNT, num_writers, num_readers);
Jens Wiklander0c86bc32017-11-13 19:52:03 +0100422 Do_ADBG_Log(" Max read concurrency: %zu", max_read_concurrency);
423 Do_ADBG_Log(" Max read waiters: %zu", max_read_waiters);
424 Do_ADBG_Log(" Mean read concurrency: %g", mean_read_concurrency);
425 Do_ADBG_Log(" Mean read waiting: %g", mean_read_waiters);
426}
Jens Wiklander14f48872018-06-29 15:30:13 +0200427ADBG_CASE_DEFINE(regression, 1003, xtest_tee_test_1003,
428 "Core internal read/write mutex");
Jens Wiklander1d70a112017-10-16 15:16:39 +0200429
Pascal Brandc639ac82015-07-02 08:53:34 +0200430static void xtest_tee_test_1004(ADBG_Case_t *c)
431{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100432 TEEC_Session session = { };
433 uint32_t ret_orig = 0;
Pascal Brandc639ac82015-07-02 08:53:34 +0200434 struct xtest_crypto_session cs = { c, &session, TA_CRYPT_CMD_SHA256,
435 TA_CRYPT_CMD_AES256ECB_ENC,
436 TA_CRYPT_CMD_AES256ECB_DEC };
437
438 if (!ADBG_EXPECT_TEEC_SUCCESS(c, xtest_teec_open_session(
439 &session, &crypt_user_ta_uuid,
440 NULL, &ret_orig)))
441 return;
442
443 /* Run the "complete crypto test suite" */
444 xtest_crypto_test(&cs);
445
446 TEEC_CloseSession(&session);
447}
Jens Wiklander14f48872018-06-29 15:30:13 +0200448ADBG_CASE_DEFINE(regression, 1004, xtest_tee_test_1004, "Test User Crypt TA");
Pascal Brandc639ac82015-07-02 08:53:34 +0200449
Etienne Carriere92c34422018-02-09 13:11:40 +0100450static void xtest_tee_test_invalid_mem_access(ADBG_Case_t *c, unsigned int n)
Pascal Brandc639ac82015-07-02 08:53:34 +0200451{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100452 TEEC_Session session = { };
Pascal Brandc639ac82015-07-02 08:53:34 +0200453 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100454 uint32_t ret_orig = 0;
Pascal Brandc639ac82015-07-02 08:53:34 +0200455
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300456 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
Pascal Brandc639ac82015-07-02 08:53:34 +0200457 xtest_teec_open_session(&session, &os_test_ta_uuid, NULL,
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300458 &ret_orig)))
459 return;
Pascal Brandc639ac82015-07-02 08:53:34 +0200460
461 op.params[0].value.a = n;
462 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE, TEEC_NONE,
463 TEEC_NONE);
464
465 (void)ADBG_EXPECT_TEEC_RESULT(c,
466 TEEC_ERROR_TARGET_DEAD,
467 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_BAD_MEM_ACCESS, &op,
468 &ret_orig));
469
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300470 (void)ADBG_EXPECT_TEEC_RESULT(c,
471 TEEC_ERROR_TARGET_DEAD,
472 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_BAD_MEM_ACCESS, &op,
Pascal Brandc639ac82015-07-02 08:53:34 +0200473 &ret_orig));
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300474
Pascal Brandc639ac82015-07-02 08:53:34 +0200475 (void)ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TEE, ret_orig);
476
477 TEEC_CloseSession(&session);
478}
479
Etienne Carriere92c34422018-02-09 13:11:40 +0100480static void xtest_tee_test_invalid_mem_access2(ADBG_Case_t *c, unsigned int n,
481 size_t size)
482{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100483 TEEC_Session session = { };
Etienne Carriere92c34422018-02-09 13:11:40 +0100484 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100485 uint32_t ret_orig = 0;
486 TEEC_SharedMemory shm = { };
Etienne Carriere92c34422018-02-09 13:11:40 +0100487
Etienne Carriere92c34422018-02-09 13:11:40 +0100488 shm.size = size;
489 shm.flags = TEEC_MEM_INPUT | TEEC_MEM_OUTPUT;
490 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
491 TEEC_AllocateSharedMemory(&xtest_teec_ctx, &shm)))
492 return;
493
494 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
495 xtest_teec_open_session(&session, &os_test_ta_uuid, NULL,
496 &ret_orig)))
Jens Wiklander6987a822019-06-28 12:47:42 +0200497 goto rel_shm;
Etienne Carriere92c34422018-02-09 13:11:40 +0100498
499 op.params[0].value.a = (uint32_t)n;
500 op.params[1].memref.parent = &shm;
501 op.params[1].memref.size = size;
502 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_MEMREF_WHOLE,
503 TEEC_NONE, TEEC_NONE);
504
505 (void)ADBG_EXPECT_TEEC_RESULT(c,
506 TEEC_ERROR_TARGET_DEAD,
507 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_BAD_MEM_ACCESS, &op,
508 &ret_orig));
509
510 (void)ADBG_EXPECT_TEEC_RESULT(c,
511 TEEC_ERROR_TARGET_DEAD,
512 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_BAD_MEM_ACCESS, &op,
513 &ret_orig));
514
515 (void)ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TEE, ret_orig);
516
517 TEEC_CloseSession(&session);
Jens Wiklander6987a822019-06-28 12:47:42 +0200518rel_shm:
519 TEEC_ReleaseSharedMemory(&shm);
Etienne Carriere92c34422018-02-09 13:11:40 +0100520}
521
Pascal Brandc639ac82015-07-02 08:53:34 +0200522static void xtest_tee_test_1005(ADBG_Case_t *c)
523{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100524 uint32_t ret_orig = 0;
Pascal Brandc639ac82015-07-02 08:53:34 +0200525#define MAX_SESSIONS 3
526 TEEC_Session sessions[MAX_SESSIONS];
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100527 int i = 0;
Pascal Brandc639ac82015-07-02 08:53:34 +0200528
529 for (i = 0; i < MAX_SESSIONS; i++) {
530 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
Jens Wiklandereb6bce72016-09-23 11:37:33 +0200531 xtest_teec_open_session(&sessions[i],
532 &concurrent_ta_uuid,
Pascal Brandc639ac82015-07-02 08:53:34 +0200533 NULL, &ret_orig)))
534 break;
535 }
536
537 for (; --i >= 0; )
538 TEEC_CloseSession(&sessions[i]);
539}
Jens Wiklander14f48872018-06-29 15:30:13 +0200540ADBG_CASE_DEFINE(regression, 1005, xtest_tee_test_1005, "Many sessions");
Pascal Brandc639ac82015-07-02 08:53:34 +0200541
542static void xtest_tee_test_1006(ADBG_Case_t *c)
543{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100544 TEEC_Session session = { };
545 uint32_t ret_orig = 0;
Pascal Brandc639ac82015-07-02 08:53:34 +0200546 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100547 uint8_t buf[32] = { };
Pascal Brandc639ac82015-07-02 08:53:34 +0200548
549 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
550 xtest_teec_open_session(&session, &os_test_ta_uuid, NULL,
551 &ret_orig)))
552 return;
553
554 op.params[0].tmpref.buffer = buf;
555 op.params[0].tmpref.size = sizeof(buf);
556 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_NONE,
557 TEEC_NONE, TEEC_NONE);
558
559 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
560 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_BASIC, &op,
561 &ret_orig));
562
563 TEEC_CloseSession(&session);
564}
Jens Wiklander14f48872018-06-29 15:30:13 +0200565ADBG_CASE_DEFINE(regression, 1006, xtest_tee_test_1006,
566 "Test Basic OS features");
Pascal Brandc639ac82015-07-02 08:53:34 +0200567
568static void xtest_tee_test_1007(ADBG_Case_t *c)
569{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100570 TEEC_Session session = { };
571 uint32_t ret_orig = 0;
Pascal Brandc639ac82015-07-02 08:53:34 +0200572
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300573 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
Pascal Brandc639ac82015-07-02 08:53:34 +0200574 xtest_teec_open_session(&session, &os_test_ta_uuid, NULL,
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300575 &ret_orig)))
576 return;
Pascal Brandc639ac82015-07-02 08:53:34 +0200577
578 (void)ADBG_EXPECT_TEEC_RESULT(c,
579 TEEC_ERROR_TARGET_DEAD,
580 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_PANIC, NULL,
581 &ret_orig));
582
583 (void)ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TEE, ret_orig);
584
585 (void)ADBG_EXPECT_TEEC_RESULT(c,
586 TEEC_ERROR_TARGET_DEAD,
587 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_INIT, NULL,
588 &ret_orig));
589
590 (void)ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TEE, ret_orig);
591
592 TEEC_CloseSession(&session);
593}
Jens Wiklander14f48872018-06-29 15:30:13 +0200594ADBG_CASE_DEFINE(regression, 1007, xtest_tee_test_1007, "Test Panic");
Pascal Brandc639ac82015-07-02 08:53:34 +0200595
Jerome Forissierf02a2212015-10-29 14:33:35 +0100596#ifndef TA_DIR
Victor Chong3d8798f2017-03-01 18:31:48 +0000597# ifdef __ANDROID__
Yongqin Liu286f1fc2018-06-21 22:09:15 +0800598#define TA_DIR "/vendor/lib/optee_armtz"
Victor Chong3d8798f2017-03-01 18:31:48 +0000599# else
Jerome Forissierf02a2212015-10-29 14:33:35 +0100600#define TA_DIR "/lib/optee_armtz"
Victor Chong3d8798f2017-03-01 18:31:48 +0000601# endif
Jerome Forissierf02a2212015-10-29 14:33:35 +0100602#endif
603
Jens Wiklanderec545fb2017-11-24 16:58:07 +0100604static FILE *open_ta_file(const TEEC_UUID *uuid, const char *mode)
David Brownb2865ab2016-08-02 11:44:41 -0600605{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100606 char buf[PATH_MAX] = { };
David Brownb2865ab2016-08-02 11:44:41 -0600607
Jens Wiklanderec545fb2017-11-24 16:58:07 +0100608 snprintf(buf, sizeof(buf),
Jens Wiklander6203b872016-12-08 19:18:29 +0100609 "%s/%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x.ta",
Jens Wiklanderec545fb2017-11-24 16:58:07 +0100610 TA_DIR, uuid->timeLow, uuid->timeMid, uuid->timeHiAndVersion,
Jens Wiklanderb7940892015-10-23 16:02:40 +0200611 uuid->clockSeqAndNode[0], uuid->clockSeqAndNode[1],
612 uuid->clockSeqAndNode[2], uuid->clockSeqAndNode[3],
613 uuid->clockSeqAndNode[4], uuid->clockSeqAndNode[5],
David Brownb2865ab2016-08-02 11:44:41 -0600614 uuid->clockSeqAndNode[6], uuid->clockSeqAndNode[7]);
Jens Wiklanderb7940892015-10-23 16:02:40 +0200615
Jens Wiklanderb7940892015-10-23 16:02:40 +0200616 return fopen(buf, mode);
617}
618
Jens Wiklanderec545fb2017-11-24 16:58:07 +0100619static bool load_corrupt_ta(ADBG_Case_t *c, size_t offs, uint8_t mask)
Jens Wiklander4441fe22015-10-23 16:53:02 +0200620{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100621 TEEC_Session session = { };
Jens Wiklanderec545fb2017-11-24 16:58:07 +0100622 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
623 TEEC_UUID uuid = PTA_SECSTOR_TA_MGMT_UUID;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100624 TEEC_Result res = TEEC_ERROR_GENERIC;
625 uint32_t ret_orig = 0;
Jens Wiklanderec545fb2017-11-24 16:58:07 +0100626 FILE *f = NULL;
627 bool r = false;
628 uint8_t *buf = NULL;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100629 size_t sz = 0;
630 size_t fread_res = 0;
Jens Wiklander4441fe22015-10-23 16:53:02 +0200631
Jens Wiklanderec545fb2017-11-24 16:58:07 +0100632 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
633 xtest_teec_open_session(&session, &uuid, NULL, &ret_orig)))
634 goto out;
Jens Wiklander4441fe22015-10-23 16:53:02 +0200635
Jens Wiklanderec545fb2017-11-24 16:58:07 +0100636 f = open_ta_file(&create_fail_test_ta_uuid, "rb");
637 if (!ADBG_EXPECT_NOT_NULL(c, f))
638 goto out;
639 if (!ADBG_EXPECT_TRUE(c, !fseek(f, 0, SEEK_END)))
640 goto out;
641 sz = ftell(f);
642 rewind(f);
643
644 buf = malloc(sz);
645 if (!ADBG_EXPECT_NOT_NULL(c, buf))
646 goto out;
647
648 fread_res = fread(buf, 1, sz, f);
649 if (!ADBG_EXPECT_COMPARE_UNSIGNED(c, fread_res, ==, sz))
650 goto out;
651
Jens Wiklander4441fe22015-10-23 16:53:02 +0200652 fclose(f);
Jens Wiklanderec545fb2017-11-24 16:58:07 +0100653 f = NULL;
Jens Wiklander4441fe22015-10-23 16:53:02 +0200654
Jens Wiklanderec545fb2017-11-24 16:58:07 +0100655 buf[MIN(offs, sz)] ^= mask;
Jens Wiklander4441fe22015-10-23 16:53:02 +0200656
Jens Wiklanderec545fb2017-11-24 16:58:07 +0100657 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_NONE,
658 TEEC_NONE, TEEC_NONE);
659 op.params[0].tmpref.buffer = buf;
660 op.params[0].tmpref.size = sz;
661
662 res = TEEC_InvokeCommand(&session, PTA_SECSTOR_TA_MGMT_BOOTSTRAP, &op,
663 &ret_orig);
664 r = ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_SECURITY, res);
665out:
666 free(buf);
667 if (f)
668 fclose(f);
669 TEEC_CloseSession(&session);
Jens Wiklander4441fe22015-10-23 16:53:02 +0200670 return r;
671}
Jens Wiklandere1a201d2020-02-12 18:36:20 +0100672
673static void test_1008_corrupt_ta(ADBG_Case_t *c)
674{
675 TEEC_UUID uuid = PTA_SECSTOR_TA_MGMT_UUID;
676 TEEC_Result res = TEEC_ERROR_GENERIC;
677 TEEC_Session session = { };
678 uint32_t ret_orig = 0;
679
680 res = xtest_teec_open_session(&session, &uuid, NULL, &ret_orig);
681 if (res) {
682 if (ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_ITEM_NOT_FOUND,
683 res))
684 Do_ADBG_Log("PTA Secure Storage TA Managment not found: skip test");
685 return;
686 }
687 TEEC_CloseSession(&session);
688
689 ADBG_EXPECT_TRUE(c,
690 load_corrupt_ta(c, offsetof(struct shdr, magic), 1));
691 ADBG_EXPECT_TRUE(c,
692 load_corrupt_ta(c, offsetof(struct shdr, img_type), 1));
693 ADBG_EXPECT_TRUE(c,
694 load_corrupt_ta(c, offsetof(struct shdr, img_size), 1));
695 ADBG_EXPECT_TRUE(c,
696 load_corrupt_ta(c, offsetof(struct shdr, algo), 1));
697 ADBG_EXPECT_TRUE(c,
698 load_corrupt_ta(c, offsetof(struct shdr, hash_size), 1));
699 ADBG_EXPECT_TRUE(c,
700 load_corrupt_ta(c, offsetof(struct shdr, sig_size), 1));
701 ADBG_EXPECT_TRUE(c,
702 load_corrupt_ta(c, sizeof(struct shdr), 1)); /* hash */
703 ADBG_EXPECT_TRUE(c,
704 load_corrupt_ta(c, sizeof(struct shdr) + 32, 1)); /* sig */
705 ADBG_EXPECT_TRUE(c, load_corrupt_ta(c, 3000, 1)); /* payload */
706 ADBG_EXPECT_TRUE(c, load_corrupt_ta(c, 8000, 1)); /* payload */
707}
Jens Wiklander4441fe22015-10-23 16:53:02 +0200708
Pascal Brandc639ac82015-07-02 08:53:34 +0200709static void xtest_tee_test_1008(ADBG_Case_t *c)
710{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100711 TEEC_Session session = { };
712 TEEC_Session session_crypt = { };
713 uint32_t ret_orig = 0;
Pascal Brandc639ac82015-07-02 08:53:34 +0200714
715 Do_ADBG_BeginSubCase(c, "Invoke command");
716 {
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300717 if (ADBG_EXPECT_TEEC_SUCCESS(c,
Pascal Brandc639ac82015-07-02 08:53:34 +0200718 xtest_teec_open_session(&session, &os_test_ta_uuid,
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300719 NULL, &ret_orig))) {
Pascal Brandc639ac82015-07-02 08:53:34 +0200720
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300721 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
722 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_CLIENT,
723 NULL, &ret_orig));
724 TEEC_CloseSession(&session);
725 }
Pascal Brandc639ac82015-07-02 08:53:34 +0200726
Pascal Brandc639ac82015-07-02 08:53:34 +0200727 }
728 Do_ADBG_EndSubCase(c, "Invoke command");
729
730 Do_ADBG_BeginSubCase(c, "Invoke command with timeout");
731 {
732 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
733
734 op.params[0].value.a = 2000;
735 op.paramTypes = TEEC_PARAM_TYPES(
736 TEEC_VALUE_INPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
737
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300738 if (ADBG_EXPECT_TEEC_SUCCESS(c,
Pascal Brandc639ac82015-07-02 08:53:34 +0200739 xtest_teec_open_session(&session,
740 &os_test_ta_uuid,
741 NULL,
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300742 &ret_orig))) {
Pascal Brandc639ac82015-07-02 08:53:34 +0200743
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300744 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
745 TEEC_InvokeCommand(&session,
746 TA_OS_TEST_CMD_CLIENT_WITH_TIMEOUT,
747 &op, &ret_orig));
748 TEEC_CloseSession(&session);
749 }
Pascal Brandc639ac82015-07-02 08:53:34 +0200750 }
751 Do_ADBG_EndSubCase(c, "Invoke command with timeout");
752
753 Do_ADBG_BeginSubCase(c, "Create session fail");
754 {
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100755 size_t n = 0;
Jens Wiklanderb7940892015-10-23 16:02:40 +0200756
Pascal Brandc639ac82015-07-02 08:53:34 +0200757 (void)ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_GENERIC,
758 xtest_teec_open_session(&session_crypt,
759 &create_fail_test_ta_uuid, NULL,
760 &ret_orig));
Pascal Brandc639ac82015-07-02 08:53:34 +0200761 /*
762 * Run this several times to see that there's no memory leakage.
763 */
764 for (n = 0; n < 100; n++) {
765 Do_ADBG_Log("n = %zu", n);
766 (void)ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_GENERIC,
767 xtest_teec_open_session(&session_crypt,
768 &create_fail_test_ta_uuid,
769 NULL, &ret_orig));
770 }
771 }
772 Do_ADBG_EndSubCase(c, "Create session fail");
Jens Wiklanderb7940892015-10-23 16:02:40 +0200773
Jens Wiklander4441fe22015-10-23 16:53:02 +0200774 Do_ADBG_BeginSubCase(c, "Load corrupt TA");
Jens Wiklandere1a201d2020-02-12 18:36:20 +0100775 test_1008_corrupt_ta(c);
Jens Wiklander4441fe22015-10-23 16:53:02 +0200776 Do_ADBG_EndSubCase(c, "Load corrupt TA");
Pascal Brandc639ac82015-07-02 08:53:34 +0200777}
Jens Wiklander14f48872018-06-29 15:30:13 +0200778ADBG_CASE_DEFINE(regression, 1008, xtest_tee_test_1008,
779 "TEE internal client API");
Pascal Brandc639ac82015-07-02 08:53:34 +0200780
Pascal Brandc639ac82015-07-02 08:53:34 +0200781static void *cancellation_thread(void *arg)
782{
783 /*
784 * Sleep 0.5 seconds before cancellation to make sure that the other
785 * thread is in RPC_WAIT.
786 */
787 (void)usleep(500000);
788 TEEC_RequestCancellation(arg);
789 return NULL;
790}
Pascal Brandc639ac82015-07-02 08:53:34 +0200791
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300792static void xtest_tee_test_1009_subcase(ADBG_Case_t *c, const char *subcase,
793 uint32_t timeout, bool cancel)
Pascal Brandc639ac82015-07-02 08:53:34 +0200794{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100795 TEEC_Session session = { };
796 uint32_t ret_orig = 0;
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300797 pthread_t thr;
Pascal Brandc639ac82015-07-02 08:53:34 +0200798
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100799 memset(&thr, 0, sizeof(thr));
800
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300801 Do_ADBG_BeginSubCase(c, "%s", subcase);
Pascal Brandc639ac82015-07-02 08:53:34 +0200802 {
803 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
804
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300805 if (ADBG_EXPECT_TEEC_SUCCESS(c,
806 xtest_teec_open_session(&session, &os_test_ta_uuid,
807 NULL, &ret_orig))) {
Pascal Brandc639ac82015-07-02 08:53:34 +0200808
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300809 (void)ADBG_EXPECT_TEEC_ERROR_ORIGIN(c,
810 TEEC_ORIGIN_TRUSTED_APP,
811 ret_orig);
Pascal Brandc639ac82015-07-02 08:53:34 +0200812
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300813 op.params[0].value.a = timeout;
814 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT,
815 TEEC_NONE,
816 TEEC_NONE, TEEC_NONE);
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300817 if (cancel) {
818 (void)ADBG_EXPECT(c, 0,
819 pthread_create(&thr, NULL,
820 cancellation_thread, &op));
Pascal Brandc639ac82015-07-02 08:53:34 +0200821
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300822 (void)ADBG_EXPECT_TEEC_RESULT(c,
823 TEEC_ERROR_CANCEL,
824 TEEC_InvokeCommand(&session,
825 TA_OS_TEST_CMD_WAIT,
826 &op,
827 &ret_orig));
828 } else
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300829
830 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
831 TEEC_InvokeCommand(&session,
832 TA_OS_TEST_CMD_WAIT,
833 &op,
834 &ret_orig));
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300835 if (cancel)
836 (void)ADBG_EXPECT(c, 0, pthread_join(thr, NULL));
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300837
838 TEEC_CloseSession(&session);
839 }
Pascal Brandc639ac82015-07-02 08:53:34 +0200840 }
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300841 Do_ADBG_EndSubCase(c, "%s", subcase);
842}
843
844static void xtest_tee_test_1009(ADBG_Case_t *c)
845{
846 xtest_tee_test_1009_subcase(c, "TEE Wait 0.1s", 100, false);
847 xtest_tee_test_1009_subcase(c, "TEE Wait 0.5s", 500, false);
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300848 xtest_tee_test_1009_subcase(c, "TEE Wait 2s cancel", 2000, true);
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300849 xtest_tee_test_1009_subcase(c, "TEE Wait 2s", 2000, false);
Pascal Brandc639ac82015-07-02 08:53:34 +0200850}
Jens Wiklander14f48872018-06-29 15:30:13 +0200851ADBG_CASE_DEFINE(regression, 1009, xtest_tee_test_1009, "TEE Wait");
Pascal Brandc639ac82015-07-02 08:53:34 +0200852
853static void xtest_tee_test_1010(ADBG_Case_t *c)
854{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100855 unsigned int n = 0;
856 unsigned int idx = 0;
Etienne Carriere92c34422018-02-09 13:11:40 +0100857 size_t memref_sz[] = { 1024, 65536 };
Pascal Brandc639ac82015-07-02 08:53:34 +0200858
859 for (n = 1; n <= 5; n++) {
860 Do_ADBG_BeginSubCase(c, "Invalid memory access %u", n);
861 xtest_tee_test_invalid_mem_access(c, n);
862 Do_ADBG_EndSubCase(c, "Invalid memory access %u", n);
863 }
Etienne Carriere92c34422018-02-09 13:11:40 +0100864
865 for (idx = 0; idx < ARRAY_SIZE(memref_sz); idx++) {
866 for (n = 1; n <= 5; n++) {
867 Do_ADBG_BeginSubCase(c,
Igor Opaniuke8236ac2018-02-12 12:26:25 +0200868 "Invalid memory access %u with %zu bytes memref",
Etienne Carriere92c34422018-02-09 13:11:40 +0100869 n, memref_sz[idx]);
870 xtest_tee_test_invalid_mem_access2(c, n, memref_sz[idx]);
871 Do_ADBG_EndSubCase(c,
Igor Opaniuke8236ac2018-02-12 12:26:25 +0200872 "Invalid memory access %u with %zu bytes memref",
Etienne Carriere92c34422018-02-09 13:11:40 +0100873 n, memref_sz[idx]);
874 }
875 }
Pascal Brandc639ac82015-07-02 08:53:34 +0200876}
Jens Wiklander14f48872018-06-29 15:30:13 +0200877ADBG_CASE_DEFINE(regression, 1010, xtest_tee_test_1010,
878 "Invalid memory access");
Pascal Brandc639ac82015-07-02 08:53:34 +0200879
880static void xtest_tee_test_1011(ADBG_Case_t *c)
881{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100882 TEEC_Session session = { };
883 uint32_t ret_orig = 0;
Pascal Brandc639ac82015-07-02 08:53:34 +0200884 struct xtest_crypto_session cs = {
885 c, &session, TA_RPC_CMD_CRYPT_SHA256,
886 TA_RPC_CMD_CRYPT_AES256ECB_ENC,
887 TA_RPC_CMD_CRYPT_AES256ECB_DEC
888 };
Jens Wiklanderf7b9c632017-01-03 17:32:26 +0100889 struct xtest_crypto_session cs_privmem = {
890 c, &session,
891 TA_RPC_CMD_CRYPT_PRIVMEM_SHA256,
892 TA_RPC_CMD_CRYPT_PRIVMEM_AES256ECB_ENC,
893 TA_RPC_CMD_CRYPT_PRIVMEM_AES256ECB_DEC
894 };
Pascal Brandc639ac82015-07-02 08:53:34 +0200895 TEEC_UUID uuid = rpc_test_ta_uuid;
896
897 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
898 xtest_teec_open_session(&session, &uuid, NULL, &ret_orig)))
899 return;
900
Jens Wiklanderf7b9c632017-01-03 17:32:26 +0100901 Do_ADBG_BeginSubCase(c, "TA-to-TA via non-secure shared memory");
Pascal Brandc639ac82015-07-02 08:53:34 +0200902 /*
Jens Wiklanderf7b9c632017-01-03 17:32:26 +0100903 * Run the "complete crypto test suite" using TA-to-TA
904 * communication
Pascal Brandc639ac82015-07-02 08:53:34 +0200905 */
906 xtest_crypto_test(&cs);
Jens Wiklanderf7b9c632017-01-03 17:32:26 +0100907 Do_ADBG_EndSubCase(c, "TA-to-TA via non-secure shared memory");
908
909 Do_ADBG_BeginSubCase(c, "TA-to-TA via TA private memory");
910 /*
911 * Run the "complete crypto test suite" using TA-to-TA
912 * communication via TA private memory.
913 */
914 xtest_crypto_test(&cs_privmem);
915 Do_ADBG_EndSubCase(c, "TA-to-TA via TA private memory");
916
Pascal Brandc639ac82015-07-02 08:53:34 +0200917 TEEC_CloseSession(&session);
918}
Jens Wiklander14f48872018-06-29 15:30:13 +0200919ADBG_CASE_DEFINE(regression, 1011, xtest_tee_test_1011,
920 "Test TA-to-TA features with User Crypt TA");
Pascal Brandc639ac82015-07-02 08:53:34 +0200921
922/*
923 * Note that this test is failing when
924 * - running twice in a raw
925 * - and the user TA is statically linked
926 * This is because the counter is not reseted when opening the first session
927 * in case the TA is statically linked
928 */
929static void xtest_tee_test_1012(ADBG_Case_t *c)
930{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100931 TEEC_Session session1 = { };
932 TEEC_Session session2 = { };
933 uint32_t ret_orig = 0;
Pascal Brandc639ac82015-07-02 08:53:34 +0200934 TEEC_UUID uuid = sims_test_ta_uuid;
935
936 Do_ADBG_BeginSubCase(c, "Single Instance Multi Session");
937 {
938 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
939 static const uint8_t in[] = {
940 0x5A, 0x6E, 0x04, 0x57, 0x08, 0xFB, 0x71, 0x96,
941 0xF0, 0x2E, 0x55, 0x3D, 0x02, 0xC3, 0xA6, 0x92,
942 0xE9, 0xC3, 0xEF, 0x8A, 0xB2, 0x34, 0x53, 0xE6,
943 0xF0, 0x74, 0x9C, 0xD6, 0x36, 0xE7, 0xA8, 0x8E
944 };
Etienne Carrieree4ec9e42019-03-28 13:30:21 +0100945 uint8_t out[32] = { };
946 int i = 0;
Pascal Brandc639ac82015-07-02 08:53:34 +0200947
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300948 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
Pascal Brandc639ac82015-07-02 08:53:34 +0200949 xtest_teec_open_session(&session1, &uuid, NULL,
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300950 &ret_orig)))
951 return;
Pascal Brandc639ac82015-07-02 08:53:34 +0200952
953 op.params[0].value.a = 0;
954 op.params[1].tmpref.buffer = (void *)in;
955 op.params[1].tmpref.size = sizeof(in);
956 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT,
957 TEEC_MEMREF_TEMP_INPUT,
958 TEEC_NONE, TEEC_NONE);
959
960 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
961 TEEC_InvokeCommand(&session1, TA_SIMS_CMD_WRITE, &op,
962 &ret_orig));
963
Jerome Forissier3cc0a422017-12-14 09:53:24 +0100964 for (i = 1; i < 3; i++) {
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300965 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
Pascal Brandc639ac82015-07-02 08:53:34 +0200966 xtest_teec_open_session(&session2, &uuid, NULL,
Volodymyr Babchukae3dcd72016-10-20 16:51:59 +0300967 &ret_orig)))
968 continue;
Pascal Brandc639ac82015-07-02 08:53:34 +0200969
970 op.params[0].value.a = 0;
971 op.params[1].tmpref.buffer = out;
972 op.params[1].tmpref.size = sizeof(out);
973 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT,
974 TEEC_MEMREF_TEMP_OUTPUT,
975 TEEC_NONE, TEEC_NONE);
976
977 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
978 TEEC_InvokeCommand(&session2, TA_SIMS_CMD_READ,
979 &op, &ret_orig));
980
981 if (!ADBG_EXPECT_BUFFER(c, in, sizeof(in), out,
982 sizeof(out))) {
983 Do_ADBG_Log("in:");
984 Do_ADBG_HexLog(in, sizeof(in), 16);
985 Do_ADBG_Log("out:");
986 Do_ADBG_HexLog(out, sizeof(out), 16);
987 }
988
989 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_OUTPUT,
990 TEEC_NONE, TEEC_NONE,
991 TEEC_NONE);
992
993 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
994 TEEC_InvokeCommand(&session1,
995 TA_SIMS_CMD_GET_COUNTER,
996 &op, &ret_orig));
997
998 (void)ADBG_EXPECT(c, 0, op.params[0].value.a);
999
1000 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
1001 TEEC_InvokeCommand(&session2,
1002 TA_SIMS_CMD_GET_COUNTER, &op,
1003 &ret_orig));
1004
1005 (void)ADBG_EXPECT(c, i, op.params[0].value.a);
1006 TEEC_CloseSession(&session2);
1007 }
1008
1009 memset(out, 0, sizeof(out));
1010 op.params[0].value.a = 0;
1011 op.params[1].tmpref.buffer = out;
1012 op.params[1].tmpref.size = sizeof(out);
1013 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT,
1014 TEEC_MEMREF_TEMP_OUTPUT,
1015 TEEC_NONE, TEEC_NONE);
1016
1017 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
1018 TEEC_InvokeCommand(&session1, TA_SIMS_CMD_READ, &op,
1019 &ret_orig));
1020
1021 if (!ADBG_EXPECT(c, 0, memcmp(in, out, sizeof(in)))) {
1022 Do_ADBG_Log("in:");
1023 Do_ADBG_HexLog(in, sizeof(in), 16);
1024 Do_ADBG_Log("out:");
1025 Do_ADBG_HexLog(out, sizeof(out), 16);
1026 }
1027
1028 TEEC_CloseSession(&session1);
1029 }
Ovidiu Mihalachi3e6183e2019-04-25 10:23:21 +03001030 Do_ADBG_EndSubCase(c, "Single Instance Multi Session");
Pascal Brandc639ac82015-07-02 08:53:34 +02001031}
Jens Wiklander14f48872018-06-29 15:30:13 +02001032ADBG_CASE_DEFINE(regression, 1012, xtest_tee_test_1012,
1033 "Test Single Instance Multi Session features with SIMS TA");
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001034
1035struct test_1013_thread_arg {
Jens Wiklander70672972016-04-06 00:01:45 +02001036 const TEEC_UUID *uuid;
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001037 uint32_t cmd;
1038 uint32_t repeat;
1039 TEEC_SharedMemory *shm;
1040 uint32_t error_orig;
1041 TEEC_Result res;
1042 uint32_t max_concurrency;
1043 const uint8_t *in;
1044 size_t in_len;
1045 uint8_t *out;
1046 size_t out_len;
1047};
1048
1049static void *test_1013_thread(void *arg)
1050{
1051 struct test_1013_thread_arg *a = arg;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001052 TEEC_Session session = { };
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001053 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
1054 uint8_t p2 = TEEC_NONE;
1055 uint8_t p3 = TEEC_NONE;
1056
Jens Wiklander70672972016-04-06 00:01:45 +02001057 a->res = xtest_teec_open_session(&session, a->uuid, NULL,
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001058 &a->error_orig);
1059 if (a->res != TEEC_SUCCESS)
1060 return NULL;
1061
1062 op.params[0].memref.parent = a->shm;
1063 op.params[0].memref.size = a->shm->size;
1064 op.params[0].memref.offset = 0;
1065 op.params[1].value.a = a->repeat;
1066 op.params[1].value.b = 0;
1067 op.params[2].tmpref.buffer = (void *)a->in;
1068 op.params[2].tmpref.size = a->in_len;
1069 op.params[3].tmpref.buffer = a->out;
1070 op.params[3].tmpref.size = a->out_len;
1071
1072 if (a->in_len)
1073 p2 = TEEC_MEMREF_TEMP_INPUT;
1074 if (a->out_len)
1075 p3 = TEEC_MEMREF_TEMP_OUTPUT;
1076
1077 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT,
1078 TEEC_VALUE_INOUT, p2, p3);
1079
1080 a->res = TEEC_InvokeCommand(&session, a->cmd, &op, &a->error_orig);
1081 a->max_concurrency = op.params[1].value.b;
1082 a->out_len = op.params[3].tmpref.size;
1083 TEEC_CloseSession(&session);
1084 return NULL;
1085}
1086
Pascal Brand4fa35582015-12-17 10:59:12 +01001087#define NUM_THREADS 3
1088
Jens Wiklander70672972016-04-06 00:01:45 +02001089static void xtest_tee_test_1013_single(ADBG_Case_t *c, double *mean_concurrency,
1090 const TEEC_UUID *uuid)
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001091{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001092 size_t nt = 0;
1093 size_t n = 0;
Jens Wiklander70672972016-04-06 00:01:45 +02001094 size_t repeat = 1000;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001095 TEEC_SharedMemory shm = { };
1096 size_t max_concurrency = 0;
1097 struct test_1013_thread_arg arg[NUM_THREADS] = { };
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001098 static const uint8_t sha256_in[] = { 'a', 'b', 'c' };
1099 static const uint8_t sha256_out[] = {
1100 0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
1101 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23,
1102 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
1103 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad
1104 };
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001105 uint8_t out[32] = { };
1106 pthread_t thr[NUM_THREADS] = { };
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001107
Jens Wiklander70672972016-04-06 00:01:45 +02001108 Do_ADBG_BeginSubCase(c, "Busy loop repeat %zu", repeat * 10);
Pascal Brand4fa35582015-12-17 10:59:12 +01001109 *mean_concurrency = 0;
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001110
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001111 shm.size = sizeof(struct ta_concurrent_shm);
1112 shm.flags = TEEC_MEM_INPUT | TEEC_MEM_OUTPUT;
1113 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1114 TEEC_AllocateSharedMemory(&xtest_teec_ctx, &shm)))
1115 return;
1116
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001117 memset(shm.buffer, 0, shm.size);
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001118 max_concurrency = 0;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001119 nt = NUM_THREADS;
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001120
1121 for (n = 0; n < nt; n++) {
Jens Wiklander70672972016-04-06 00:01:45 +02001122 arg[n].uuid = uuid;
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001123 arg[n].cmd = TA_CONCURRENT_CMD_BUSY_LOOP;
Jens Wiklander70672972016-04-06 00:01:45 +02001124 arg[n].repeat = repeat * 10;
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001125 arg[n].shm = &shm;
1126 if (!ADBG_EXPECT(c, 0, pthread_create(thr + n, NULL,
1127 test_1013_thread, arg + n)))
1128 nt = n; /* break loop and start cleanup */
1129 }
1130
1131 for (n = 0; n < nt; n++) {
1132 ADBG_EXPECT(c, 0, pthread_join(thr[n], NULL));
1133 ADBG_EXPECT_TEEC_SUCCESS(c, arg[n].res);
1134 if (arg[n].max_concurrency > max_concurrency)
1135 max_concurrency = arg[n].max_concurrency;
1136 }
1137
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001138 /*
1139 * Concurrency can be limited by several factors, for instance in a
1140 * single CPU system it's dependent on the Preemtion Model used by
1141 * the kernel (Preemptible Kernel (Low-Latency Desktop) gives the
1142 * best result there).
1143 */
1144 (void)ADBG_EXPECT_COMPARE_UNSIGNED(c, max_concurrency, >, 0);
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001145 (void)ADBG_EXPECT_COMPARE_UNSIGNED(c, max_concurrency, <=, NUM_THREADS);
Pascal Brand4fa35582015-12-17 10:59:12 +01001146 *mean_concurrency += max_concurrency;
Jens Wiklander70672972016-04-06 00:01:45 +02001147 Do_ADBG_EndSubCase(c, "Busy loop repeat %zu", repeat * 10);
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001148
Jens Wiklander70672972016-04-06 00:01:45 +02001149 Do_ADBG_BeginSubCase(c, "SHA-256 loop repeat %zu", repeat);
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001150 memset(shm.buffer, 0, shm.size);
1151 memset(arg, 0, sizeof(arg));
1152 max_concurrency = 0;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001153 nt = NUM_THREADS;
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001154
1155 for (n = 0; n < nt; n++) {
Jens Wiklander70672972016-04-06 00:01:45 +02001156 arg[n].uuid = uuid;
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001157 arg[n].cmd = TA_CONCURRENT_CMD_SHA256;
Jens Wiklander70672972016-04-06 00:01:45 +02001158 arg[n].repeat = repeat;
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001159 arg[n].shm = &shm;
1160 arg[n].in = sha256_in;
1161 arg[n].in_len = sizeof(sha256_in);
1162 arg[n].out = out;
1163 arg[n].out_len = sizeof(out);
1164 if (!ADBG_EXPECT(c, 0, pthread_create(thr + n, NULL,
1165 test_1013_thread, arg + n)))
1166 nt = n; /* break loop and start cleanup */
1167 }
1168
1169 for (n = 0; n < nt; n++) {
1170 if (ADBG_EXPECT(c, 0, pthread_join(thr[n], NULL)) &&
1171 ADBG_EXPECT_TEEC_SUCCESS(c, arg[n].res))
1172 ADBG_EXPECT_BUFFER(c, sha256_out, sizeof(sha256_out),
1173 arg[n].out, arg[n].out_len);
1174 if (arg[n].max_concurrency > max_concurrency)
1175 max_concurrency = arg[n].max_concurrency;
1176 }
Pascal Brand4fa35582015-12-17 10:59:12 +01001177 *mean_concurrency += max_concurrency;
Jens Wiklander70672972016-04-06 00:01:45 +02001178 Do_ADBG_EndSubCase(c, "SHA-256 loop repeat %zu", repeat);
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001179
Pascal Brand4fa35582015-12-17 10:59:12 +01001180 *mean_concurrency /= 2.0;
Jens Wiklanderac27ec12015-07-15 15:23:14 +02001181 TEEC_ReleaseSharedMemory(&shm);
1182}
Pascal Brand4fa35582015-12-17 10:59:12 +01001183
1184static void xtest_tee_test_1013(ADBG_Case_t *c)
1185{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001186 int i = 0;
1187 double mean_concurrency = 0;
1188 double concurrency = 0;
Jens Wiklander70672972016-04-06 00:01:45 +02001189 int nb_loops = 24;
Jens Wiklander6a9d15a2016-02-01 10:29:42 +01001190
1191 if (level == 0)
1192 nb_loops /= 2;
Pascal Brand4fa35582015-12-17 10:59:12 +01001193
Jens Wiklander70672972016-04-06 00:01:45 +02001194 Do_ADBG_BeginSubCase(c, "Using small concurrency TA");
Pascal Brand4fa35582015-12-17 10:59:12 +01001195 mean_concurrency = 0;
1196 for (i = 0; i < nb_loops; i++) {
Jens Wiklander70672972016-04-06 00:01:45 +02001197 xtest_tee_test_1013_single(c, &concurrency,
1198 &concurrent_ta_uuid);
Pascal Brand4fa35582015-12-17 10:59:12 +01001199 mean_concurrency += concurrency;
1200 }
1201 mean_concurrency /= nb_loops;
1202
1203 Do_ADBG_Log(" Number of parallel threads: %d", NUM_THREADS);
1204 Do_ADBG_Log(" Mean concurrency: %g", mean_concurrency);
Jens Wiklander70672972016-04-06 00:01:45 +02001205 Do_ADBG_EndSubCase(c, "Using small concurrency TA");
Pascal Brand4fa35582015-12-17 10:59:12 +01001206
Jens Wiklanderc9d7b242016-06-28 18:35:08 +02001207#ifndef CFG_PAGED_USER_TA
Jens Wiklander70672972016-04-06 00:01:45 +02001208 Do_ADBG_BeginSubCase(c, "Using large concurrency TA");
1209 mean_concurrency = 0;
1210 for (i = 0; i < nb_loops; i++) {
1211 xtest_tee_test_1013_single(c, &concurrency,
1212 &concurrent_large_ta_uuid);
1213 mean_concurrency += concurrency;
1214 }
1215 mean_concurrency /= nb_loops;
1216
1217 Do_ADBG_Log(" Number of parallel threads: %d", NUM_THREADS);
1218 Do_ADBG_Log(" Mean concurrency: %g", mean_concurrency);
1219 Do_ADBG_EndSubCase(c, "Using large concurrency TA");
Jens Wiklanderc9d7b242016-06-28 18:35:08 +02001220#endif
Jens Wiklander70672972016-04-06 00:01:45 +02001221}
Jens Wiklander14f48872018-06-29 15:30:13 +02001222ADBG_CASE_DEFINE(regression, 1013, xtest_tee_test_1013,
1223 "Test concurency with concurrent TA");
Etienne Carriere50abf9a2017-03-24 11:33:50 +01001224
1225#ifdef CFG_SECURE_DATA_PATH
1226static void xtest_tee_test_1014(ADBG_Case_t *c)
1227{
1228 UNUSED(c);
1229
1230 int size = 17000;
1231 int loop = 10;
1232 int ion_heap = DEFAULT_ION_HEAP_TYPE;
1233 int rnd_offset = 1;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001234 int test = 0;
1235 int ret = 0;
Etienne Carriere50abf9a2017-03-24 11:33:50 +01001236
1237 test = TEST_NS_TO_TA;
1238 Do_ADBG_BeginSubCase(c, "SDP: NonSecure client invokes a SDP TA");
Etienne Carriereb9a95822017-04-26 15:03:53 +02001239 ret = sdp_basic_test(test, size, loop, ion_heap, rnd_offset, 0);
Etienne Carriere50abf9a2017-03-24 11:33:50 +01001240 ADBG_EXPECT(c, 0, ret);
1241 Do_ADBG_EndSubCase(c, "SDP: NonSecure client invokes a SDP TA");
1242
1243 test = TEST_TA_TO_TA;
1244 Do_ADBG_BeginSubCase(c, "SDP: SDP TA invokes a SDP TA");
Etienne Carriereb9a95822017-04-26 15:03:53 +02001245 ret = sdp_basic_test(test, size, loop, ion_heap, rnd_offset, 0);
Etienne Carriere50abf9a2017-03-24 11:33:50 +01001246 ADBG_EXPECT(c, 0, ret);
1247 Do_ADBG_EndSubCase(c, "SDP: SDP TA invokes a SDP TA");
1248
1249 test = TEST_TA_TO_PTA;
1250 Do_ADBG_BeginSubCase(c, "SDP: SDP TA invokes a SDP pTA");
Etienne Carriereb9a95822017-04-26 15:03:53 +02001251 ret = sdp_basic_test(test, size, loop, ion_heap, rnd_offset, 0);
Etienne Carriere50abf9a2017-03-24 11:33:50 +01001252 ADBG_EXPECT(c, 0, ret);
1253 Do_ADBG_EndSubCase(c, "SDP: SDP TA invokes a SDP pTA");
1254
1255 test = TEST_NS_TO_PTA;
Etienne Carrierea3198522017-10-26 09:48:55 +02001256 Do_ADBG_BeginSubCase(c, "SDP: NSec CA invokes SDP pTA (should fail)");
Etienne Carriereb9a95822017-04-26 15:03:53 +02001257 ret = sdp_basic_test(test, size, loop, ion_heap, rnd_offset, 0);
Etienne Carriere50abf9a2017-03-24 11:33:50 +01001258 ADBG_EXPECT(c, 1, ret);
Etienne Carrierea3198522017-10-26 09:48:55 +02001259 Do_ADBG_EndSubCase(c, "SDP: NSec CA invokes SDP pTA (should fail)");
Etienne Carriere50abf9a2017-03-24 11:33:50 +01001260}
Jens Wiklander14f48872018-06-29 15:30:13 +02001261ADBG_CASE_DEFINE(regression, 1014, xtest_tee_test_1014,
1262 "Test secure data path against SDP TAs and pTAs");
1263#endif /*CFG_SECURE_DATA_PATH*/
Jens Wiklander272d3642017-04-03 13:03:47 +02001264
1265static void xtest_tee_test_1015(ADBG_Case_t *c)
1266{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001267 TEEC_Result res = TEEC_ERROR_GENERIC;
1268 TEEC_Session session = { };
1269 uint32_t ret_orig = 0;
Jens Wiklander272d3642017-04-03 13:03:47 +02001270
Etienne Carriere11093162017-10-26 09:49:04 +02001271 /* Pseudo TA is optional: warn and nicely exit if not found */
Jens Wiklander272d3642017-04-03 13:03:47 +02001272 res = xtest_teec_open_session(&session, &pta_invoke_tests_ta_uuid, NULL,
1273 &ret_orig);
Etienne Carriere11093162017-10-26 09:49:04 +02001274 if (res == TEEC_ERROR_ITEM_NOT_FOUND) {
1275 Do_ADBG_Log(" - 1015 - skip test, pseudo TA not found");
Jens Wiklander272d3642017-04-03 13:03:47 +02001276 return;
Etienne Carriere11093162017-10-26 09:49:04 +02001277 }
1278 ADBG_EXPECT_TEEC_SUCCESS(c, res);
Jens Wiklander272d3642017-04-03 13:03:47 +02001279
1280 ADBG_EXPECT_TEEC_SUCCESS(c,
1281 TEEC_InvokeCommand(&session, PTA_INVOKE_TESTS_CMD_FS_HTREE,
1282 NULL, &ret_orig));
1283 TEEC_CloseSession(&session);
1284}
Jens Wiklander14f48872018-06-29 15:30:13 +02001285ADBG_CASE_DEFINE(regression, 1015, xtest_tee_test_1015,
1286 "FS hash-tree corner cases");
Jerome Forissiere916b102017-06-07 17:55:52 +02001287
1288static void xtest_tee_test_1016(ADBG_Case_t *c)
1289{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001290 TEEC_Session session = { };
Jerome Forissiere916b102017-06-07 17:55:52 +02001291 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001292 uint32_t ret_orig = 0;
Jerome Forissiere916b102017-06-07 17:55:52 +02001293
1294 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1295 xtest_teec_open_session(&session, &os_test_ta_uuid, NULL,
1296 &ret_orig)))
1297 return;
1298
1299 op.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_NONE, TEEC_NONE,
1300 TEEC_NONE);
1301
1302 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
1303 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_TA2TA_MEMREF, &op,
1304 &ret_orig));
1305
1306 TEEC_CloseSession(&session);
1307}
Jens Wiklander14f48872018-06-29 15:30:13 +02001308ADBG_CASE_DEFINE(regression, 1016, xtest_tee_test_1016,
1309 "Test TA to TA transfers (in/out/inout memrefs on the stack)");
Jens Wiklander87e81702018-03-20 12:00:00 +08001310
1311static void xtest_tee_test_1017(ADBG_Case_t *c)
1312{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001313 TEEC_Session session = { };
Jens Wiklander87e81702018-03-20 12:00:00 +08001314 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001315 uint32_t ret_orig = 0;
1316 TEEC_SharedMemory shm = { };
Jens Wiklander87e81702018-03-20 12:00:00 +08001317 size_t page_size = 4096;
1318
Jens Wiklander87e81702018-03-20 12:00:00 +08001319 shm.size = 8 * page_size;
1320 shm.flags = TEEC_MEM_INPUT | TEEC_MEM_OUTPUT;
1321 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1322 TEEC_AllocateSharedMemory(&xtest_teec_ctx, &shm)))
1323 return;
1324
1325 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1326 xtest_teec_open_session(&session, &os_test_ta_uuid, NULL,
1327 &ret_orig)))
1328 goto out;
1329
1330 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INPUT,
1331 TEEC_MEMREF_PARTIAL_INPUT,
1332 TEEC_MEMREF_PARTIAL_OUTPUT,
1333 TEEC_MEMREF_PARTIAL_OUTPUT);
1334
1335 /*
1336 * The first two memrefs are supposed to be combined into in
1337 * region and the last two memrefs should have one region each
1338 * when the parameters are mapped for the TA.
1339 */
1340 op.params[0].memref.parent = &shm;
1341 op.params[0].memref.size = page_size;
1342 op.params[0].memref.offset = 0;
1343
1344 op.params[1].memref.parent = &shm;
1345 op.params[1].memref.size = page_size;
1346 op.params[1].memref.offset = page_size;
1347
1348 op.params[2].memref.parent = &shm;
1349 op.params[2].memref.size = page_size;
1350 op.params[2].memref.offset = 4 * page_size;
1351
1352 op.params[3].memref.parent = &shm;
1353 op.params[3].memref.size = 2 * page_size;
1354 op.params[3].memref.offset = 6 * page_size;
1355
1356 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
1357 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_PARAMS, &op,
1358 &ret_orig));
1359
1360 TEEC_CloseSession(&session);
1361out:
1362 TEEC_ReleaseSharedMemory(&shm);
1363}
Jens Wiklander14f48872018-06-29 15:30:13 +02001364ADBG_CASE_DEFINE(regression, 1017, xtest_tee_test_1017,
1365 "Test coalescing memrefs");
Jens Wiklanderbb10bcd2018-03-20 12:50:58 +08001366
1367static void xtest_tee_test_1018(ADBG_Case_t *c)
1368{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001369 TEEC_Session session = { };
Jens Wiklanderbb10bcd2018-03-20 12:50:58 +08001370 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001371 uint32_t ret_orig = 0;
1372 TEEC_SharedMemory shm = { };
Jens Wiklanderbb10bcd2018-03-20 12:50:58 +08001373 size_t page_size = 4096;
1374
Jens Wiklanderbb10bcd2018-03-20 12:50:58 +08001375 shm.size = 8 * page_size;
1376 shm.flags = TEEC_MEM_INPUT | TEEC_MEM_OUTPUT;
1377 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1378 TEEC_AllocateSharedMemory(&xtest_teec_ctx, &shm)))
1379 return;
1380
1381 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1382 xtest_teec_open_session(&session, &os_test_ta_uuid, NULL,
1383 &ret_orig)))
1384 goto out;
1385
1386 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INPUT,
1387 TEEC_MEMREF_PARTIAL_INPUT,
1388 TEEC_MEMREF_PARTIAL_OUTPUT,
1389 TEEC_MEMREF_PARTIAL_OUTPUT);
1390
1391 /*
1392 * The first two memrefs are supposed to be combined into in
1393 * region and the last two memrefs should have one region each
1394 * when the parameters are mapped for the TA.
1395 */
1396 op.params[0].memref.parent = &shm;
1397 op.params[0].memref.size = page_size;
1398 op.params[0].memref.offset = 0;
1399
1400 op.params[1].memref.parent = &shm;
1401 op.params[1].memref.size = page_size;
1402 op.params[1].memref.offset = page_size;
1403
1404 op.params[2].memref.parent = &shm;
1405 op.params[2].memref.size = page_size;
1406 op.params[2].memref.offset = 4 * page_size;
1407
1408 op.params[3].memref.parent = &shm;
1409 op.params[3].memref.size = 3 * page_size;
1410 op.params[3].memref.offset = 6 * page_size;
1411
1412 /*
1413 * Depending on the tee driver we may have different error codes.
1414 * What's most important is that secure world doesn't panic and
1415 * that someone detects an error.
1416 */
1417 ADBG_EXPECT_NOT(c, TEE_SUCCESS,
1418 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_PARAMS, &op,
1419 &ret_orig));
1420
1421 TEEC_CloseSession(&session);
1422out:
1423 TEEC_ReleaseSharedMemory(&shm);
1424}
Jens Wiklander14f48872018-06-29 15:30:13 +02001425ADBG_CASE_DEFINE(regression, 1018, xtest_tee_test_1018,
1426 "Test memref out of bounds");
Jerome Forissier53bde722018-05-31 09:14:54 +02001427
Victor Chong3ff36f52018-06-07 04:37:00 +01001428#if defined(CFG_TA_DYNLINK)
Jerome Forissier53bde722018-05-31 09:14:54 +02001429static void xtest_tee_test_1019(ADBG_Case_t *c)
1430{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001431 TEEC_Session session = { };
1432 uint32_t ret_orig = 0;
Jerome Forissier53bde722018-05-31 09:14:54 +02001433
1434 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1435 xtest_teec_open_session(&session, &os_test_ta_uuid, NULL,
1436 &ret_orig)))
1437 return;
1438
1439 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
1440 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_CALL_LIB, NULL,
1441 &ret_orig));
1442
1443 (void)ADBG_EXPECT_TEEC_RESULT(c,
1444 TEEC_ERROR_TARGET_DEAD,
1445 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_CALL_LIB_PANIC,
1446 NULL, &ret_orig));
1447
1448 (void)ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TEE, ret_orig);
1449
1450 TEEC_CloseSession(&session);
1451}
Jens Wiklander14f48872018-06-29 15:30:13 +02001452ADBG_CASE_DEFINE(regression, 1019, xtest_tee_test_1019,
1453 "Test dynamically linked TA");
1454#endif /*CFG_TA_DYNLINK*/
Jerome Forissier3357f872018-10-05 15:13:44 +02001455
1456static void xtest_tee_test_1020(ADBG_Case_t *c)
1457{
Etienne Carrieree4ec9e42019-03-28 13:30:21 +01001458 TEEC_Result res = TEEC_ERROR_GENERIC;
1459 TEEC_Session session = { };
1460 uint32_t ret_orig = 0;
Jerome Forissier3357f872018-10-05 15:13:44 +02001461
1462 /* Pseudo TA is optional: warn and nicely exit if not found */
1463 res = xtest_teec_open_session(&session, &pta_invoke_tests_ta_uuid, NULL,
1464 &ret_orig);
1465 if (res == TEEC_ERROR_ITEM_NOT_FOUND) {
1466 Do_ADBG_Log(" - 1020 - skip test, pseudo TA not found");
1467 return;
1468 }
1469 ADBG_EXPECT_TEEC_SUCCESS(c, res);
1470
1471 res = TEEC_InvokeCommand(&session, PTA_INVOKE_TESTS_CMD_LOCKDEP,
1472 NULL, &ret_orig);
1473 if (res != TEEC_SUCCESS) {
1474 (void)ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP,
1475 ret_orig);
1476 if (res == TEEC_ERROR_NOT_SUPPORTED) {
1477 Do_ADBG_Log(" - 1020 - skip test, feature not "
1478 "implemented");
1479 goto out;
1480 }
1481 /* Error */
1482 (void)ADBG_EXPECT_TEEC_SUCCESS(c, res);
1483 }
1484out:
1485 TEEC_CloseSession(&session);
1486}
1487ADBG_CASE_DEFINE(regression, 1020, xtest_tee_test_1020,
1488 "Test lockdep algorithm");
Ovidiu Mihalachi15cecff2019-04-02 16:36:31 +03001489
1490static TEEC_Result open_sec_session(TEEC_Session *session,
1491 const TEEC_UUID *uuid)
1492{
1493 TEEC_Result res = TEEC_ERROR_GENERIC;
1494 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
1495 uint32_t ret_orig = 0;
1496
1497 op.params[0].tmpref.buffer = (void *)uuid;
1498 op.params[0].tmpref.size = sizeof(*uuid);
1499 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
1500 TEEC_NONE, TEEC_NONE, TEEC_NONE);
1501
1502 res = TEEC_InvokeCommand(session, TA_SIMS_OPEN_TA_SESSION,
1503 &op, &ret_orig);
1504 if (res != TEEC_SUCCESS)
1505 return TEEC_ERROR_GENERIC;
1506
1507 return res;
1508}
1509
1510static TEEC_Result sims_get_counter(TEEC_Session *session,
1511 uint32_t *counter)
1512{
1513 TEEC_Result res = TEEC_ERROR_GENERIC;
1514 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
1515 uint32_t ret_orig = 0;
1516
1517 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_OUTPUT,
1518 TEEC_NONE, TEEC_NONE, TEEC_NONE);
1519
1520 res = TEEC_InvokeCommand(session, TA_SIMS_CMD_GET_COUNTER,
1521 &op, &ret_orig);
1522 if (res == TEEC_SUCCESS)
1523 *counter = op.params[0].value.a;
1524
1525 return res;
1526}
1527
1528static TEEC_Result trigger_panic(TEEC_Session *session,
1529 const TEEC_UUID *uuid)
1530{
1531 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
1532 uint32_t ret_orig = 0;
1533
1534 if (!uuid) {
1535 op.params[0].tmpref.buffer = NULL;
1536 op.params[0].tmpref.size = 0;
1537 } else {
1538 op.params[0].tmpref.buffer = (void *)uuid;
1539 op.params[0].tmpref.size = sizeof(*uuid);
1540 }
1541 op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT,
1542 TEEC_NONE, TEEC_NONE, TEEC_NONE);
1543
1544 return TEEC_InvokeCommand(session, TA_SIMS_CMD_PANIC,
1545 &op, &ret_orig);
1546}
1547
1548static void test_panic_ca_to_ta(ADBG_Case_t *c, const TEEC_UUID *uuid,
1549 bool multi_instance)
1550{
1551 TEEC_Result exp_res = TEEC_ERROR_GENERIC;
1552 uint32_t counter = 0;
1553 uint32_t ret_orig = 0;
1554 uint32_t exp_counter = 0;
1555 TEEC_Session cs[3] = { };
1556
1557 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1558 xtest_teec_open_session(&cs[0], uuid, NULL,
1559 &ret_orig)))
1560 return;
1561
1562 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1563 xtest_teec_open_session(&cs[1], uuid, NULL,
1564 &ret_orig)))
1565 goto bail0;
1566
1567 if (!ADBG_EXPECT_TEEC_SUCCESS(c, sims_get_counter(&cs[0], &counter)))
1568 goto bail1;
1569
1570 if (!ADBG_EXPECT(c, 0, counter))
1571 goto bail1;
1572
1573 if (!ADBG_EXPECT_TEEC_SUCCESS(c, sims_get_counter(&cs[1], &counter)))
1574 goto bail1;
1575
1576 exp_counter = multi_instance ? 0 : 1;
Ovidiu Mihalachi110aac42019-09-11 14:08:01 +03001577 if (!ADBG_EXPECT(c, exp_counter, counter))
Ovidiu Mihalachi15cecff2019-04-02 16:36:31 +03001578 goto bail1;
1579
1580 if (!ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_TARGET_DEAD,
1581 trigger_panic(&cs[1], NULL)))
1582 goto bail1;
1583
1584 exp_res = multi_instance ? TEEC_SUCCESS : TEEC_ERROR_TARGET_DEAD;
1585 if (!ADBG_EXPECT_TEEC_RESULT(c, exp_res,
1586 sims_get_counter(&cs[0], &counter)))
1587 goto bail1;
1588
1589 if (!ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_TARGET_DEAD,
1590 sims_get_counter(&cs[1], &counter)))
1591 goto bail1;
1592
1593 /* Attempt to open a session on panicked context */
Ovidiu Mihalachi110aac42019-09-11 14:08:01 +03001594 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
Ovidiu Mihalachi15cecff2019-04-02 16:36:31 +03001595 xtest_teec_open_session(&cs[1], uuid, NULL,
1596 &ret_orig)))
1597 goto bail1;
1598
1599 /* Sanity check of still valid TA context */
1600 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1601 xtest_teec_open_session(&cs[2], uuid, NULL,
1602 &ret_orig)))
1603 goto bail1;
1604
1605 /* Sanity check of still valid TA context */
1606 if (multi_instance) {
1607 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1608 sims_get_counter(&cs[0], &counter)))
1609 goto bail2;
1610
1611 if (!ADBG_EXPECT(c, 0, counter))
1612 goto bail2;
1613 }
1614
1615 if (!ADBG_EXPECT_TEEC_SUCCESS(c, sims_get_counter(&cs[2], &counter)))
1616 goto bail2;
1617
Ovidiu Mihalachi110aac42019-09-11 14:08:01 +03001618 exp_counter = multi_instance ? 0 : 1;
1619 if (!ADBG_EXPECT(c, exp_counter, counter))
Ovidiu Mihalachi15cecff2019-04-02 16:36:31 +03001620 goto bail2;
1621
1622bail2:
1623 TEEC_CloseSession(&cs[2]);
1624bail1:
1625 TEEC_CloseSession(&cs[1]);
1626bail0:
1627 TEEC_CloseSession(&cs[0]);
1628}
1629
1630static void test_panic_ta_to_ta(ADBG_Case_t *c, const TEEC_UUID *uuid1,
1631 const TEEC_UUID *uuid2)
1632{
1633 uint32_t ret_orig = 0;
1634 uint32_t counter = 0;
1635 TEEC_Session cs[3] = { };
1636
1637 /* Test pre-conditions */
1638 /* 2.1 - CA opens a session toward TA1 */
1639 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1640 xtest_teec_open_session(&cs[0], uuid1, NULL,
1641 &ret_orig)))
1642 return;
1643
1644 /* 2.2 - CA opens a session toward TA2 */
1645 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1646 xtest_teec_open_session(&cs[1], uuid2, NULL,
1647 &ret_orig)))
1648 goto bail0;
1649
1650 /* 2.3 - TA1 opens a session toward TA2 */
1651 if (!ADBG_EXPECT_TEEC_SUCCESS(c, open_sec_session(&cs[0], uuid2)))
1652 goto bail1;
1653
1654 /* 2.4 - CA invokes TA2 which panics */
1655 if (!ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_TARGET_DEAD,
1656 trigger_panic(&cs[1], NULL)))
1657 goto bail1;
1658
1659 /* Expected results */
1660 /* 2.5 - Expect CA->TA1 session is still alive */
1661 if (!ADBG_EXPECT_TEEC_SUCCESS(c, sims_get_counter(&cs[0], &counter)))
1662 goto bail1;
1663
1664 /* 2.6 - Expect CA->TA2 session is properly released */
1665 if (!ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_TARGET_DEAD,
1666 sims_get_counter(&cs[1], &counter)))
1667 goto bail1;
1668
1669bail1:
1670 TEEC_CloseSession(&cs[1]);
1671bail0:
1672 TEEC_CloseSession(&cs[0]);
1673
1674 memset(cs, 0, sizeof(cs));
1675
1676 /* Test pre-conditions */
1677 /* 2.1 - CA opens a session toward TA1 */
1678 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1679 xtest_teec_open_session(&cs[0], uuid1, NULL,
1680 &ret_orig)))
1681 return;
1682
1683 /* 2.2 - CA opens a session toward TA2 */
1684 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1685 xtest_teec_open_session(&cs[1], uuid2, NULL,
1686 &ret_orig)))
1687 goto bail2;
1688
1689 /* 2.3 - TA1 opens a session toward TA2 */
1690 if (!ADBG_EXPECT_TEEC_SUCCESS(c, open_sec_session(&cs[0], uuid2)))
1691 goto bail3;
1692
1693 /* 2.4 - CA invokes TA1 which invokes TA2 which panics */
1694 if (!ADBG_EXPECT_TEEC_SUCCESS(c, trigger_panic(&cs[0], uuid2)))
1695 goto bail3;
1696
1697 /* Expected results */
1698 /* 2.5 - Expect CA->TA1 session is still alive */
1699 if (!ADBG_EXPECT_TEEC_SUCCESS(c, sims_get_counter(&cs[0], &counter)))
1700 goto bail3;
1701
1702 /* 2.6 - Expect CA->TA2 session is properly released */
1703 if (!ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_TARGET_DEAD,
1704 sims_get_counter(&cs[1], &counter)))
1705 goto bail3;
1706
1707bail3:
1708 TEEC_CloseSession(&cs[1]);
1709bail2:
1710 TEEC_CloseSession(&cs[0]);
1711}
1712
1713static void xtest_tee_test_1021(ADBG_Case_t *c)
1714{
1715 Do_ADBG_BeginSubCase(c, "Multiple Instances Single Session");
1716 test_panic_ca_to_ta(c, &miss_test_ta_uuid, true);
1717 Do_ADBG_EndSubCase(c, "Multiple Instances Single Session");
1718
1719 Do_ADBG_BeginSubCase(c, "Single Instance Multi Sessions");
1720 test_panic_ca_to_ta(c, &sims_test_ta_uuid, false);
1721 Do_ADBG_EndSubCase(c, "Single Instance Multi Sessions");
1722
1723 Do_ADBG_BeginSubCase(c, "Single Instance Multi Sessions Keep Alive");
1724 test_panic_ca_to_ta(c, &sims_keepalive_test_ta_uuid, false);
1725 Do_ADBG_EndSubCase(c, "Single Instance Multi Sessions Keep Alive");
1726
1727 Do_ADBG_BeginSubCase(c, "Multi Sessions TA to TA");
1728 test_panic_ta_to_ta(c, &sims_test_ta_uuid,
1729 &sims_keepalive_test_ta_uuid);
1730 Do_ADBG_EndSubCase(c, "Multi Sessions TA to TA");
1731}
1732ADBG_CASE_DEFINE(regression, 1021, xtest_tee_test_1021,
1733 "Test panic context release");
Jerome Forissiera9ab5d02019-03-17 21:14:06 +01001734
1735static void xtest_tee_test_1022(ADBG_Case_t *c)
1736{
1737 TEEC_Session session = { 0 };
1738 uint32_t ret_orig = 0;
1739
1740 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1741 xtest_teec_open_session(&session, &os_test_ta_uuid,
1742 NULL, &ret_orig)))
1743 return;
1744
1745 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
1746 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_CALL_LIB_DL, NULL,
1747 &ret_orig));
1748
1749 (void)ADBG_EXPECT_TEEC_RESULT(c,
1750 TEEC_ERROR_TARGET_DEAD,
1751 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_CALL_LIB_DL_PANIC,
1752 NULL, &ret_orig));
1753
1754 (void)ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TEE, ret_orig);
1755
1756 TEEC_CloseSession(&session);
1757}
1758ADBG_CASE_DEFINE(regression, 1022, xtest_tee_test_1022,
1759 "Test dlopen()/dlsym()/dlclose() API");
Jerome Forissiere9571e82020-02-18 15:26:20 +01001760
1761/*
1762 * Testing the ELF initialization (.init_array)
1763 *
1764 * - The TA has a global variable which can also be accessed by the two shared
1765 * libraries os_test_lib (linked with the TA) and os_test_lib_dl (loaded via
1766 * dlopen())
1767 * - The TA and both libraries have initialization functions (declared with the
1768 * "constructor" attribute) which perform the following:
1769 * * The TA multiplies by 10 then adds 1
1770 * * os_test_lib multiplies by 10 then adds 2
1771 * * os_test_lib_dl multiplies by 10 then adds 3
1772 * By testing the variable value we make sure the initializations occurred in
1773 * the correct order.
1774 */
1775static void xtest_tee_test_1023(ADBG_Case_t *c)
1776{
1777 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
1778 TEEC_Session session = { 0 };
1779 uint32_t ret_orig = 0;
1780
1781 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_OUTPUT, TEEC_NONE,
1782 TEEC_NONE, TEEC_NONE);
1783
1784 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1785 xtest_teec_open_session(&session, &os_test_ta_uuid,
1786 NULL, &ret_orig)))
1787 return;
1788
1789 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
1790 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_GET_GLOBAL_VAR, &op,
1791 &ret_orig));
1792
1793 /* Expected: initialization of os_test_lib, then TA */
1794 (void)ADBG_EXPECT_COMPARE_SIGNED(c, op.params[0].value.a, ==, 21);
1795
1796 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
1797 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_CALL_LIB_DL, NULL,
1798 &ret_orig));
1799
1800 (void)ADBG_EXPECT_TEEC_SUCCESS(c,
1801 TEEC_InvokeCommand(&session, TA_OS_TEST_CMD_GET_GLOBAL_VAR, &op,
1802 &ret_orig));
1803
1804 /* Expected: initialization of os_test_lib_dl */
1805 (void)ADBG_EXPECT_COMPARE_SIGNED(c, op.params[0].value.a, ==, 213);
1806
1807 TEEC_CloseSession(&session);
1808}
1809ADBG_CASE_DEFINE(regression, 1023, xtest_tee_test_1023,
1810 "Test ELF initialization (.init_array)");