1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2018, Linaro Limited */
3
4 #include <adbg.h>
5 #include <ctype.h>
6 #include <inttypes.h>
7 #include <stdarg.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <ta_crypt.h>
12 #include <tee_api_defines.h>
13 #include <tee_api_types.h>
14 #include <tee_api_compat.h>
15 #include <util.h>
16
17 #include "xtest_test.h"
18 #include "xtest_helpers.h"
19
cmd_new_var(ADBG_Case_t * c,TEEC_Session * s,uint32_t num_bits,uint32_t * handle)20 static TEEC_Result cmd_new_var(ADBG_Case_t *c, TEEC_Session *s,
21 uint32_t num_bits, uint32_t *handle)
22 {
23 TEEC_Result res = TEEC_ERROR_GENERIC;
24 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
25 uint32_t ret_orig = 0;
26
27 op.params[0].value.a = num_bits;
28 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT,
29 TEEC_NONE, TEEC_NONE);
30 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_NEW_VAR, &op, &ret_orig);
31 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
32 if (!res)
33 *handle = op.params[1].value.a;
34
35 return res;
36 }
37
cmd_new_fmm_var(ADBG_Case_t * c,TEEC_Session * s,uint32_t num_bits,uint32_t * handle)38 static TEEC_Result cmd_new_fmm_var(ADBG_Case_t *c, TEEC_Session *s,
39 uint32_t num_bits, uint32_t *handle)
40 {
41 TEEC_Result res = TEEC_ERROR_GENERIC;
42 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
43 uint32_t ret_orig = 0;
44
45 op.params[0].value.a = num_bits;
46 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT,
47 TEEC_NONE, TEEC_NONE);
48 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_NEW_FMM_VAR, &op,
49 &ret_orig);
50 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
51 if (!res)
52 *handle = op.params[1].value.a;
53
54 return res;
55 }
56
cmd_new_fmm_ctx(ADBG_Case_t * c,TEEC_Session * s,uint32_t num_bits,uint32_t hmodulus,uint32_t * handle)57 static TEEC_Result cmd_new_fmm_ctx(ADBG_Case_t *c, TEEC_Session *s,
58 uint32_t num_bits, uint32_t hmodulus,
59 uint32_t *handle)
60 {
61 TEEC_Result res = TEEC_ERROR_GENERIC;
62 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
63 uint32_t ret_orig = 0;
64
65 op.params[0].value.a = num_bits;
66 op.params[0].value.b = hmodulus;
67 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT,
68 TEEC_NONE, TEEC_NONE);
69 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_NEW_FMM_CTX, &op,
70 &ret_orig);
71 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
72 if (!res)
73 *handle = op.params[1].value.a;
74
75 return res;
76 }
77
cmd_free_handle(ADBG_Case_t * c,TEEC_Session * s,uint32_t handle)78 static TEEC_Result cmd_free_handle(ADBG_Case_t *c, TEEC_Session *s,
79 uint32_t handle)
80 {
81 if (handle == TA_CRYPT_ARITH_INVALID_HANDLE)
82 return TEEC_SUCCESS;
83
84 TEEC_Result res = TEEC_ERROR_GENERIC;
85 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
86 uint32_t ret_orig = 0;
87
88 op.params[0].value.a = handle;
89 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
90 TEEC_NONE, TEEC_NONE);
91 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_FREE_HANDLE, &op,
92 &ret_orig);
93 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
94
95 return res;
96 }
97
cmd_from_octet_string(ADBG_Case_t * c,TEEC_Session * s,uint8_t * buf,uint32_t buf_len,int32_t sign,uint32_t h)98 static TEEC_Result cmd_from_octet_string(ADBG_Case_t *c, TEEC_Session *s,
99 uint8_t *buf, uint32_t buf_len,
100 int32_t sign, uint32_t h)
101 {
102 TEEC_Result res = TEEC_ERROR_GENERIC;
103 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
104 uint32_t ret_orig = 0;
105
106 op.params[0].value.a = h;
107 op.params[0].value.b = sign;
108 op.params[1].tmpref.buffer = buf;
109 op.params[1].tmpref.size = buf_len;
110 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT,
111 TEEC_MEMREF_TEMP_INPUT,
112 TEEC_NONE, TEEC_NONE);
113 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_FROM_OCTET_STRING, &op,
114 &ret_orig);
115 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
116
117 return res;
118 }
119
cmd_from_s32(ADBG_Case_t * c,TEEC_Session * s,uint32_t handle,int32_t v)120 static TEEC_Result cmd_from_s32(ADBG_Case_t *c, TEEC_Session *s,
121 uint32_t handle, int32_t v)
122 {
123 TEEC_Result res = TEEC_ERROR_GENERIC;
124 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
125 uint32_t ret_orig = 0;
126
127 op.params[0].value.a = handle;
128 op.params[0].value.b = v;
129 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
130 TEEC_NONE, TEEC_NONE);
131 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_FROM_S32, &op,
132 &ret_orig);
133 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
134
135 return res;
136 }
137
cmd_get_bit(ADBG_Case_t * c,TEEC_Session * s,uint32_t handle,uint32_t bit_num,uint32_t * v)138 static TEEC_Result cmd_get_bit(ADBG_Case_t *c, TEEC_Session *s,
139 uint32_t handle, uint32_t bit_num, uint32_t *v)
140 {
141 TEEC_Result res = TEEC_ERROR_GENERIC;
142 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
143 uint32_t ret_orig = 0;
144
145 op.params[0].value.a = handle;
146 op.params[0].value.b = bit_num;
147 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT,
148 TEEC_NONE, TEEC_NONE);
149 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_GET_BIT, &op, &ret_orig);
150 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
151 if (!res)
152 *v = op.params[1].value.a;
153
154 return res;
155 }
156
cmd_get_bit_count(ADBG_Case_t * c,TEEC_Session * s,uint32_t handle,uint32_t * v)157 static TEEC_Result cmd_get_bit_count(ADBG_Case_t *c, TEEC_Session *s,
158 uint32_t handle, uint32_t *v)
159 {
160 TEEC_Result res = TEEC_ERROR_GENERIC;
161 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
162 uint32_t ret_orig = 0;
163
164 op.params[0].value.a = handle;
165 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT,
166 TEEC_NONE, TEEC_NONE);
167 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_GET_BIT_COUNT, &op,
168 &ret_orig);
169 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
170 if (!res)
171 *v = op.params[1].value.a;
172
173 return res;
174 }
175
cmd_binary_cmd(ADBG_Case_t * c,TEEC_Session * s,uint32_t cmd,uint32_t hop1,uint32_t hop2,uint32_t hres)176 static TEEC_Result cmd_binary_cmd(ADBG_Case_t *c, TEEC_Session *s, uint32_t cmd,
177 uint32_t hop1, uint32_t hop2, uint32_t hres)
178 {
179 TEEC_Result res = TEEC_ERROR_GENERIC;
180 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
181 uint32_t ret_orig = 0;
182
183 op.params[0].value.a = hop1;
184 op.params[0].value.b = hop2;
185 op.params[1].value.a = hres;
186 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT,
187 TEEC_NONE, TEEC_NONE);
188 res = TEEC_InvokeCommand(s, cmd, &op, &ret_orig);
189 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
190
191 return res;
192 }
193
cmd_unary_cmd(ADBG_Case_t * c,TEEC_Session * s,uint32_t cmd,uint32_t hop,uint32_t hres)194 static TEEC_Result cmd_unary_cmd(ADBG_Case_t *c, TEEC_Session *s, uint32_t cmd,
195 uint32_t hop, uint32_t hres)
196 {
197 TEEC_Result res = TEEC_ERROR_GENERIC;
198 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
199 uint32_t ret_orig = 0;
200
201 op.params[0].value.a = hop;
202 op.params[0].value.b = hres;
203 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE,
204 TEEC_NONE, TEEC_NONE);
205 res = TEEC_InvokeCommand(s, cmd, &op, &ret_orig);
206 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
207
208 return res;
209 }
210
cmd_ternary_cmd(ADBG_Case_t * c,TEEC_Session * s,uint32_t cmd,uint32_t hop1,uint32_t hop2,uint32_t hn,uint32_t hres)211 static TEEC_Result cmd_ternary_cmd(ADBG_Case_t *c, TEEC_Session *s,
212 uint32_t cmd, uint32_t hop1, uint32_t hop2,
213 uint32_t hn, uint32_t hres)
214 {
215 TEEC_Result res = TEEC_ERROR_GENERIC;
216 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
217 uint32_t ret_orig = 0;
218
219 op.params[0].value.a = hop1;
220 op.params[0].value.b = hop2;
221 op.params[1].value.a = hn;
222 op.params[1].value.b = hres;
223 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT,
224 TEEC_NONE, TEEC_NONE);
225 res = TEEC_InvokeCommand(s, cmd, &op, &ret_orig);
226 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
227
228 return res;
229 }
230
cmd_neg(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop,uint32_t hres)231 static TEEC_Result cmd_neg(ADBG_Case_t *c, TEEC_Session *s, uint32_t hop,
232 uint32_t hres)
233 {
234 return cmd_unary_cmd(c, s, TA_CRYPT_CMD_ARITH_NEG, hop, hres);
235 }
236
cmd_add(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,uint32_t hres)237 static TEEC_Result cmd_add(ADBG_Case_t *c, TEEC_Session *s,
238 uint32_t hop1, uint32_t hop2, uint32_t hres)
239 {
240 return cmd_binary_cmd(c, s, TA_CRYPT_CMD_ARITH_ADD, hop1, hop2, hres);
241 }
242
cmd_sub(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,uint32_t hres)243 static TEEC_Result cmd_sub(ADBG_Case_t *c, TEEC_Session *s,
244 uint32_t hop1, uint32_t hop2, uint32_t hres)
245 {
246 return cmd_binary_cmd(c, s, TA_CRYPT_CMD_ARITH_SUB, hop1, hop2, hres);
247 }
248
cmd_mul(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,uint32_t hres)249 static TEEC_Result cmd_mul(ADBG_Case_t *c, TEEC_Session *s,
250 uint32_t hop1, uint32_t hop2, uint32_t hres)
251 {
252 return cmd_binary_cmd(c, s, TA_CRYPT_CMD_ARITH_MUL, hop1, hop2, hres);
253 }
254
cmd_mod(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,uint32_t hres)255 static TEEC_Result cmd_mod(ADBG_Case_t *c, TEEC_Session *s,
256 uint32_t hop1, uint32_t hop2, uint32_t hres)
257 {
258 return cmd_binary_cmd(c, s, TA_CRYPT_CMD_ARITH_MOD, hop1, hop2, hres);
259 }
260
cmd_invmod(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,uint32_t hres)261 static TEEC_Result cmd_invmod(ADBG_Case_t *c, TEEC_Session *s,
262 uint32_t hop1, uint32_t hop2, uint32_t hres)
263 {
264 return cmd_binary_cmd(c, s, TA_CRYPT_CMD_ARITH_INVMOD, hop1, hop2,
265 hres);
266 }
267
cmd_addmod(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,uint32_t hn,uint32_t hres)268 static TEEC_Result cmd_addmod(ADBG_Case_t *c, TEEC_Session *s,
269 uint32_t hop1, uint32_t hop2, uint32_t hn,
270 uint32_t hres)
271 {
272 return cmd_ternary_cmd(c, s, TA_CRYPT_CMD_ARITH_ADDMOD, hop1, hop2,
273 hn, hres);
274 }
275
cmd_submod(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,uint32_t hn,uint32_t hres)276 static TEEC_Result cmd_submod(ADBG_Case_t *c, TEEC_Session *s,
277 uint32_t hop1, uint32_t hop2, uint32_t hn,
278 uint32_t hres)
279 {
280 return cmd_ternary_cmd(c, s, TA_CRYPT_CMD_ARITH_SUBMOD, hop1, hop2,
281 hn, hres);
282 }
283
cmd_mulmod(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,uint32_t hn,uint32_t hres)284 static TEEC_Result cmd_mulmod(ADBG_Case_t *c, TEEC_Session *s,
285 uint32_t hop1, uint32_t hop2, uint32_t hn,
286 uint32_t hres)
287 {
288 return cmd_ternary_cmd(c, s, TA_CRYPT_CMD_ARITH_MULMOD, hop1, hop2,
289 hn, hres);
290 }
291
cmd_is_prime(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop,uint32_t conf_level,int32_t * pres)292 static TEEC_Result cmd_is_prime(ADBG_Case_t *c, TEEC_Session *s, uint32_t hop,
293 uint32_t conf_level, int32_t *pres)
294 {
295 TEEC_Result res = TEEC_ERROR_GENERIC;
296 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
297 uint32_t ret_orig = 0;
298
299 op.params[0].value.a = hop;
300 op.params[0].value.b = conf_level;
301 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT,
302 TEEC_NONE, TEEC_NONE);
303 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_IS_PRIME, &op,
304 &ret_orig);
305 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
306 if (!res)
307 *pres = op.params[1].value.a;
308
309 return res;
310 }
311
cmd_shift_right(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop,uint32_t bits,uint32_t hres)312 static TEEC_Result cmd_shift_right(ADBG_Case_t *c, TEEC_Session *s,
313 uint32_t hop, uint32_t bits, uint32_t hres)
314 {
315 TEEC_Result res = TEEC_ERROR_GENERIC;
316 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
317 uint32_t ret_orig = 0;
318
319 op.params[0].value.a = hop;
320 op.params[0].value.b = bits;
321 op.params[1].value.a = hres;
322 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT,
323 TEEC_NONE, TEEC_NONE);
324 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_SHIFT_RIGHT, &op,
325 &ret_orig);
326 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
327
328 return res;
329 }
330
cmd_to_fmm(ADBG_Case_t * c,TEEC_Session * s,uint32_t hsrc,uint32_t hn,uint32_t hctx,uint32_t hres)331 static TEEC_Result cmd_to_fmm(ADBG_Case_t *c, TEEC_Session *s, uint32_t hsrc,
332 uint32_t hn, uint32_t hctx, uint32_t hres)
333 {
334 TEEC_Result res = TEEC_ERROR_GENERIC;
335 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
336 uint32_t ret_orig = 0;
337
338 op.params[0].value.a = hsrc;
339 op.params[0].value.b = hn;
340 op.params[1].value.a = hctx;
341 op.params[1].value.b = hres;
342 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT,
343 TEEC_NONE, TEEC_NONE);
344 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_TO_FMM, &op, &ret_orig);
345 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
346
347 return res;
348 }
349
cmd_from_fmm(ADBG_Case_t * c,TEEC_Session * s,uint32_t hsrc,uint32_t hn,uint32_t hctx,uint32_t hres)350 static TEEC_Result cmd_from_fmm(ADBG_Case_t *c, TEEC_Session *s, uint32_t hsrc,
351 uint32_t hn, uint32_t hctx, uint32_t hres)
352 {
353 TEEC_Result res = TEEC_ERROR_GENERIC;
354 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
355 uint32_t ret_orig = 0;
356
357 op.params[0].value.a = hsrc;
358 op.params[0].value.b = hn;
359 op.params[1].value.a = hctx;
360 op.params[1].value.b = hres;
361 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT,
362 TEEC_NONE, TEEC_NONE);
363 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_FROM_FMM, &op,
364 &ret_orig);
365 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
366
367 return res;
368 }
369
cmd_compute_fmm(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,uint32_t hn,uint32_t hctx,uint32_t hres)370 static TEEC_Result cmd_compute_fmm(ADBG_Case_t *c, TEEC_Session *s,
371 uint32_t hop1, uint32_t hop2, uint32_t hn,
372 uint32_t hctx, uint32_t hres)
373 {
374 TEEC_Result res = TEEC_ERROR_GENERIC;
375 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
376 uint32_t ret_orig = 0;
377
378 op.params[0].value.a = hop1;
379 op.params[0].value.b = hop2;
380 op.params[1].value.a = hn;
381 op.params[1].value.b = hctx;
382 op.params[2].value.a = hres;
383 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT,
384 TEEC_VALUE_INPUT, TEEC_NONE);
385 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_COMPUTE_FMM, &op,
386 &ret_orig);
387 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
388
389 return res;
390 }
391
cmd_compute_egcd(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,uint32_t hu,uint32_t hv,uint32_t hgcd)392 static TEEC_Result cmd_compute_egcd(ADBG_Case_t *c, TEEC_Session *s,
393 uint32_t hop1, uint32_t hop2, uint32_t hu,
394 uint32_t hv, uint32_t hgcd)
395 {
396 TEEC_Result res = TEEC_ERROR_GENERIC;
397 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
398 uint32_t ret_orig = 0;
399
400 op.params[0].value.a = hop1;
401 op.params[0].value.b = hop2;
402 op.params[1].value.a = hu;
403 op.params[1].value.b = hv;
404 op.params[2].value.a = hgcd;
405 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT,
406 TEEC_VALUE_INPUT, TEEC_NONE);
407 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_COMPUTE_EGCD, &op,
408 &ret_orig);
409 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
410
411 return res;
412 }
413
cmd_compute_gcd(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,uint32_t hgcd)414 static TEEC_Result cmd_compute_gcd(ADBG_Case_t *c, TEEC_Session *s,
415 uint32_t hop1, uint32_t hop2, uint32_t hgcd)
416 {
417 return cmd_compute_egcd(c, s, hop1, hop2, TA_CRYPT_ARITH_INVALID_HANDLE,
418 TA_CRYPT_ARITH_INVALID_HANDLE, hgcd);
419 }
420
digit_value(char ch)421 static int digit_value(char ch)
422 {
423 if ((ch >= '0') && (ch <= '9'))
424 return ch - '0';
425
426 if ((ch >= 'A') && (ch <= 'F'))
427 return ch - 'A' + 10;
428
429 if ((ch >= 'a') && (ch <= 'f'))
430 return ch - 'a' + 10;
431
432 return -1;
433 }
434
convert_from_string(ADBG_Case_t * c,TEEC_Session * s,const char * str,uint32_t h)435 static TEEC_Result convert_from_string(ADBG_Case_t *c, TEEC_Session *s,
436 const char *str, uint32_t h)
437 {
438 TEEC_Result res = TEEC_ERROR_BAD_FORMAT;
439 size_t spos = strlen(str);
440 int32_t sign = 1;
441 size_t os_len = (spos + 1) / 2;
442 uint8_t *os = calloc(1, os_len);
443 int ospos = os_len - 1;
444 int nibble = 0;
445
446 if (!os)
447 return TEEC_ERROR_OUT_OF_MEMORY;
448
449 while (spos) {
450 spos--;
451 nibble = digit_value(str[spos]);
452 if (nibble == -1)
453 break;
454 os[ospos] = nibble;
455
456 if (!spos)
457 break;
458 spos--;
459 nibble = digit_value(str[spos]);
460 if (nibble == -1)
461 break;
462
463 os[ospos] |= nibble << 4;
464 ospos--;
465 }
466
467 if (spos)
468 goto out;
469
470 if (str[spos] == '-')
471 sign = -1;
472
473 res = cmd_from_octet_string(c, s, os, os_len, sign, h);
474 out:
475 free(os);
476 return res;
477 }
478
cmd_get_value(ADBG_Case_t * c,TEEC_Session * s,uint8_t * buf,uint32_t * buf_len,int32_t * sign,uint32_t h)479 static TEEC_Result cmd_get_value(ADBG_Case_t *c, TEEC_Session *s, uint8_t *buf,
480 uint32_t *buf_len, int32_t *sign, uint32_t h)
481 {
482 TEEC_Result res = TEEC_ERROR_GENERIC;
483 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
484 uint32_t ret_orig = 0;
485
486 op.params[0].value.a = h;
487 op.params[2].tmpref.buffer = buf;
488 op.params[2].tmpref.size = *buf_len;
489 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT,
490 TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE);
491 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_GET_VALUE, &op,
492 &ret_orig);
493 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
494 if (!res)
495 *sign = op.params[1].value.a;
496 *buf_len = op.params[2].tmpref.size;
497
498 return res;
499 }
500
print_handle(ADBG_Case_t * c,TEEC_Session * s,const char * name,uint32_t h)501 static TEEC_Result __maybe_unused print_handle(ADBG_Case_t *c, TEEC_Session *s,
502 const char *name, uint32_t h)
503 {
504 TEEC_Result res = TEEC_ERROR_GENERIC;
505 uint8_t *os = NULL;
506 uint32_t os_len = 0;
507 int32_t sign = 0;
508
509 res = cmd_get_value(c, s, os, &os_len, &sign, h);
510 if (res) {
511 if (!ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_SHORT_BUFFER, res))
512 return res;
513
514 os = malloc(os_len);
515 if (!ADBG_EXPECT_NOT_NULL(c, os))
516 return TEEC_ERROR_OUT_OF_MEMORY;
517
518 res = cmd_get_value(c, s, os, &os_len, &sign, h);
519 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
520 goto out;
521 }
522
523 Do_ADBG_Log("%s sign %" PRId32 " (length %" PRIu32 ")",
524 name, sign, os_len);
525 Do_ADBG_HexLog(os, os_len, 16);
526 out:
527 free(os);
528 return res;
529 }
530
cmd_get_value_s32(ADBG_Case_t * c,TEEC_Session * s,uint32_t h,int32_t * val)531 static TEEC_Result cmd_get_value_s32(ADBG_Case_t *c, TEEC_Session *s,
532 uint32_t h, int32_t *val)
533 {
534 TEEC_Result res = TEEC_ERROR_GENERIC;
535 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
536 uint32_t ret_orig = 0;
537
538 op.params[0].value.a = h;
539 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT,
540 TEEC_NONE, TEEC_NONE);
541 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_GET_VALUE_S32, &op,
542 &ret_orig);
543 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
544 if (!res)
545 *val = op.params[1].value.a;
546
547 return res;
548 }
549
cmd_cmp(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,int32_t * cmp_res)550 static TEEC_Result cmd_cmp(ADBG_Case_t *c, TEEC_Session *s, uint32_t hop1,
551 uint32_t hop2, int32_t *cmp_res)
552 {
553 TEEC_Result res = TEEC_ERROR_GENERIC;
554 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
555 uint32_t ret_orig = 0;
556
557 op.params[0].value.a = hop1;
558 op.params[0].value.b = hop2;
559 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT,
560 TEEC_NONE, TEEC_NONE);
561 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_CMP, &op, &ret_orig);
562 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
563
564 if (!res)
565 *cmp_res = op.params[1].value.a;
566
567 return res;
568 }
569
cmd_cmp_s32(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop,int32_t s32,int32_t * cmp_res)570 static TEEC_Result cmd_cmp_s32(ADBG_Case_t *c, TEEC_Session *s, uint32_t hop,
571 int32_t s32, int32_t *cmp_res)
572 {
573 TEEC_Result res = TEEC_ERROR_GENERIC;
574 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
575 uint32_t ret_orig = 0;
576
577 op.params[0].value.a = hop;
578 op.params[0].value.b = s32;
579 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT,
580 TEEC_NONE, TEEC_NONE);
581 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_CMP_S32, &op, &ret_orig);
582 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
583
584 if (!res)
585 *cmp_res = op.params[1].value.a;
586
587 return res;
588 }
589
cmd_div(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,uint32_t hq,uint32_t hr)590 static TEEC_Result cmd_div(ADBG_Case_t *c, TEEC_Session *s, uint32_t hop1,
591 uint32_t hop2, uint32_t hq, uint32_t hr)
592 {
593 TEEC_Result res = TEEC_ERROR_GENERIC;
594 TEEC_Operation op = TEEC_OPERATION_INITIALIZER;
595 uint32_t ret_orig = 0;
596
597 op.params[0].value.a = hop1;
598 op.params[0].value.b = hop2;
599 op.params[1].value.a = hq;
600 op.params[1].value.b = hr;
601 op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT,
602 TEEC_NONE, TEEC_NONE);
603 res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_DIV, &op, &ret_orig);
604 ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig);
605
606 return res;
607 }
608
test_4101(ADBG_Case_t * c)609 static void test_4101(ADBG_Case_t *c)
610 {
611 TEEC_Session session = { };
612 uint32_t ret_orig = 0;
613 uint32_t handle = TA_CRYPT_ARITH_INVALID_HANDLE;
614
615 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
616 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
617 NULL, &ret_orig)))
618 return;
619
620 Do_ADBG_BeginSubCase(c, "Normal allocation and initialization");
621
622 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
623 cmd_new_var(c, &session, 512, &handle)))
624 goto out;
625 if (!ADBG_EXPECT_COMPARE_UNSIGNED(c,
626 handle, !=, TA_CRYPT_ARITH_INVALID_HANDLE))
627 goto out;
628 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, &session, handle)))
629 goto out;
630
631 Do_ADBG_EndSubCase(c, "Normal allocation and initialization");
632
633 Do_ADBG_BeginSubCase(c, "Zero allocation");
634
635 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
636 cmd_new_var(c, &session, 0, &handle)))
637 goto out;
638 if (!ADBG_EXPECT_COMPARE_UNSIGNED(c,
639 handle, !=, TA_CRYPT_ARITH_INVALID_HANDLE))
640 goto out;
641 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, &session, handle)))
642 goto out;
643
644 Do_ADBG_EndSubCase(c, "Zero allocation");
645
646 Do_ADBG_BeginSubCase(c, "Too large");
647
648 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
649 cmd_new_var(c, &session, 4096, &handle)))
650 goto out;
651 if (!ADBG_EXPECT_COMPARE_UNSIGNED(c,
652 handle, !=, TA_CRYPT_ARITH_INVALID_HANDLE))
653 goto out;
654 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, &session, handle)))
655 goto out;
656
657 Do_ADBG_EndSubCase(c, "Too large");
658
659 Do_ADBG_BeginSubCase(c, "Boundaries");
660
661 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
662 cmd_new_var(c, &session, 2048, &handle)))
663 goto out;
664 if (!ADBG_EXPECT_COMPARE_UNSIGNED(c,
665 handle, !=, TA_CRYPT_ARITH_INVALID_HANDLE))
666 goto out;
667 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, &session, handle)))
668 goto out;
669
670 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
671 cmd_new_var(c, &session, 2049, &handle)))
672 goto out;
673 if (!ADBG_EXPECT_COMPARE_UNSIGNED(c,
674 handle, !=, TA_CRYPT_ARITH_INVALID_HANDLE))
675 goto out;
676 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, &session, handle)))
677 goto out;
678
679 Do_ADBG_EndSubCase(c, "Boundaries");
680 out:
681 TEEC_CloseSession(&session);
682 }
683 ADBG_CASE_DEFINE(regression, 4101, test_4101,
684 "Test TEE Internal API Arithmetical API - Bigint init");
685
test_4102(ADBG_Case_t * c)686 static void test_4102(ADBG_Case_t *c)
687 {
688 TEEC_Session session = { };
689 uint32_t ret_orig = 0;
690 uint32_t ha = TA_CRYPT_ARITH_INVALID_HANDLE;
691 uint32_t hb = TA_CRYPT_ARITH_INVALID_HANDLE;
692 size_t n = 0;
693 const struct {
694 const uint8_t *os;
695 uint32_t os_len;
696 const char *str;
697 int32_t sign;
698 } data[] = {
699 { .os = (const uint8_t []){ 1, 2, 3, 4 },
700 .os_len = 4, .sign = 1, .str = "01020304", },
701 { .os = (const uint8_t []){ 1, 2, 3, 4, 5 },
702 .os_len = 5, .sign = 1, .str = "0102030405", },
703 { .os = (const uint8_t []){
704 0x11, 0x22, 0x44, 0x55, 0x66, 0x77, 0x88 },
705 .os_len = 7, .sign = 1, .str = "11224455667788", },
706 { .os = (const uint8_t []){ 0, 1, 2, 3, 4 },
707 .os_len = 5, .sign = 1, .str = "01020304", },
708 };
709
710 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
711 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
712 NULL, &ret_orig)))
713 return;
714
715 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, &session, 512, &ha)))
716 goto out;
717 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, &session, 512, &hb)))
718 goto out;
719
720 for (n = 0; n < ARRAY_SIZE(data); n++) {
721 int32_t sign = 0;
722 int32_t cmp_res = 0;
723 size_t len_diff = 0;
724 uint8_t os_res[10];
725 uint32_t os_len;
726
727 Do_ADBG_BeginSubCase(c, "\"%s\"", data[n].str);
728
729 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c,
730 &session, data[n].str, ha)))
731 goto out;
732
733 /* Check that it's read back correctly */
734 os_len = data[n].os_len;
735 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_get_value(c, &session,
736 os_res, &os_len, &sign, ha)))
737 goto out;
738 if (!ADBG_EXPECT_COMPARE_UNSIGNED(c, data[n].os_len,
739 >=, os_len))
740 goto out;
741
742 len_diff = data[n].os_len - os_len;
743 if (!ADBG_EXPECT_BUFFER(c, data[n].os + len_diff,
744 data[n].os_len - len_diff,
745 os_res, os_len))
746 goto out;
747 if (!ADBG_EXPECT_COMPARE_SIGNED(c, sign, ==, data[n].sign))
748 goto out;
749
750 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_from_octet_string(c,
751 &session, os_res, os_len, sign, hb)))
752 goto out;
753
754 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_cmp(c, &session,
755 ha, hb, &cmp_res)))
756 goto out;
757 if (!ADBG_EXPECT_COMPARE_SIGNED(c, cmp_res, ==, 0))
758 goto out;
759
760 Do_ADBG_EndSubCase(c, NULL);
761 }
762 out:
763 TEEC_CloseSession(&session);
764 }
765 ADBG_CASE_DEFINE(regression, 4102, test_4102,
766 "Test TEE Internal API Arithmetical API - Octet string");
767
test_4103(ADBG_Case_t * c)768 static void test_4103(ADBG_Case_t *c)
769 {
770 TEEC_Session session = { };
771 uint32_t ret_orig = 0;
772 size_t n = 0;
773 uint32_t h = TA_CRYPT_ARITH_INVALID_HANDLE;
774 int32_t v = 0;
775 static const int32_t data[] = {
776 1, -1, 123, -123, 0x7FFFFFFF, (int32_t)0x80000000,
777 (int32_t)0xFFFFFFFF, 0,
778 };
779 static const char *data_str[] = { "1FFFFFFFFF", "-1FFFFFFFFF" };
780
781 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
782 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
783 NULL, &ret_orig)))
784 return;
785
786 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, &session, 512, &h)))
787 goto out;
788
789 for (n = 0; n < ARRAY_SIZE(data); n++) {
790 int32_t cmp_res = 0;
791
792 Do_ADBG_BeginSubCase(c, "%" PRId32 " (0x%" PRIx32 ")",
793 data[n], (uint32_t)data[n]);
794
795 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
796 cmd_from_s32(c, &session, h, data[n])))
797 goto out;
798 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
799 cmd_cmp_s32(c, &session, h, data[n], &cmp_res)))
800 goto out;
801 if (!ADBG_EXPECT_COMPARE_SIGNED(c, cmp_res, ==, 0))
802 goto out;
803 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
804 cmd_get_value_s32(c, &session, h, &v))) {
805 Do_ADBG_Log("n %zu", n);
806 goto out;
807 }
808 if (!ADBG_EXPECT_COMPARE_SIGNED(c, data[n], ==, v))
809 goto out;
810
811 Do_ADBG_EndSubCase(c, NULL);
812 }
813
814 for (n = 0; n < ARRAY_SIZE(data_str); n++) {
815 Do_ADBG_BeginSubCase(c, "\"%s\" (overflow)", data_str[n]);
816 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c,
817 &session, data_str[n], h)))
818 goto out;
819 if (!ADBG_EXPECT_TEEC_RESULT(c, TEE_ERROR_OVERFLOW,
820 cmd_get_value_s32(c, &session, h, &v)))
821 goto out;
822 Do_ADBG_EndSubCase(c, NULL);
823 }
824
825 out:
826 TEEC_CloseSession(&session);
827 }
828 ADBG_CASE_DEFINE(regression, 4103, test_4103,
829 "Test TEE Internal API Arithmetical API - S32");
830
compare_str(ADBG_Case_t * c,TEEC_Session * s,const char str1[],const char str2[],int32_t cmp_res)831 static TEEC_Result compare_str(ADBG_Case_t *c, TEEC_Session *s,
832 const char str1[], const char str2[],
833 int32_t cmp_res)
834 {
835 TEEC_Result res = TEEC_ERROR_GENERIC;
836 int32_t cres = 0;
837 uint32_t h1 = TA_CRYPT_ARITH_INVALID_HANDLE;
838 uint32_t h2 = TA_CRYPT_ARITH_INVALID_HANDLE;
839
840 res = cmd_new_var(c, s, 512, &h1);
841 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
842 goto out;
843 res = cmd_new_var(c, s, 512, &h2);
844 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
845 goto out;
846
847 res = convert_from_string(c, s, str1, h1);
848 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
849 goto out;
850 res = convert_from_string(c, s, str2, h2);
851 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
852 goto out;
853
854 res = cmd_cmp(c, s, h1, h2, &cres);
855 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
856 goto out;
857
858 ADBG_EXPECT_COMPARE_SIGNED(c, cres, ==, cmp_res);
859 out:
860 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, h1));
861 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, h2));
862 return res;
863 }
864
compare_s32(ADBG_Case_t * c,TEEC_Session * s,const char str[],int32_t val,int32_t cmp_res)865 static TEEC_Result compare_s32(ADBG_Case_t *c, TEEC_Session *s,
866 const char str[], int32_t val,
867 int32_t cmp_res)
868 {
869 TEEC_Result res = TEEC_ERROR_GENERIC;
870 int32_t cres = 0;
871 uint32_t h = TA_CRYPT_ARITH_INVALID_HANDLE;
872
873 res = cmd_new_var(c, s, 512, &h);
874 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
875 return res;
876
877 res = convert_from_string(c, s, str, h);
878 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
879 goto out;
880
881 res = cmd_cmp_s32(c, s, h, val, &cres);
882 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
883 goto out;
884
885 ADBG_EXPECT_COMPARE_SIGNED(c, cres, ==, cmp_res);
886 out:
887 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, h));
888
889 return res;
890 }
891
test_4104(ADBG_Case_t * c)892 static void test_4104(ADBG_Case_t *c)
893 {
894 TEEC_Session session = { };
895 uint32_t ret_orig = 0;
896 size_t n = 0;
897 const struct {
898 const char *str1;
899 const char *str2;
900 int32_t cmp_res;
901 } data[] = {
902 { "0", "1", -1 },
903 { "1", "0", 1 },
904 { "1", "2", -1 },
905 { "2", "1", 1 },
906 { "-1", "FFFFFFFFFF", -1 },
907 { "FFFFFFFFFF", "-1", 1 },
908 { "1", "-FFFFFFFFFF", 1 },
909 { "-FFFFFFFFFF", "1", -1 },
910 { "1", "100000000", -1 },
911 { "0", "0", 0 },
912 { "1", "1", 0 },
913 { "-1", "-1", 0}
914 };
915
916 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
917 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
918 NULL, &ret_orig)))
919 return;
920
921 Do_ADBG_BeginSubCase(c, "Compare bigints");
922 for (n = 0; n < ARRAY_SIZE(data); n++) {
923 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_str(c, &session,
924 data[n].str1, data[n].str2, data[n].cmp_res)))
925 goto out;
926 }
927 Do_ADBG_EndSubCase(c, "Compare bigints");
928
929 const struct {
930 const char *str;
931 int32_t val;
932 int32_t cmp_res;
933 } data_s32[] = {
934 {"0", 0, 0 },
935 {"0", 1, -1 },
936 {"1", 0, 1 },
937 {"0", -1, 1 },
938 {"-1", 0, -1 },
939 {"1", 1, 0 },
940 {"-1", -1, 0 },
941 {"-1", 1, -1 },
942 {"1", -1, 1 },
943 {"123", 0x123, 0 },
944 {"-123", -0x123, 0 },
945
946 /* corner case */
947 {"7FFFFFFF", INT32_MAX, 0 },
948 {"-7FFFFFFF", INT32_MIN, 1 },
949 {"7FFFFFFF", 0, 1 },
950 {"-7FFFFFFF", 0, -1 },
951 {"-80000000", INT32_MIN, 0 },
952 {"80000000", INT32_MAX, 1 },
953 {"-80000001", INT32_MIN, -1 },
954 {"-7FFFFFFF", INT32_MIN, 1 },
955
956 /* large BigInt */
957 {"1FFFFFFFF", 1, 1 },
958 {"-1FFFFFFFF", 1, -1 },
959 };
960
961 Do_ADBG_BeginSubCase(c, "Compare S32");
962 for (n = 0; n < ARRAY_SIZE(data_s32); n++) {
963 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_s32(c, &session,
964 data_s32[n].str, data_s32[n].val,
965 data_s32[n].cmp_res)))
966 goto out;
967 }
968 Do_ADBG_EndSubCase(c, "Compare S32");
969
970 out:
971 TEEC_CloseSession(&session);
972 }
973 ADBG_CASE_DEFINE(regression, 4104, test_4104,
974 "Test TEE Internal API Arithmetical API - Compare");
975
compare_handle(ADBG_Case_t * c,TEEC_Session * s,uint32_t hop1,uint32_t hop2,int32_t cmp_res)976 static TEEC_Result compare_handle(ADBG_Case_t *c, TEEC_Session *s,
977 uint32_t hop1, uint32_t hop2, int32_t cmp_res)
978 {
979 int32_t cres = 0;
980 TEEC_Result res = cmd_cmp(c, s, hop1, hop2, &cres);
981
982 if (!ADBG_EXPECT_TEEC_SUCCESS(c, res))
983 return res;
984 if (!ADBG_EXPECT_COMPARE_SIGNED(c, cres, ==, cmp_res))
985 return TEEC_ERROR_GENERIC;
986
987 return TEEC_SUCCESS;
988 }
989
do_addsub(ADBG_Case_t * c,TEEC_Session * s,const char * str_s,const char * str_t,const char * str_r)990 static bool do_addsub(ADBG_Case_t *c, TEEC_Session *s, const char *str_s,
991 const char *str_t, const char *str_r)
992 {
993 bool res = false;
994 uint32_t ha = TA_CRYPT_ARITH_INVALID_HANDLE;
995 uint32_t hb = TA_CRYPT_ARITH_INVALID_HANDLE;
996 uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE;
997 uint32_t hr = TA_CRYPT_ARITH_INVALID_HANDLE;
998
999 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 1024, &ha)))
1000 goto out;
1001 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 1024, &hb)))
1002 goto out;
1003 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 1024, &hc)))
1004 goto out;
1005 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 1024, &hr)))
1006 goto out;
1007
1008 /* First do the ADD dominated phase */
1009
1010 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_r, hr)))
1011 goto out;
1012 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_s, ha)))
1013 goto out;
1014 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_t, hb)))
1015 goto out;
1016
1017 /* hc = ha + hb */
1018 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_add(c, s, ha, hb, hc)))
1019 goto out;
1020 /* check hc == hr */
1021 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hr, 0)))
1022 goto out;
1023 /* ha = ha + hb */
1024 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_add(c, s, ha, hb, ha)))
1025 goto out;
1026 /* check ha == hr */
1027 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, ha, hr, 0)))
1028 goto out;
1029 /* ha = ha - hb */
1030 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_sub(c, s, ha, hb, ha)))
1031 goto out;
1032 /* hb = ha + hb */
1033 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_add(c, s, ha, hb, hb)))
1034 goto out;
1035 /* check hb == hr */
1036 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hb, hr, 0)))
1037 goto out;
1038
1039 /* Do the SUB dominated phase */
1040
1041 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_s, hr)))
1042 goto out;
1043 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_r, ha)))
1044 goto out;
1045 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_t, hb)))
1046 goto out;
1047
1048 /* hc = ha - hb */
1049 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_sub(c, s, ha, hb, hc)))
1050 goto out;
1051 /* check hc == hr */
1052 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hr, 0)))
1053 goto out;
1054 /* ha = ha - hb */
1055 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_sub(c, s, ha, hb, ha)))
1056 goto out;
1057 /* check ha == hr */
1058 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, ha, hr, 0)))
1059 goto out;
1060 /* ha = ha + hb */
1061 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_add(c, s, ha, hb, ha)))
1062 goto out;
1063 /* hb = ha - hb */
1064 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_sub(c, s, ha, hb, hb)))
1065 goto out;
1066 /* check hb == hr */
1067 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hb, hr, 0)))
1068 goto out;
1069
1070 res = true;
1071 out:
1072 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, ha));
1073 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hb));
1074 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc));
1075 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hr));
1076
1077 return res;
1078 }
1079
test_4105(ADBG_Case_t * c)1080 static void test_4105(ADBG_Case_t *c)
1081 {
1082 TEEC_Session session = { };
1083 uint32_t ret_orig = 0;
1084 size_t n = 0;
1085 static const struct {
1086 const char *s;
1087 const char *t;
1088 const char *r;
1089 } data[] = {
1090 { "1", "1", "2" },
1091 { "-1", "1", "0" },
1092 { "0", "0", "0" },
1093 { "0", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
1094 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" },
1095 /* single word, no carry */
1096 { "FF", "FF", "1FE" },
1097 /* single word, with carry */
1098 { "FFFFFFFF", "FFFFFFFF", "1FFFFFFFE" },
1099 /* mult word with partial carry */
1100 { "FFFFFFFF", "100000000FFFFFFFFFFFFFFFF",
1101 "10000000100000000FFFFFFFE" },
1102 /* mult word with carry all the way */
1103 { "FFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFF",
1104 "1FFFFFFFFFFFFFFFE" },
1105 /* single word, no carry */
1106 { "-FF", "-FF", "-1FE" },
1107 /* single word, with carry */
1108 { "-FFFFFFFF", "-FFFFFFFF", "-1FFFFFFFE" },
1109 /* mult word with partial carry */
1110 { "-FFFFFFFF", "-100000000FFFFFFFFFFFFFFFF",
1111 "-10000000100000000FFFFFFFE" },
1112 /* mult word with carry */
1113 { "-FFFFFFFFFFFFFFFF", "-FFFFFFFFFFFFFFFF",
1114 "-1FFFFFFFFFFFFFFFE" },
1115 /* single word, no carry */
1116 { "FFFF", "-FF", "FF00" },
1117 /* single word, with carry */
1118 { "F00000000", "-00000FFFF", "EFFFF0001" },
1119 /* multi words with carry */
1120 { "FFFFFFFF00000000", "-FFFFFFFF", "FFFFFFFE00000001" },
1121 { "10000000FFFFFFFF00000000", "-FFFFFFFF",
1122 "10000000FFFFFFFE00000001" },
1123 { "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
1124 "-FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE", "1" },
1125 { "FF", "-FFFF", "-FF00" },
1126 { "FFFFFFFF", "-1FFFFFFFF", "-100000000" },
1127 /* single word, no carry */
1128 { "-FFFF", "FF", "-FF00" },
1129 /* single word, with carry */
1130 { "-F00000000", "00000FFFF", "-EFFFF0001" },
1131 /* multi words with carry */
1132 { "-FFFFFFFF00000000", "FFFFFFFF", "-FFFFFFFE00000001" },
1133 { "-10000000FFFFFFFF00000000", "FFFFFFFF",
1134 "-10000000FFFFFFFE00000001" },
1135 { "-FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
1136 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE", "-1" },
1137 { "-FF", "FFFF", "FF00" },
1138 { "-FFFFFFFF", "1FFFFFFFF", "100000000" },
1139 };
1140
1141 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1142 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
1143 NULL, &ret_orig)))
1144 return;
1145
1146 for (n = 0; n < ARRAY_SIZE(data); n++) {
1147 if (!ADBG_EXPECT_TRUE(c, do_addsub(c, &session, data[n].s,
1148 data[n].t, data[n].r))) {
1149 Do_ADBG_Log("n %zu", n);
1150 break;
1151 }
1152 }
1153
1154 TEEC_CloseSession(&session);
1155 }
1156 ADBG_CASE_DEFINE(regression, 4105, test_4105,
1157 "Test TEE Internal API Arithmetical API - Add, Sub");
1158
test_4106(ADBG_Case_t * c)1159 static void test_4106(ADBG_Case_t *c)
1160 {
1161 TEEC_Session session = { };
1162 uint32_t ret_orig = 0;
1163 size_t n = 0;
1164 uint32_t h1 = TA_CRYPT_ARITH_INVALID_HANDLE;
1165 uint32_t h2 = TA_CRYPT_ARITH_INVALID_HANDLE;
1166 static const struct {
1167 const char *val;
1168 const char *neg_val;
1169 } data[] = {
1170 { "0", "0" },
1171 { "1", "-1" },
1172 { "123", "-123" },
1173 { "123456789123456789", "-123456789123456789" },
1174 };
1175
1176 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1177 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
1178 NULL, &ret_orig)))
1179 return;
1180
1181 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, &session, 1024, &h1)))
1182 goto out;
1183 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, &session, 1024, &h2)))
1184 goto out;
1185
1186 for (n = 0; n < ARRAY_SIZE(data); n++) {
1187 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c,
1188 &session, data[n].val, h1)))
1189 goto out;
1190
1191 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c,
1192 &session, data[n].neg_val, h2)))
1193 goto out;
1194
1195 if (n && !ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c,
1196 &session, h1, h2, 1)))
1197 goto out;
1198
1199 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_neg(c, &session, h1, h1)))
1200 goto out;
1201 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, &session,
1202 h1, h2, 0)))
1203 goto out;
1204 }
1205 out:
1206 TEEC_CloseSession(&session);
1207 }
1208 ADBG_CASE_DEFINE(regression, 4106, test_4106,
1209 "Test TEE Internal API Arithmetical API - Neg");
1210
do_mul(ADBG_Case_t * c,TEEC_Session * s,const char * str_s,const char * str_t,const char * str_r)1211 static bool do_mul(ADBG_Case_t *c, TEEC_Session *s, const char *str_s,
1212 const char *str_t, const char *str_r)
1213 {
1214 bool res = false;
1215 uint32_t ha = TA_CRYPT_ARITH_INVALID_HANDLE;
1216 uint32_t hb = TA_CRYPT_ARITH_INVALID_HANDLE;
1217 uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE;
1218 uint32_t hr = TA_CRYPT_ARITH_INVALID_HANDLE;
1219
1220 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 1024, &ha)))
1221 goto out;
1222 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 1024, &hb)))
1223 goto out;
1224 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hc)))
1225 goto out;
1226 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hr)))
1227 goto out;
1228
1229 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_r, hr)))
1230 goto out;
1231 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_s, ha)))
1232 goto out;
1233 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_t, hb)))
1234 goto out;
1235
1236 /* hc = ha * hb */
1237 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mul(c, s, ha, hb, hc)))
1238 goto out;
1239 /* check hc == hr */
1240 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hr, 0)))
1241 goto out;
1242 /* ha = ha * hb */
1243 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mul(c, s, ha, hb, ha)))
1244 goto out;
1245 /* check ha == hr */
1246 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, ha, hr, 0)))
1247 goto out;
1248
1249 res = true;
1250 out:
1251 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, ha));
1252 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hb));
1253 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc));
1254 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hr));
1255
1256 return res;
1257 }
1258
test_4107(ADBG_Case_t * c)1259 static void test_4107(ADBG_Case_t *c)
1260 {
1261 TEEC_Session session = { };
1262 uint32_t ret_orig = 0;
1263 size_t n = 0;
1264 static const struct {
1265 const char *s;
1266 const char *t;
1267 const char *r;
1268 } data[] = {
1269 { "0", "0", "0" },
1270 { "0", "FFFFFFFF", "0" },
1271 { "1", "1", "1" },
1272 { "-1", "1", "-1" },
1273 { "-1", "-1", "1" },
1274 { "FF", "1", "FF" },
1275 { "2", "2", "4" },
1276 { "3", "3", "9" },
1277 { "100", "100", "10000" },
1278 { "FFFFFFFF", "FFFFFFFF", "FFFFFFFE00000001" },
1279 { "4F239BBAE89A447149CDB0B50A103C69591DD9E0C91A57955A6C266"
1280 "C7ED42A5ED5F4",
1281 "44FF5A67036657E041D55AE42AE25517A1",
1282 "155465C8221717FFC135C87ABF6D34184DF5E6906D2EBA7C364879AA"
1283 "0BE840FD06F1E0A7036BC3B7B1844FF95F07A39CE17A74" },
1284 { "4F239BBAE89A447149CDB0B50A103C69591DD9E0C91A57955A6C266C"
1285 "7ED42A5ED5F4",
1286 "-44FF5A67036657E041D55AE42AE25517A1",
1287 "-155465C8221717FFC135C87ABF6D34184DF5E6906D2EBA7C364879A"
1288 "A0BE840FD06F1E0A7036BC3B7B1844FF95F07A39CE17A74" },
1289 { "-4F239BBAE89A447149CDB0B50A103C69591DD9E0C91A57955A6C266"
1290 "C7ED42A5ED5F4",
1291 "-44FF5A67036657E041D55AE42AE25517A1",
1292 "155465C8221717FFC135C87ABF6D34184DF5E6906D2EBA7C364879AA"
1293 "0BE840FD06F1E0A7036BC3B7B1844FF95F07A39CE17A74" },
1294 };
1295
1296 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1297 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
1298 NULL, &ret_orig)))
1299 return;
1300
1301 for (n = 0; n < ARRAY_SIZE(data); n++) {
1302 if (!ADBG_EXPECT_TRUE(c, do_mul(c, &session, data[n].s,
1303 data[n].t, data[n].r))) {
1304 Do_ADBG_Log("n %zu", n);
1305 break;
1306 }
1307 }
1308
1309 TEEC_CloseSession(&session);
1310 }
1311 ADBG_CASE_DEFINE(regression, 4107, test_4107,
1312 "Test TEE Internal API Arithmetical API - Mul");
1313
do_div(ADBG_Case_t * c,TEEC_Session * s,const char * str_s,const char * str_t,const char * str_out,int32_t qsign,int32_t rsign)1314 static bool do_div(ADBG_Case_t *c, TEEC_Session *s, const char *str_s,
1315 const char *str_t, const char *str_out, int32_t qsign,
1316 int32_t rsign)
1317 {
1318 bool res = false;
1319 int32_t cres = 0;
1320 uint32_t hn = TA_CRYPT_ARITH_INVALID_HANDLE;
1321 uint32_t hd = TA_CRYPT_ARITH_INVALID_HANDLE;
1322 uint32_t hq = TA_CRYPT_ARITH_INVALID_HANDLE;
1323 uint32_t hr = TA_CRYPT_ARITH_INVALID_HANDLE;
1324 uint32_t hv = TA_CRYPT_ARITH_INVALID_HANDLE;
1325 uint32_t hout = TA_CRYPT_ARITH_INVALID_HANDLE;
1326
1327 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hn)))
1328 goto out;
1329 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hd)))
1330 goto out;
1331 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hq)))
1332 goto out;
1333 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hr)))
1334 goto out;
1335 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hv)))
1336 goto out;
1337
1338 if (str_out) {
1339 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1340 cmd_new_var(c, s, 2048, &hout)))
1341 goto out;
1342 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1343 convert_from_string(c, s, str_out, hout)))
1344 goto out;
1345 }
1346
1347 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_s, hn)))
1348 goto out;
1349 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_t, hd)))
1350 goto out;
1351
1352 /* (hq, hr) = n / d */
1353 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_div(c, s, hn, hd, hq, hr)))
1354 goto out;
1355 if (str_out) {
1356 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1357 compare_handle(c, s, hq, hout, 0)))
1358 goto out;
1359 }
1360
1361 /* hv = hq * hd */
1362 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mul(c, s, hq, hd, hv)))
1363 goto out;
1364 /* hv = hv + hr */
1365 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_add(c, s, hv, hr, hv)))
1366 goto out;
1367 /* check hn == hv */
1368 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hn, hv, 0)))
1369 goto out;
1370
1371 if (qsign) {
1372 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1373 cmd_cmp_s32(c, s, hq, 0, &cres)))
1374 goto out;
1375 if (!ADBG_EXPECT_COMPARE_SIGNED(c, cres, ==, qsign))
1376 goto out;
1377 }
1378
1379 if (rsign) {
1380 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1381 cmd_cmp_s32(c, s, hr, 0, &cres)))
1382 goto out;
1383 if (!ADBG_EXPECT_COMPARE_SIGNED(c, cres, ==, rsign))
1384 goto out;
1385 }
1386
1387 res = true;
1388 out:
1389 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hn));
1390 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hd));
1391 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hq));
1392 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hr));
1393 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hv));
1394 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hout));
1395
1396 return res;
1397 }
1398
test_4108(ADBG_Case_t * c)1399 static void test_4108(ADBG_Case_t *c)
1400 {
1401 TEEC_Session session = { };
1402 uint32_t ret_orig = 0;
1403 size_t n = 0;
1404 static const struct {
1405 const char *s;
1406 const char *t;
1407 const char *out;
1408 int32_t qsign;
1409 int32_t rsign;
1410 } data[] = {
1411 { "811111100000000112345678", "8000000012345678" },
1412 { "0", "1", "0" },
1413 { "1", "1", "1" },
1414 { "b7fb", "5", "24CB" },
1415 { "124378912734891273894712890347102358129034789120374",
1416 "1984086C15FA011154C86FA68", "B73D14EC7205D3311F6E78411D" },
1417 { "124378912734891273894712890347102358129034789120374",
1418 "1984086C15FA011154C86FA68" },
1419 { "-124378912734891273894712890347102358129034789120374",
1420 "1984086C15FA011154C86FA68" },
1421 { "124378912734891273894712890347102358129034789120374",
1422 "-1984086C15FA011154C86FA68" },
1423 { "-124378912734891273894712890347102358129034789120374",
1424 "-1984086C15FA011154C86FA68" },
1425 { "12345678", "10" },
1426 { "-12345678", "10" },
1427 { "12345678", "-10" },
1428 { "-12345678", "-10" },
1429 { "12345678901234567890123456789012345678901", "10" },
1430 { "1234567890123456789012345678901234567890", "10" },
1431 { "123456789012345678901234567890123456789", "10" },
1432 { "53", "7", NULL, 1, 1 },
1433 { "-53", "7", NULL, -1, -1 },
1434 { "53", "-7", NULL, -1, 1 },
1435 { "-53", "-7", NULL, 1, -1 },
1436 { "123456789abcdef123456789abcdef", "fedcba98765432100",
1437 NULL, 1, 1 },
1438 { "-123456789abcdef123456789abcdef", "fedcba98765432100",
1439 NULL, -1, -1 },
1440 { "123456789abcdef123456789abcdef", "-fedcba98765432100",
1441 NULL, -1, 1 },
1442 { "-123456789abcdef123456789abcdef", "-fedcba98765432100",
1443 NULL, 1, -1 },
1444 };
1445
1446 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1447 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
1448 NULL, &ret_orig)))
1449 return;
1450
1451 for (n = 0; n < ARRAY_SIZE(data); n++) {
1452 if (!ADBG_EXPECT_TRUE(c, do_div(c, &session, data[n].s,
1453 data[n].t, data[n].out, data[n].qsign,
1454 data[n].rsign))) {
1455 Do_ADBG_Log("n %zu", n);
1456 break;
1457 }
1458 }
1459
1460 TEEC_CloseSession(&session);
1461 }
1462 ADBG_CASE_DEFINE(regression, 4108, test_4108,
1463 "Test TEE Internal API Arithmetical API - Div");
1464
1465 static const struct {
1466 const char *op;
1467 const char *n;
1468 const char *res;
1469 } test_4109_data[] = {
1470 { "10", "A", "6" },
1471 { "10", "20", "10" },
1472 { "-1", "123", "122" },
1473 { "-122", "123", "1" },
1474 { "-1", "100000000000000000000", "FFFFFFFFFFFFFFFFFFFF" },
1475
1476 { "42176E7CD0386C94194C3C3DACFA7237"
1477 "CCF4E0829E2EBEAB59DE12CAE3305C9E"
1478 "576F837A42D9C13BB1D83E4DFD330B65"
1479 "76FD516B2AE9FBDD152F0A820C5DD18E"
1480 "D048D476EC791DC989D6D8C30B2B30FF"
1481 "C2A4ABAC082C672B38E138610B74CE0C"
1482 "30D1B378BE6FE0C44E09EC11586245CD"
1483 "8F1216619392E6B2C857C71EA78DD4D8"
1484 "61A482D9D1251C341D1D6205AFB2BFB5"
1485 "3DD1F272B5624FA61B020936745387CD"
1486 "F1F3EBC4435CBE6C6B323497098FDE9D"
1487 "61AA0CC87416235E706A71F73EC3C291"
1488 "D9ACA2EECD712DA40966DD251310AE94"
1489 "9713F69B2A32E42732A7F6669547D88A"
1490 "415B25C582FDBBF06C5EC5F5750053D4"
1491 "9F7ED68DED168C92F9C531828A",
1492 "A9A9C49F0015DBEF9EB0D927F379821AE2C59",
1493 "3460EB99F07BC4617A7586E6522B98F66E5B2" },
1494
1495 { "42176E7CD0386C94194C3C3DACFA7237"
1496 "CCF4E0829E2EBEAB59DE12CAE3305C9E"
1497 "576F837A42D9C13BB1D83E4DFD330B65"
1498 "76FD516B2AE9FBDD152F0A820C5DD18E"
1499 "D048D476EC791DC989D6D8C30B2B30FF"
1500 "C2A4ABAC082C672B38E138610B74CE0C"
1501 "30D1B378BE6FE0C44E09EC11586245CD"
1502 "8F1216619392E6B2C857C71EA78DD4D8"
1503 "61A482D9D1251C341D1D6205AFB2BFB5"
1504 "3DD1F272B5624FA61B020936745387CD"
1505 "F1F3EBC4435CBE6C6B323497098FDE9D"
1506 "61AA0CC87416235E706A71F73EC3C291"
1507 "D9ACA2EECD712DA40966DD251310AE94"
1508 "9713F69B2A32E42732A7F6669547D88A"
1509 "415B25C582FDBBF06C5EC5F5750053D4"
1510 "9F7ED68DED168C92F9C531828A",
1511 "1234", "1082" },
1512
1513 { "FFFF6E7CD0386C94194C3C3DACFA7237"
1514 "CCF4E0829E2EBEAB59DE12CAE3305C9E"
1515 "576F837A42D9C13BB1D83E4DFD330B65"
1516 "76FD516B2AE9FBDD152F0A820C5DD18E"
1517 "D048D476EC791DC989D6D8C30B2B30FF"
1518 "C2A4ABAC082C672B38E138610B74CE0C"
1519 "30D1B378BE6FE0C44E09EC11586245CD"
1520 "8F1216619392E6B2C857C71EA78DD4D8"
1521 "61A482D9D1251C341D1D6205AFB2BFB5"
1522 "3DD1F272B5624FA61B020936745387CD"
1523 "F1F3EBC4435CBE6C6B323497098FDE9D"
1524 "61AA0CC87416235E706A71F73EC3C291"
1525 "D9ACA2EECD712DA40966DD251310AE94"
1526 "9713F69B2A32E42732A7F6669547D88A"
1527 "415B25C582FDBBF06C5EC5F5750053D4"
1528 "9F7ED68DED168C92F9C531828A",
1529 "2", "0" },
1530
1531 { "FFFF6E7CD0386C94194C3C3DACFA7237"
1532 "CCF4E0829E2EBEAB59DE12CAE3305C9E"
1533 "576F837A42D9C13BB1D83E4DFD330B65"
1534 "76FD516B2AE9FBDD152F0A820C5DD18E"
1535 "D048D476EC791DC989D6D8C30B2B30FF"
1536 "C2A4ABAC082C672B38E138610B74CE0C"
1537 "30D1B378BE6FE0C44E09EC11586245CD"
1538 "8F1216619392E6B2C857C71EA78DD4D8"
1539 "61A482D9D1251C341D1D6205AFB2BFB5"
1540 "3DD1F272B5624FA61B020936745387CD"
1541 "F1F3EBC4435CBE6C6B323497098FDE9D"
1542 "61AA0CC87416235E706A71F73EC3C291"
1543 "D9ACA2EECD712DA40966DD251310AE94"
1544 "9713F69B2A32E42732A7F6669547D88A"
1545 "415B25C582FDBBF06C5EC5F5750053D4"
1546 "9F7ED68DED168C92F9C531828A",
1547 "FFFF6E7CD0386C94194C3C3DACFA7237"
1548 "CCF4E0829E2EBEAB59DE12CAE3305C9E"
1549 "576F837A42D9C13BB1D83E4DFD330B65"
1550 "76FD516B2AE9FBDD152F0A820C5DD18E"
1551 "D048D476EC791DC989D6D8C30B2B30FF"
1552 "C2A4ABAC082C672B38E138610B74CE0C"
1553 "30D1B378BE6FE0C44E09EC11586245CD"
1554 "8F1216619392E6B2C857C71EA78DD4D8"
1555 "61A482D9D1251C341D1D6205AFB2BFB5"
1556 "3DD1F272B5624FA61B020936745387CD"
1557 "F1F3EBC4435CBE6C6B323497098FDE9D"
1558 "61AA0CC87416235E706A71F73EC3C291"
1559 "D9ACA2EECD712DA40966DD251310AE94"
1560 "9713F69B2A32E42732A7F6669547D88A"
1561 "415B25C582FDBBF06C5EC5F5750053D4"
1562 "9F7ED68DED168C92F9C531828A",
1563 "0" },
1564
1565 { "FFFF6E7CD0386C94194C3C3DACFA7237"
1566 "CCF4E0829E2EBEAB59DE12CAE3305C9E"
1567 "576F837A42D9C13BB1D83E4DFD330B65"
1568 "76FD516B2AE9FBDD152F0A820C5DD18E"
1569 "D048D476EC791DC989D6D8C30B2B30FF"
1570 "C2A4ABAC082C672B38E138610B74CE0C"
1571 "30D1B378BE6FE0C44E09EC11586245CD"
1572 "8F1216619392E6B2C857C71EA78DD4D8"
1573 "61A482D9D1251C341D1D6205AFB2BFB5"
1574 "3DD1F272B5624FA61B020936745387CD"
1575 "F1F3EBC4435CBE6C6B323497098FDE9D"
1576 "61AA0CC87416235E706A71F73EC3C291"
1577 "D9ACA2EECD712DA40966DD251310AE94"
1578 "9713F69B2A32E42732A7F6669547D88A"
1579 "415B25C582FDBBF06C5EC5F5750053D4"
1580 "9F7ED68DED168C92F9C531828A",
1581 "FFFF6E7CD0386C94194C3C3DACFA7237"
1582 "CCF4E0829E2EBEAB59DE12CAE3305C9E"
1583 "576F837A42D9C13BB1D83E4DFD330B65"
1584 "76FD516B2AE9FBDD152F0A820C5DD18E"
1585 "D048D476EC791DC989D6D8C30B2B30FF"
1586 "C2A4ABAC082C672B38E138610B74CE0C"
1587 "30D1B378BE6FE0C44E09EC11586245CD"
1588 "8F1216619392E6B2C857C71EA78DD4D8"
1589 "61A482D9D1251C341D1D6205AFB2BFB5"
1590 "3DD1F272B5624FA61B020936745387CD"
1591 "F1F3EBC4435CBE6C6B323497098FDE9D"
1592 "61AA0CC87416235E706A71F73EC3C291"
1593 "D9ACA2EECD712DA40966DD251310AE94"
1594 "9713F69B2A32E42732A7F6669547D88A"
1595 "415B25C582FDBBF06C5EC5F5750053D4"
1596 "9F7ED68DED168C92F9C531828B",
1597 "FFFF6E7CD0386C94194C3C3DACFA7237"
1598 "CCF4E0829E2EBEAB59DE12CAE3305C9E"
1599 "576F837A42D9C13BB1D83E4DFD330B65"
1600 "76FD516B2AE9FBDD152F0A820C5DD18E"
1601 "D048D476EC791DC989D6D8C30B2B30FF"
1602 "C2A4ABAC082C672B38E138610B74CE0C"
1603 "30D1B378BE6FE0C44E09EC11586245CD"
1604 "8F1216619392E6B2C857C71EA78DD4D8"
1605 "61A482D9D1251C341D1D6205AFB2BFB5"
1606 "3DD1F272B5624FA61B020936745387CD"
1607 "F1F3EBC4435CBE6C6B323497098FDE9D"
1608 "61AA0CC87416235E706A71F73EC3C291"
1609 "D9ACA2EECD712DA40966DD251310AE94"
1610 "9713F69B2A32E42732A7F6669547D88A"
1611 "415B25C582FDBBF06C5EC5F5750053D4"
1612 "9F7ED68DED168C92F9C531828A" },
1613 };
1614
test_4109_mod(ADBG_Case_t * c,TEEC_Session * s,const char * str_op,const char * str_n,const char * str_res)1615 static bool test_4109_mod(ADBG_Case_t *c, TEEC_Session *s, const char *str_op,
1616 const char *str_n, const char *str_res)
1617 {
1618 bool res = false;
1619 uint32_t hop = TA_CRYPT_ARITH_INVALID_HANDLE;
1620 uint32_t hn = TA_CRYPT_ARITH_INVALID_HANDLE;
1621 uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE;
1622 uint32_t hres = TA_CRYPT_ARITH_INVALID_HANDLE;
1623
1624 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hop)))
1625 goto out;
1626 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hn)))
1627 goto out;
1628 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hc)))
1629 goto out;
1630 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hres)))
1631 goto out;
1632
1633 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1634 convert_from_string(c, s, str_res, hres)))
1635 goto out;
1636 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1637 convert_from_string(c, s, str_op, hop)))
1638 goto out;
1639 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1640 convert_from_string(c, s, str_n, hn)))
1641 goto out;
1642
1643 /* hc = hop mod hn */
1644 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mod(c, s, hop, hn, hc)))
1645 goto out;
1646 /* check hc == hres */
1647 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hres, 0)))
1648 goto out;
1649
1650 res = true;
1651 out:
1652 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop));
1653 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hn));
1654 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc));
1655 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hres));
1656
1657 return res;
1658 }
1659
test_4109(ADBG_Case_t * c)1660 static void test_4109(ADBG_Case_t *c)
1661 {
1662 TEEC_Session session = { };
1663 uint32_t ret_orig = 0;
1664 size_t n = 0;
1665
1666 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1667 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
1668 NULL, &ret_orig)))
1669 return;
1670
1671 for (n = 0; n < ARRAY_SIZE(test_4109_data); n++) {
1672 if (!ADBG_EXPECT_TRUE(c, test_4109_mod(c, &session,
1673 test_4109_data[n].op, test_4109_data[n].n,
1674 test_4109_data[n].res))) {
1675 Do_ADBG_Log("n %zu", n);
1676 break;
1677 }
1678 }
1679
1680 TEEC_CloseSession(&session);
1681 }
1682 ADBG_CASE_DEFINE(regression, 4109, test_4109,
1683 "Test TEE Internal API Arithmetical API - Mod");
1684
1685 static const char n2048str[] = "F9000000000000000000000000000000"
1686 "00000000000000000000000000000000"
1687 "00000000000000000000000000000000"
1688 "00000000000000000000000000000000"
1689 "00000000000000000000000000000000"
1690 "00000000000000000000000000000000"
1691 "00000000000000000000000000000000"
1692 "00000000000000000000000000000000"
1693 "00000000000000000000000000000000"
1694 "00000000000000000000000000000000"
1695 "00000000000000000000000000000000"
1696 "00000000000000000000000000000000"
1697 "00000000000000000000000000000000"
1698 "00000000000000000000000000000000"
1699 "00000000000000000000000000000000"
1700 "000000000000000000000000000005C5";
1701
1702 static const struct {
1703 const char *op1;
1704 const char *op2;
1705 const char *n;
1706 const char *addres;
1707 const char *mulres;
1708 } test_4110_data[] = {
1709 { "0", "0", "2", "0", "0" },
1710 { "1", "1", "2", "0", "1" },
1711 { "2", "2", "9", "4", "4" },
1712 { "123", "123", "200", "46", "C9" },
1713 { "0", "123", "200", "123", "0" },
1714 { "123", "0", "200", "123", "0" },
1715
1716 /* Testing some 2048 bit numbers */
1717 { "F9000000000000000000000000000000"
1718 "00000000000000000000000000000000"
1719 "00000000000000000000000000000000"
1720 "00000000000000000000000000000000"
1721 "00000000000000000000000000000000"
1722 "00000000000000000000000000000000"
1723 "00000000000000000000000000000000"
1724 "00000000000000000000000000000000"
1725 "00000000000000000000000000000000"
1726 "00000000000000000000000000000000"
1727 "00000000000000000000000000000000"
1728 "00000000000000000000000000000000"
1729 "00000000000000000000000000000000"
1730 "00000000000000000000000000000000"
1731 "00000000000000000000000000000000"
1732 "00000000000000000000000000000000"
1733 ,
1734 "F9000000000000000000000000000000"
1735 "00000000000000000000000000000000"
1736 "00000000000000000000000000000000"
1737 "00000000000000000000000000000000"
1738 "00000000000000000000000000000000"
1739 "00000000000000000000000000000000"
1740 "00000000000000000000000000000000"
1741 "00000000000000000000000000000000"
1742 "00000000000000000000000000000000"
1743 "00000000000000000000000000000000"
1744 "00000000000000000000000000000000"
1745 "00000000000000000000000000000000"
1746 "00000000000000000000000000000000"
1747 "00000000000000000000000000000000"
1748 "00000000000000000000000000000000"
1749 "00000000000000000000000000000001",
1750 n2048str,
1751 "F8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1752 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1753 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1754 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1755 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1756 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1757 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1758 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1759 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1760 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1761 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1762 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1763 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1764 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1765 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1766 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFA3C",
1767 "2143D4" },
1768
1769 { "F9000000000000000000000000000000"
1770 "00000000000000000000000000000000"
1771 "00000000000000000000000000000000"
1772 "00000000000000000000000000000000"
1773 "00000000000000000000000000000000"
1774 "00000000000000000000000000000000"
1775 "00000000000000000000000000000000"
1776 "00000000000000000000000000000000"
1777 "00000000000000000000000000000000"
1778 "00000000000000000000000000000000"
1779 "00000000000000000000000000000000"
1780 "00000000000000000000000000000000"
1781 "00000000000000000000000000000000"
1782 "00000000000000000000000000000000"
1783 "00000000000000000000000000000000"
1784 "00000000000000000000000000000000",
1785 "5C5", n2048str, "0",
1786 "F8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1787 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1788 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1789 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1790 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1791 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1792 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1793 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1794 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1795 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1796 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1797 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1798 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1799 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1800 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
1801 "FFFFFFFFFFFFFFFFFFFFFFFFFFDEBC2C" },
1802 };
1803
test_4110_mod(ADBG_Case_t * c,TEEC_Session * s,const char * str_op1,const char * str_op2,const char * str_n,const char * str_add_res,const char * str_mul_res)1804 static bool test_4110_mod(ADBG_Case_t *c, TEEC_Session *s,
1805 const char *str_op1, const char *str_op2,
1806 const char *str_n, const char *str_add_res,
1807 const char *str_mul_res)
1808 {
1809 bool res = false;
1810 uint32_t hop1 = TA_CRYPT_ARITH_INVALID_HANDLE;
1811 uint32_t hop2 = TA_CRYPT_ARITH_INVALID_HANDLE;
1812 uint32_t hn = TA_CRYPT_ARITH_INVALID_HANDLE;
1813 uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE;
1814 uint32_t haddres = TA_CRYPT_ARITH_INVALID_HANDLE;
1815 uint32_t hmulres = TA_CRYPT_ARITH_INVALID_HANDLE;
1816
1817 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hop1)))
1818 goto out;
1819 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hop2)))
1820 goto out;
1821 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hn)))
1822 goto out;
1823 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hc)))
1824 goto out;
1825 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &haddres)))
1826 goto out;
1827 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hmulres)))
1828 goto out;
1829
1830 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1831 convert_from_string(c, s, str_add_res, haddres)))
1832 goto out;
1833 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1834 convert_from_string(c, s, str_mul_res, hmulres)))
1835 goto out;
1836 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1837 convert_from_string(c, s, str_op1, hop1)))
1838 goto out;
1839 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1840 convert_from_string(c, s, str_op2, hop2)))
1841 goto out;
1842 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1843 convert_from_string(c, s, str_n, hn)))
1844 goto out;
1845
1846 /* hc = (hop1 + hop2) mod hn */
1847 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_addmod(c, s, hop1, hop2, hn, hc)))
1848 goto out;
1849 /* check hc == haddres */
1850 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, haddres, 0)))
1851 goto out;
1852 /* hc = (haddres - hop2) mod hn */
1853 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_submod(c, s, haddres, hop2, hn,
1854 hc)))
1855 goto out;
1856 /* check hc == hop1 */
1857 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hop1, 0)))
1858 goto out;
1859
1860 /* hc = (hop1 * hop2) mod hn */
1861 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mulmod(c, s, hop1, hop2, hn, hc)))
1862 goto out;
1863 /* check hc == hmulres */
1864 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hmulres, 0)))
1865 goto out;
1866
1867 res = true;
1868 out:
1869 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop1));
1870 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop2));
1871 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hn));
1872 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc));
1873 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, haddres));
1874 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hmulres));
1875
1876 return res;
1877 }
1878
test_4110_fmm(ADBG_Case_t * c,TEEC_Session * s,const char * str_op1,const char * str_op2,const char * str_n,const char * str_res)1879 static bool test_4110_fmm(ADBG_Case_t *c, TEEC_Session *s,
1880 const char *str_op1, const char *str_op2,
1881 const char *str_n, const char *str_res)
1882 {
1883 bool res = false;
1884 uint32_t hop1 = TA_CRYPT_ARITH_INVALID_HANDLE;
1885 uint32_t hop2 = TA_CRYPT_ARITH_INVALID_HANDLE;
1886 uint32_t hn = TA_CRYPT_ARITH_INVALID_HANDLE;
1887 uint32_t hres = TA_CRYPT_ARITH_INVALID_HANDLE;
1888 uint32_t hfmmres = TA_CRYPT_ARITH_INVALID_HANDLE;
1889 uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE;
1890 uint32_t hctx = TA_CRYPT_ARITH_INVALID_HANDLE;
1891 uint32_t nbitsize = 0;
1892 uint32_t n_is_odd = 0;
1893
1894 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_fmm_var(c, s, 2048, &hop1)))
1895 goto out;
1896 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_fmm_var(c, s, 2048, &hop2)))
1897 goto out;
1898 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hn)))
1899 goto out;
1900 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hres)))
1901 goto out;
1902 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_fmm_var(c, s, 2048, &hfmmres)))
1903 goto out;
1904 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hc)))
1905 goto out;
1906
1907 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_n, hn)))
1908 goto out;
1909 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1910 convert_from_string(c, s, str_res, hres)))
1911 goto out;
1912 /* Check if FMM is applicable on this modulus */
1913 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_get_bit(c, s, hn, 0, &n_is_odd)))
1914 goto out;
1915 if (!n_is_odd) {
1916 res = true;
1917 goto out;
1918 }
1919
1920 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1921 cmd_get_bit_count(c, s, hn, &nbitsize)))
1922 goto out;
1923
1924 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1925 cmd_new_fmm_ctx(c, s, nbitsize, hn, &hctx)))
1926 goto out;
1927
1928 /* hop1 */
1929 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1930 convert_from_string(c, s, str_op1, hc)))
1931 goto out;
1932 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_to_fmm(c, s, hc, hn, hctx, hop1)))
1933 goto out;
1934
1935 /* hop2 */
1936 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1937 convert_from_string(c, s, str_op2, hc)))
1938 goto out;
1939 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_to_fmm(c, s, hc, hn, hctx, hop2)))
1940 goto out;
1941
1942 /* hfmmres = hop1 * hop2 */
1943 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1944 cmd_compute_fmm(c, s, hop1, hop2, hn, hctx, hfmmres)))
1945 goto out;
1946 /* hc = hfmmres mod hn*/
1947 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1948 cmd_from_fmm(c, s, hfmmres, hn, hctx, hc)))
1949 goto out;
1950 /* check hc == hres */
1951 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hres, 0)))
1952 goto out;
1953
1954 res = true;
1955 out:
1956 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop1));
1957 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop2));
1958 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hn));
1959 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hres));
1960 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hfmmres));
1961 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc));
1962 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hctx));
1963 return res;
1964 }
1965
test_4110(ADBG_Case_t * c)1966 static void test_4110(ADBG_Case_t *c)
1967 {
1968 TEEC_Session session = { };
1969 uint32_t ret_orig = 0;
1970 size_t n = 0;
1971
1972 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
1973 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
1974 NULL, &ret_orig)))
1975 return;
1976
1977 for (n = 0; n < ARRAY_SIZE(test_4110_data); n++) {
1978 if (!ADBG_EXPECT_TRUE(c, test_4110_mod(c, &session,
1979 test_4110_data[n].op1, test_4110_data[n].op2,
1980 test_4110_data[n].n,
1981 test_4110_data[n].addres,
1982 test_4110_data[n].mulres))) {
1983 Do_ADBG_Log("n %zu", n);
1984 break;
1985 }
1986 if (!ADBG_EXPECT_TRUE(c, test_4110_fmm(c, &session,
1987 test_4110_data[n].op1, test_4110_data[n].op2,
1988 test_4110_data[n].n,
1989 test_4110_data[n].mulres))) {
1990 Do_ADBG_Log("n %zu", n);
1991 break;
1992 }
1993 }
1994
1995 TEEC_CloseSession(&session);
1996 }
1997 ADBG_CASE_DEFINE(regression, 4110, test_4110,
1998 "Test TEE Internal API Arithmetical API - Mod arith");
1999
2000 static const struct {
2001 const char *op;
2002 const char *n;
2003 const char *res;
2004 } test_4111_data[] = {
2005 { "2", "3", "2" },
2006 { "3", "7", "5" },
2007 { "5", "7", "3" },
2008 { "7B", "FA1", "8E5" },
2009 { "462D578CF0F88", "AB54A98CEB1F0AD3", "5ABBF22B54DBD000" },
2010 { "7", n2048str,
2011 "B1DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6"
2012 "DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB"
2013 "6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6D"
2014 "B6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6"
2015 "DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB"
2016 "6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6D"
2017 "B6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6"
2018 "DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB"
2019 "6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6D"
2020 "B6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6"
2021 "DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB"
2022 "6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6D"
2023 "B6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6"
2024 "DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB"
2025 "6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6D"
2026 "B6DB6DB6DB6DB6DB6DB6DB6DB6DB71D6" },
2027 };
2028
test_4111_invmod(ADBG_Case_t * c,TEEC_Session * s,const char * str_op,const char * str_n,const char * str_res)2029 static bool test_4111_invmod(ADBG_Case_t *c, TEEC_Session *s,
2030 const char *str_op, const char *str_n,
2031 const char *str_res)
2032 {
2033 bool res = false;
2034 uint32_t hop = TA_CRYPT_ARITH_INVALID_HANDLE;
2035 uint32_t hn = TA_CRYPT_ARITH_INVALID_HANDLE;
2036 uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE;
2037 uint32_t hres = TA_CRYPT_ARITH_INVALID_HANDLE;
2038 int32_t cres = 0;
2039
2040 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hop)))
2041 goto out;
2042 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hn)))
2043 goto out;
2044 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hc)))
2045 goto out;
2046 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hres)))
2047 goto out;
2048
2049 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
2050 convert_from_string(c, s, str_res, hres)))
2051 goto out;
2052 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
2053 convert_from_string(c, s, str_op, hop)))
2054 goto out;
2055 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
2056 convert_from_string(c, s, str_n, hn)))
2057 goto out;
2058
2059 /* hc = hop^-1 mod hn */
2060 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_invmod(c, s, hop, hn, hc)))
2061 goto out;
2062 /* check hc == hres */
2063 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hres, 0)))
2064 goto out;
2065
2066 /* hc = (hres * hop) mod hn */
2067 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mulmod(c, s, hres, hop, hn, hc)))
2068 goto out;
2069 /* check hc == 1 */
2070 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_cmp_s32(c, s, hc, 1, &cres)))
2071 goto out;
2072 if (!ADBG_EXPECT_COMPARE_SIGNED(c, cres, ==, 0))
2073 goto out;
2074
2075 /* hc = hres^-1 mod hn */
2076 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_invmod(c, s, hres, hn, hc)))
2077 goto out;
2078 /* check hc == hop */
2079 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hop, 0)))
2080 goto out;
2081
2082 res = true;
2083 out:
2084 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop));
2085 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hn));
2086 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc));
2087 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hres));
2088
2089 return res;
2090 }
2091
test_4111(ADBG_Case_t * c)2092 static void test_4111(ADBG_Case_t *c)
2093 {
2094 TEEC_Session session = { };
2095 uint32_t ret_orig = 0;
2096 size_t n = 0;
2097
2098 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
2099 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
2100 NULL, &ret_orig)))
2101 return;
2102
2103 for (n = 0; n < ARRAY_SIZE(test_4111_data); n++) {
2104 if (!ADBG_EXPECT_TRUE(c, test_4111_invmod(c, &session,
2105 test_4111_data[n].op, test_4111_data[n].n,
2106 test_4111_data[n].res))) {
2107 Do_ADBG_Log("n %zu", n);
2108 break;
2109 }
2110 }
2111
2112 TEEC_CloseSession(&session);
2113 }
2114 ADBG_CASE_DEFINE(regression, 4111, test_4111,
2115 "Test TEE Internal API Arithmetical API - Invmod");
2116
2117 static const struct {
2118 uint32_t level;
2119 int32_t res1;
2120 int32_t res2;
2121 const char *op;
2122 } test_4112_data[] = {
2123 /* Simple cases */
2124 { 80, 0, 0, "0" },
2125 { 80, 0, 0, "1" },
2126 { 80, 1, -1, "2" },
2127 { 80, 1, -1, "3" },
2128 { 80, 1, -1, "17" },
2129 { 80, 1, -1, "FA1" },
2130 { 80, 0, 0, "FA0" },
2131 /*
2132 * Testing large composites and the only allowed classification is
2133 * "composite", aka "0".
2134 */
2135 { 80, 0, 0, "136233FDE5569" },
2136 { 80, 0, 0, "177B96388FD94D5D7EC9AE513" },
2137 { 80, 0, 0, "22770A7DC599BC90B2FF981CCB5CF057"
2138 "03344C8F3504189ED" },
2139 { 80, 0, 0, "0002ECD53B2150542D1494A424D50322"
2140 "EBABBBD5DB89392A368D7759" },
2141 { 80, 0, 0, "00000004C8971C2B6F7A8503AB80749E"
2142 "2BBA5BB6B6031BD43564DCA8003F0E3E"
2143 "54E677A0A4B1B6153662B3130C11C273"
2144 "C0F9408445B2ABB47D64153BEB48C154"
2145 "659FDFDEDC496C8EA81AA7B7CE2B2CB1"
2146 "AA7C8B407DE8C86F122607B2A226385D"
2147 "9432F6CB30B5E4DE033E3363D48A1865"
2148 "D9BC95DC7883D9DC9331691A17964979" },
2149 { 80, 0, 0, "00038AFFFFFFFFFFFFFFFFFFFFFFFFFF"
2150 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
2151 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
2152 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
2153 "FFFFFFFFFFFFFFEA5C6D11EDD2905192"
2154 "C5429E6A6D796E89250BF563DA53D393"
2155 "25129B70435894B56E337D5866F0BEF6"
2156 "63D6C26DA889B69D4B1508ED63A17AFD"
2157 "8BC0C5BE09AC18B64B2B7D87279D32EB"
2158 "4F3375C10D58DF1F7CA2147A61CFA557"
2159 "235244D4A4700AB5953C4C6ED428EB5F"
2160 "09F07DAED46A995B8FFE48EFB93390C9"
2161 "60685A31987879F818CCE9B9816E13DE"
2162 "E4BEA5CC38C56A5D1983425DDD909C88"
2163 "463B447F" },
2164 /* Large primes */
2165 { 80, 1, -1, "000136A352B2C7A5" },
2166 { 80, 1, -1, "000000022770A7DC599BC90B2FF981CC"
2167 "B5CF05703344C8F350418AAD" },
2168
2169 { 80, 1, -1, "000067E04F440C5FECCA2694B1A4AB4F"
2170 "CEC2D2B2D286FC93DD259D2B36A3A00D"
2171 "F3726A4D4DFA99195998D92F43DD7370"
2172 "B8C079E23072036F0C13F3F6ABA1D6DF" },
2173
2174 { 80, 1, -1, "000BC9F7E42CE74132EC6933DE1B8357"
2175 "CD2AEB9E4B8A5F26BD233D1E6F295555"
2176 "4D2CFA9760F3F69CCC52E8E428F68C37"
2177 "AD5BC70CDB12F4DCEF23CB101C36A2A7" },
2178
2179 { 80, 1, -1, "00000005233FE157B5B44102598513AE"
2180 "BB8876B0D1791769C8A1B0F36875D06F"
2181 "E26951C7372192C7B21CAB67ADF0D6FE"
2182 "1A718FB3FC4A51454DE87CD3F852005B"
2183 "AAEC35D5" },
2184
2185 { 80, 1, -1, "0000001A655954FBC4408E09FE97EB82"
2186 "5E0F096426B42317A36E53FF9608DD3F"
2187 "A661040245906334496987EFB14BEA5F"
2188 "7C050444C9B22A09EC76AF4EBDC609D8"
2189 "A90C05E9E5AF06829C542DFCF7E6B9DC"
2190 "0B065659C1816309CD6012C37F8CE649"
2191 "8DECF850F33943F0F83081406846D306"
2192 "22E0BCE697E612FC1F7A5D902280D6E0"
2193 "3009E585" },
2194 };
2195
test_4112_is_prime(ADBG_Case_t * c,TEEC_Session * s,uint32_t conf_level,int32_t res1,int32_t res2,const char * str_val)2196 static bool test_4112_is_prime(ADBG_Case_t *c, TEEC_Session *s,
2197 uint32_t conf_level, int32_t res1, int32_t res2,
2198 const char *str_val)
2199 {
2200 bool res = false;
2201 uint32_t hop = TA_CRYPT_ARITH_INVALID_HANDLE;
2202 int32_t pres = 11;
2203
2204 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hop)))
2205 return res;
2206
2207 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
2208 convert_from_string(c, s, str_val, hop)))
2209 goto out;
2210
2211 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_is_prime(c, s, hop, conf_level,
2212 &pres)))
2213 goto out;
2214 if (!ADBG_EXPECT_TRUE(c, pres == res1 || pres == res2)) {
2215 Do_ADBG_Log("Unexpected prime clasification %" PRId32 ", expected %" PRId32 " or %" PRId32,
2216 pres, res1, res2);
2217 goto out;
2218 }
2219
2220 res = true;
2221 out:
2222 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop));
2223
2224 return res;
2225 }
2226
test_4112(ADBG_Case_t * c)2227 static void test_4112(ADBG_Case_t *c)
2228 {
2229 TEEC_Session session = { };
2230 uint32_t ret_orig = 0;
2231 size_t n = 0;
2232
2233 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
2234 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
2235 NULL, &ret_orig)))
2236 return;
2237
2238 for (n = 0; n < ARRAY_SIZE(test_4112_data); n++) {
2239 if (!ADBG_EXPECT_TRUE(c, test_4112_is_prime(c, &session,
2240 test_4112_data[n].level,
2241 test_4112_data[n].res1,
2242 test_4112_data[n].res2,
2243 test_4112_data[n].op))) {
2244 Do_ADBG_Log("n %zu", n);
2245 break;
2246 }
2247 }
2248
2249 TEEC_CloseSession(&session);
2250 }
2251 ADBG_CASE_DEFINE(regression, 4112, test_4112,
2252 "Test TEE Internal API Arithmetical API - Is prime");
2253
2254 static const struct {
2255 const char *res;
2256 size_t bits;
2257 const char *op;
2258 } test_4113_data[] = {
2259 { "0", 31, "7FFFFFFF" },
2260 { "0", 65, "7FFFFFFF" },
2261 { "0", 1, "0" },
2262 { "-1",1, "-2" },
2263 { "1", 0, "1" },
2264 { "1", 1, "2" },
2265 { "1", 2, "4" },
2266 { "1", 3, "8" },
2267 { "1", 4, "10" },
2268 { "1", 5, "20" },
2269 { "1", 6, "40" },
2270 { "1", 7, "80" },
2271 { "1", 8, "100" },
2272 { "1", 9, "200" },
2273 { "1", 10, "400" },
2274 { "1", 11, "800" },
2275 { "1", 12, "1000" },
2276 { "1", 13, "2000" },
2277 { "1", 14, "4000" },
2278 { "1", 15, "8000" },
2279 { "1", 16, "10000" },
2280 { "1", 17, "20000" },
2281 { "1", 18, "40000" },
2282 { "1", 19, "80000" },
2283 { "1", 20, "100000" },
2284 { "1", 21, "200000" },
2285 { "1", 22, "400000" },
2286 { "1", 23, "800000" },
2287 { "1", 24, "1000000" },
2288 { "1", 25, "2000000" },
2289 { "1", 26, "4000000" },
2290 { "1", 27, "8000000" },
2291 { "1", 28, "10000000" },
2292 { "1", 29, "20000000" },
2293 { "1", 30, "40000000" },
2294 { "1", 31, "80000000" },
2295 { "1", 32, "100000000" },
2296 { "1", 64, "10000000000000000" },
2297 { "FFFFFFFF", 64, "FFFFFFFF0000000000000000" },
2298 { "1111FFFF0000", 64," 1111FFFF00000000000000000000" },
2299 { "1", 33, "200000000" },
2300 { "1", 65, "20000000000000000" },
2301 { "FFFFFFFF", 65, "1FFFFFFFE0000000000000000" },
2302 { "24B0D975EC8FCC8E1D54CA4BF7ACFC4534F04", 81,
2303 "4961B2EBD91F991C3AA99497EF59F88A69E08AD5C340167793C3CC32F" },
2304 };
2305
test_4113_shift_right(ADBG_Case_t * c,TEEC_Session * s,const char * str_op,size_t bits,const char * str_res)2306 static bool test_4113_shift_right(ADBG_Case_t *c, TEEC_Session *s,
2307 const char *str_op, size_t bits,
2308 const char *str_res)
2309 {
2310 bool res = false;
2311 uint32_t hop = TA_CRYPT_ARITH_INVALID_HANDLE;
2312 uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE;
2313 uint32_t hres = TA_CRYPT_ARITH_INVALID_HANDLE;
2314
2315 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hop)))
2316 goto out;
2317 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hc)))
2318 goto out;
2319 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hres)))
2320 goto out;
2321
2322 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
2323 convert_from_string(c, s, str_res, hres)))
2324 goto out;
2325 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
2326 convert_from_string(c, s, str_op, hop)))
2327 goto out;
2328
2329 /* hc = hop shift_right bits */
2330 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_shift_right(c, s, hop, bits, hc)))
2331 goto out;
2332 /* check hc == hres */
2333 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hres, 0)))
2334 goto out;
2335
2336 res = true;
2337 out:
2338 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop));
2339 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc));
2340 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hres));
2341
2342 return res;
2343 }
2344
test_4113(ADBG_Case_t * c)2345 static void test_4113(ADBG_Case_t *c)
2346 {
2347 TEEC_Session session = { };
2348 uint32_t ret_orig = 0;
2349 size_t n = 0;
2350
2351 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
2352 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
2353 NULL, &ret_orig)))
2354 return;
2355
2356 for (n = 0; n < ARRAY_SIZE(test_4113_data); n++) {
2357 if (!ADBG_EXPECT_TRUE(c, test_4113_shift_right(c, &session,
2358 test_4113_data[n].op, test_4113_data[n].bits,
2359 test_4113_data[n].res))) {
2360 Do_ADBG_Log("n %zu", n);
2361 break;
2362 }
2363 }
2364
2365 TEEC_CloseSession(&session);
2366 }
2367 ADBG_CASE_DEFINE(regression, 4113, test_4113,
2368 "Test TEE Internal API Arithmetical API - shift right");
2369
2370 static const struct {
2371 const char *strx;
2372 const char *stry;
2373 } test_4114_data[] = {
2374 { "0", "0" },
2375 { "0", "123" },
2376 { "1", "1" },
2377 { "1", "-1" },
2378 { "2", "2" },
2379 { "-2", "2" },
2380 { "2", "4" },
2381 { "-2", "-4" },
2382 { "400", "800" },
2383 { "261", "2B5" },
2384 { "F", "A" },
2385 { "C", "13" },
2386 { "165D662", "1664FEA" },
2387 { "AB59CDFD83CE2B24",
2388 "4961BF04008953A7F9567AAFBA94D4AF55F473F14FD68AA022982F0FE" },
2389 /* two large primes */
2390 { "5D0A380DC40EDE5E036FA051FC6D7F93",
2391 "3277FD425328576569AFB2EAC6B1430578099CA8ADA4BC73" },
2392 /* two large powers of 2 */
2393 { "20000000000000000000000000000000"
2394 "00000000000000000000000000000000"
2395 "00000000000000000000000000000000"
2396 "00000000000000000000000000000000"
2397 "00000000000000000000000000000000"
2398 "00000000000000000000000000000000"
2399 "0",
2400 "40000000000000000000000000000000"
2401 "00000000000000000000000000000000"
2402 "00000000000000000000000000000000"
2403 "00000000000000000000000000000000"
2404 "00000000000000000000000000000000"
2405 "00000000000000000000000000000000"
2406 "00000000000000000000000000000000"
2407 "000000000000000000000" },
2408 };
2409
test_4114_gcd(ADBG_Case_t * c,TEEC_Session * s,const char * strx,const char * stry)2410 static bool test_4114_gcd(ADBG_Case_t *c, TEEC_Session *s, const char *strx,
2411 const char *stry)
2412 {
2413 bool res = false;
2414 uint32_t hx = TA_CRYPT_ARITH_INVALID_HANDLE;
2415 uint32_t hy = TA_CRYPT_ARITH_INVALID_HANDLE;
2416 uint32_t ha = TA_CRYPT_ARITH_INVALID_HANDLE;
2417 uint32_t hb = TA_CRYPT_ARITH_INVALID_HANDLE;
2418 uint32_t hgcd = TA_CRYPT_ARITH_INVALID_HANDLE;
2419 uint32_t ht1 = TA_CRYPT_ARITH_INVALID_HANDLE;
2420 uint32_t ht2 = TA_CRYPT_ARITH_INVALID_HANDLE;
2421
2422 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hx)))
2423 goto out;
2424 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hy)))
2425 goto out;
2426 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &ha)))
2427 goto out;
2428 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hb)))
2429 goto out;
2430 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hgcd)))
2431 goto out;
2432 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &ht1)))
2433 goto out;
2434 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &ht2)))
2435 goto out;
2436
2437 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, strx, hx)))
2438 goto out;
2439 if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, stry, hy)))
2440 goto out;
2441
2442 /* (hgcd, a, b) = ExtendedGCD(x, y) */
2443 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
2444 cmd_compute_egcd(c, s, hx, hy, ha, hb, hgcd)))
2445 goto out;
2446 /* ht1 = GCD(x, y) */
2447 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_compute_gcd(c, s, hx, hy, ht1)))
2448 goto out;
2449 /* check hgcd == ht1 */
2450 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hgcd, ht1, 0)))
2451 goto out;
2452
2453 /* ht1 = a * x */
2454 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mul(c, s, ha, hx, ht1)))
2455 goto out;
2456 /* ht2 = b * y */
2457 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mul(c, s, hb, hy, ht2)))
2458 goto out;
2459 /* ht1 = ht1 + ht2 */
2460 if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_add(c, s, ht1, ht2, ht1)))
2461 goto out;
2462 /* check hgcd == ht1 */
2463 if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hgcd, ht1, 0)))
2464 goto out;
2465
2466 res = true;
2467 out:
2468 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hx));
2469 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hy));
2470 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, ha));
2471 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hb));
2472 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hgcd));
2473 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, ht1));
2474 ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, ht2));
2475
2476 return res;
2477 }
2478
test_4114(ADBG_Case_t * c)2479 static void test_4114(ADBG_Case_t *c)
2480 {
2481 TEEC_Session session = { };
2482 uint32_t ret_orig = 0;
2483 size_t n = 0;
2484
2485 if (!ADBG_EXPECT_TEEC_SUCCESS(c,
2486 xtest_teec_open_session(&session, &crypt_user_ta_uuid,
2487 NULL, &ret_orig)))
2488 return;
2489
2490 for (n = 0; n < ARRAY_SIZE(test_4114_data); n++) {
2491 if (!ADBG_EXPECT_TRUE(c, test_4114_gcd(c, &session,
2492 test_4114_data[n].strx,
2493 test_4114_data[n].stry))) {
2494 Do_ADBG_Log("n %zu", n);
2495 break;
2496 }
2497 }
2498
2499 TEEC_CloseSession(&session);
2500 }
2501 ADBG_CASE_DEFINE(regression, 4114, test_4114,
2502 "Test TEE Internal API Arithmetical API - GCD");
2503