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