| // SPDX-License-Identifier: GPL-2.0 |
| /* Copyright (c) 2018, Linaro Limited */ |
| |
| #include <adbg.h> |
| #include <ctype.h> |
| #include <inttypes.h> |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <ta_crypt.h> |
| #include <tee_api_types.h> |
| #include <util.h> |
| |
| #include "xtest_test.h" |
| #include "xtest_helpers.h" |
| |
| static TEEC_Result cmd_new_var(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t num_bits, uint32_t *handle) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = num_bits; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_NEW_VAR, &op, &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| if (!res) |
| *handle = op.params[1].value.a; |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_new_fmm_var(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t num_bits, uint32_t *handle) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = num_bits; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_NEW_FMM_VAR, &op, |
| &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| if (!res) |
| *handle = op.params[1].value.a; |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_new_fmm_ctx(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t num_bits, uint32_t hmodulus, |
| uint32_t *handle) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = num_bits; |
| op.params[0].value.b = hmodulus; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_NEW_FMM_CTX, &op, |
| &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| if (!res) |
| *handle = op.params[1].value.a; |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_free_handle(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t handle) |
| { |
| if (handle == TA_CRYPT_ARITH_INVALID_HANDLE) |
| return TEEC_SUCCESS; |
| |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = handle; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_FREE_HANDLE, &op, |
| &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_from_octet_string(ADBG_Case_t *c, TEEC_Session *s, |
| uint8_t *buf, uint32_t buf_len, |
| int32_t sign, uint32_t h) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = h; |
| op.params[0].value.b = sign; |
| op.params[1].tmpref.buffer = buf; |
| op.params[1].tmpref.size = buf_len; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, |
| TEEC_MEMREF_TEMP_INPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_FROM_OCTET_STRING, &op, |
| &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_from_s32(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t handle, int32_t v) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = handle; |
| op.params[0].value.b = v; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_FROM_S32, &op, |
| &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_get_bit(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t handle, uint32_t bit_num, uint32_t *v) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = handle; |
| op.params[0].value.b = bit_num; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_GET_BIT, &op, &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| if (!res) |
| *v = op.params[1].value.a; |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_get_bit_count(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t handle, uint32_t *v) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = handle; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_GET_BIT_COUNT, &op, |
| &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| if (!res) |
| *v = op.params[1].value.a; |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_binary_cmd(ADBG_Case_t *c, TEEC_Session *s, uint32_t cmd, |
| uint32_t hop1, uint32_t hop2, uint32_t hres) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = hop1; |
| op.params[0].value.b = hop2; |
| op.params[1].value.a = hres; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, cmd, &op, &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_unary_cmd(ADBG_Case_t *c, TEEC_Session *s, uint32_t cmd, |
| uint32_t hop, uint32_t hres) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = hop; |
| op.params[0].value.b = hres; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, cmd, &op, &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| return res; |
| } |
| |
| static TEEC_Result 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) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = hop1; |
| op.params[0].value.b = hop2; |
| op.params[1].value.a = hn; |
| op.params[1].value.b = hres; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, cmd, &op, &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_neg(ADBG_Case_t *c, TEEC_Session *s, uint32_t hop, |
| uint32_t hres) |
| { |
| return cmd_unary_cmd(c, s, TA_CRYPT_CMD_ARITH_NEG, hop, hres); |
| } |
| |
| static TEEC_Result cmd_add(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t hop1, uint32_t hop2, uint32_t hres) |
| { |
| return cmd_binary_cmd(c, s, TA_CRYPT_CMD_ARITH_ADD, hop1, hop2, hres); |
| } |
| |
| static TEEC_Result cmd_sub(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t hop1, uint32_t hop2, uint32_t hres) |
| { |
| return cmd_binary_cmd(c, s, TA_CRYPT_CMD_ARITH_SUB, hop1, hop2, hres); |
| } |
| |
| static TEEC_Result cmd_mul(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t hop1, uint32_t hop2, uint32_t hres) |
| { |
| return cmd_binary_cmd(c, s, TA_CRYPT_CMD_ARITH_MUL, hop1, hop2, hres); |
| } |
| |
| static TEEC_Result cmd_mod(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t hop1, uint32_t hop2, uint32_t hres) |
| { |
| return cmd_binary_cmd(c, s, TA_CRYPT_CMD_ARITH_MOD, hop1, hop2, hres); |
| } |
| |
| static TEEC_Result cmd_invmod(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t hop1, uint32_t hop2, uint32_t hres) |
| { |
| return cmd_binary_cmd(c, s, TA_CRYPT_CMD_ARITH_INVMOD, hop1, hop2, |
| hres); |
| } |
| |
| static TEEC_Result cmd_addmod(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t hop1, uint32_t hop2, uint32_t hn, |
| uint32_t hres) |
| { |
| return cmd_ternary_cmd(c, s, TA_CRYPT_CMD_ARITH_ADDMOD, hop1, hop2, |
| hn, hres); |
| } |
| |
| static TEEC_Result cmd_submod(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t hop1, uint32_t hop2, uint32_t hn, |
| uint32_t hres) |
| { |
| return cmd_ternary_cmd(c, s, TA_CRYPT_CMD_ARITH_SUBMOD, hop1, hop2, |
| hn, hres); |
| } |
| |
| static TEEC_Result cmd_mulmod(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t hop1, uint32_t hop2, uint32_t hn, |
| uint32_t hres) |
| { |
| return cmd_ternary_cmd(c, s, TA_CRYPT_CMD_ARITH_MULMOD, hop1, hop2, |
| hn, hres); |
| } |
| |
| static TEEC_Result cmd_is_prime(ADBG_Case_t *c, TEEC_Session *s, uint32_t hop, |
| uint32_t conf_level, int32_t *pres) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = hop; |
| op.params[0].value.b = conf_level; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_IS_PRIME, &op, |
| &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| if (!res) |
| *pres = op.params[1].value.a; |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_shift_right(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t hop, uint32_t bits, uint32_t hres) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = hop; |
| op.params[0].value.b = bits; |
| op.params[1].value.a = hres; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_SHIFT_RIGHT, &op, |
| &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_to_fmm(ADBG_Case_t *c, TEEC_Session *s, uint32_t hsrc, |
| uint32_t hn, uint32_t hctx, uint32_t hres) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = hsrc; |
| op.params[0].value.b = hn; |
| op.params[1].value.a = hctx; |
| op.params[1].value.b = hres; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_TO_FMM, &op, &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_from_fmm(ADBG_Case_t *c, TEEC_Session *s, uint32_t hsrc, |
| uint32_t hn, uint32_t hctx, uint32_t hres) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = hsrc; |
| op.params[0].value.b = hn; |
| op.params[1].value.a = hctx; |
| op.params[1].value.b = hres; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_FROM_FMM, &op, |
| &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| return res; |
| } |
| |
| static TEEC_Result 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) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = hop1; |
| op.params[0].value.b = hop2; |
| op.params[1].value.a = hn; |
| op.params[1].value.b = hctx; |
| op.params[2].value.a = hres; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT, |
| TEEC_VALUE_INPUT, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_COMPUTE_FMM, &op, |
| &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| return res; |
| } |
| |
| static TEEC_Result 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) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = hop1; |
| op.params[0].value.b = hop2; |
| op.params[1].value.a = hu; |
| op.params[1].value.b = hv; |
| op.params[2].value.a = hgcd; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT, |
| TEEC_VALUE_INPUT, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_COMPUTE_EGCD, &op, |
| &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_compute_gcd(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t hop1, uint32_t hop2, uint32_t hgcd) |
| { |
| return cmd_compute_egcd(c, s, hop1, hop2, TA_CRYPT_ARITH_INVALID_HANDLE, |
| TA_CRYPT_ARITH_INVALID_HANDLE, hgcd); |
| } |
| |
| static int digit_value(char ch) |
| { |
| if ((ch >= '0') && (ch <= '9')) |
| return ch - '0'; |
| |
| if ((ch >= 'A') && (ch <= 'F')) |
| return ch - 'A' + 10; |
| |
| if ((ch >= 'a') && (ch <= 'f')) |
| return ch - 'a' + 10; |
| |
| return -1; |
| } |
| |
| static TEEC_Result convert_from_string(ADBG_Case_t *c, TEEC_Session *s, |
| const char *str, uint32_t h) |
| { |
| TEEC_Result res = TEEC_ERROR_BAD_FORMAT; |
| size_t spos = strlen(str); |
| int32_t sign = 1; |
| size_t os_len = (spos + 1) / 2; |
| uint8_t *os = calloc(1, os_len); |
| int ospos = os_len - 1; |
| int nibble = 0; |
| |
| if (!os) |
| return TEEC_ERROR_OUT_OF_MEMORY; |
| |
| while (spos) { |
| spos--; |
| nibble = digit_value(str[spos]); |
| if (nibble == -1) |
| break; |
| os[ospos] = nibble; |
| |
| if (!spos) |
| break; |
| spos--; |
| nibble = digit_value(str[spos]); |
| if (nibble == -1) |
| break; |
| |
| os[ospos] |= nibble << 4; |
| ospos--; |
| } |
| |
| if (spos) |
| goto out; |
| |
| if (str[spos] == '-') |
| sign = -1; |
| |
| res = cmd_from_octet_string(c, s, os, os_len, sign, h); |
| out: |
| free(os); |
| return res; |
| } |
| |
| static TEEC_Result cmd_get_value(ADBG_Case_t *c, TEEC_Session *s, uint8_t *buf, |
| uint32_t *buf_len, int32_t *sign, uint32_t h) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = h; |
| op.params[2].tmpref.buffer = buf; |
| op.params[2].tmpref.size = *buf_len; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT, |
| TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_GET_VALUE, &op, |
| &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| if (!res) |
| *sign = op.params[1].value.a; |
| *buf_len = op.params[2].tmpref.size; |
| |
| return res; |
| } |
| |
| static TEEC_Result __maybe_unused print_handle(ADBG_Case_t *c, TEEC_Session *s, |
| const char *name, uint32_t h) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| uint8_t *os = NULL; |
| uint32_t os_len = 0; |
| int32_t sign = 0; |
| |
| res = cmd_get_value(c, s, os, &os_len, &sign, h); |
| if (res) { |
| if (!ADBG_EXPECT_TEEC_RESULT(c, TEEC_ERROR_SHORT_BUFFER, res)) |
| return res; |
| |
| os = malloc(os_len); |
| if (!ADBG_EXPECT_NOT_NULL(c, os)) |
| return TEEC_ERROR_OUT_OF_MEMORY; |
| |
| res = cmd_get_value(c, s, os, &os_len, &sign, h); |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, res)) |
| goto out; |
| } |
| |
| Do_ADBG_Log("%s sign %" PRId32 " (length %" PRIu32 ")", |
| name, sign, os_len); |
| Do_ADBG_HexLog(os, os_len, 16); |
| out: |
| free(os); |
| return res; |
| } |
| |
| static TEEC_Result cmd_get_value_s32(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t h, int32_t *val) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = h; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_GET_VALUE_S32, &op, |
| &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| if (!res) |
| *val = op.params[1].value.a; |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_cmp(ADBG_Case_t *c, TEEC_Session *s, uint32_t hop1, |
| uint32_t hop2, int32_t *cmp_res) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = hop1; |
| op.params[0].value.b = hop2; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_CMP, &op, &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| if (!res) |
| *cmp_res = op.params[1].value.a; |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_cmp_s32(ADBG_Case_t *c, TEEC_Session *s, uint32_t hop, |
| int32_t s32, int32_t *cmp_res) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = hop; |
| op.params[0].value.b = s32; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_CMP_S32, &op, &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| if (!res) |
| *cmp_res = op.params[1].value.a; |
| |
| return res; |
| } |
| |
| static TEEC_Result cmd_div(ADBG_Case_t *c, TEEC_Session *s, uint32_t hop1, |
| uint32_t hop2, uint32_t hq, uint32_t hr) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| TEEC_Operation op = TEEC_OPERATION_INITIALIZER; |
| uint32_t ret_orig = 0; |
| |
| op.params[0].value.a = hop1; |
| op.params[0].value.b = hop2; |
| op.params[1].value.a = hq; |
| op.params[1].value.b = hr; |
| op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT, |
| TEEC_NONE, TEEC_NONE); |
| res = TEEC_InvokeCommand(s, TA_CRYPT_CMD_ARITH_DIV, &op, &ret_orig); |
| ADBG_EXPECT_TEEC_ERROR_ORIGIN(c, TEEC_ORIGIN_TRUSTED_APP, ret_orig); |
| |
| return res; |
| } |
| |
| static void test_4101(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| uint32_t handle = TA_CRYPT_ARITH_INVALID_HANDLE; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| Do_ADBG_BeginSubCase(c, "Normal allocation and initialization"); |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_new_var(c, &session, 512, &handle))) |
| goto out; |
| if (!ADBG_EXPECT_COMPARE_UNSIGNED(c, |
| handle, !=, TA_CRYPT_ARITH_INVALID_HANDLE)) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, &session, handle))) |
| goto out; |
| |
| Do_ADBG_EndSubCase(c, "Normal allocation and initialization"); |
| |
| Do_ADBG_BeginSubCase(c, "Zero allocation"); |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_new_var(c, &session, 0, &handle))) |
| goto out; |
| if (!ADBG_EXPECT_COMPARE_UNSIGNED(c, |
| handle, !=, TA_CRYPT_ARITH_INVALID_HANDLE)) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, &session, handle))) |
| goto out; |
| |
| Do_ADBG_EndSubCase(c, "Zero allocation"); |
| |
| Do_ADBG_BeginSubCase(c, "Too large"); |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_new_var(c, &session, 4096, &handle))) |
| goto out; |
| if (!ADBG_EXPECT_COMPARE_UNSIGNED(c, |
| handle, !=, TA_CRYPT_ARITH_INVALID_HANDLE)) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, &session, handle))) |
| goto out; |
| |
| Do_ADBG_EndSubCase(c, "Too large"); |
| |
| Do_ADBG_BeginSubCase(c, "Boundaries"); |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_new_var(c, &session, 2048, &handle))) |
| goto out; |
| if (!ADBG_EXPECT_COMPARE_UNSIGNED(c, |
| handle, !=, TA_CRYPT_ARITH_INVALID_HANDLE)) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, &session, handle))) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_new_var(c, &session, 2049, &handle))) |
| goto out; |
| if (!ADBG_EXPECT_COMPARE_UNSIGNED(c, |
| handle, !=, TA_CRYPT_ARITH_INVALID_HANDLE)) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, &session, handle))) |
| goto out; |
| |
| Do_ADBG_EndSubCase(c, "Boundaries"); |
| out: |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4101, test_4101, |
| "Test TEE Internal API Arithmetical API - Bigint init"); |
| |
| static void test_4102(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| uint32_t ha = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hb = TA_CRYPT_ARITH_INVALID_HANDLE; |
| size_t n = 0; |
| const struct { |
| const uint8_t *os; |
| uint32_t os_len; |
| const char *str; |
| int32_t sign; |
| } data[] = { |
| { .os = (const uint8_t []){ 1, 2, 3, 4 }, |
| .os_len = 4, .sign = 1, .str = "01020304", }, |
| { .os = (const uint8_t []){ 1, 2, 3, 4, 5 }, |
| .os_len = 5, .sign = 1, .str = "0102030405", }, |
| { .os = (const uint8_t []){ |
| 0x11, 0x22, 0x44, 0x55, 0x66, 0x77, 0x88 }, |
| .os_len = 7, .sign = 1, .str = "11224455667788", }, |
| { .os = (const uint8_t []){ 0, 1, 2, 3, 4 }, |
| .os_len = 5, .sign = 1, .str = "01020304", }, |
| }; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, &session, 512, &ha))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, &session, 512, &hb))) |
| goto out; |
| |
| for (n = 0; n < ARRAY_SIZE(data); n++) { |
| int32_t sign = 0; |
| int32_t cmp_res = 0; |
| size_t len_diff = 0; |
| uint8_t os_res[10]; |
| uint32_t os_len; |
| |
| Do_ADBG_BeginSubCase(c, "\"%s\"", data[n].str); |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, |
| &session, data[n].str, ha))) |
| goto out; |
| |
| /* Check that it's read back correctly */ |
| os_len = data[n].os_len; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_get_value(c, &session, |
| os_res, &os_len, &sign, ha))) |
| goto out; |
| if (!ADBG_EXPECT_COMPARE_UNSIGNED(c, data[n].os_len, |
| >=, os_len)) |
| goto out; |
| |
| len_diff = data[n].os_len - os_len; |
| if (!ADBG_EXPECT_BUFFER(c, data[n].os + len_diff, |
| data[n].os_len - len_diff, |
| os_res, os_len)) |
| goto out; |
| if (!ADBG_EXPECT_COMPARE_SIGNED(c, sign, ==, data[n].sign)) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_from_octet_string(c, |
| &session, os_res, os_len, sign, hb))) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_cmp(c, &session, |
| ha, hb, &cmp_res))) |
| goto out; |
| if (!ADBG_EXPECT_COMPARE_SIGNED(c, cmp_res, ==, 0)) |
| goto out; |
| |
| Do_ADBG_EndSubCase(c, NULL); |
| } |
| out: |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4102, test_4102, |
| "Test TEE Internal API Arithmetical API - Octet string"); |
| |
| static void test_4103(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| size_t n = 0; |
| uint32_t h = TA_CRYPT_ARITH_INVALID_HANDLE; |
| int32_t v = 0; |
| static const int32_t data[] = { |
| 1, -1, 123, -123, 0x7FFFFFFF, (int32_t)0x80000000, |
| (int32_t)0xFFFFFFFF, 0, |
| }; |
| static const char *data_str[] = { "1FFFFFFFFF", "-1FFFFFFFFF" }; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, &session, 512, &h))) |
| goto out; |
| |
| for (n = 0; n < ARRAY_SIZE(data); n++) { |
| int32_t cmp_res = 0; |
| |
| Do_ADBG_BeginSubCase(c, "%" PRId32 " (0x%" PRIx32 ")", |
| data[n], (uint32_t)data[n]); |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_from_s32(c, &session, h, data[n]))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_cmp_s32(c, &session, h, data[n], &cmp_res))) |
| goto out; |
| if (!ADBG_EXPECT_COMPARE_SIGNED(c, cmp_res, ==, 0)) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_get_value_s32(c, &session, h, &v))) { |
| Do_ADBG_Log("n %zu", n); |
| goto out; |
| } |
| if (!ADBG_EXPECT_COMPARE_SIGNED(c, data[n], ==, v)) |
| goto out; |
| |
| Do_ADBG_EndSubCase(c, NULL); |
| } |
| |
| for (n = 0; n < ARRAY_SIZE(data_str); n++) { |
| Do_ADBG_BeginSubCase(c, "\"%s\" (overflow)", data_str[n]); |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, |
| &session, data_str[n], h))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_RESULT(c, TEE_ERROR_OVERFLOW, |
| cmd_get_value_s32(c, &session, h, &v))) |
| goto out; |
| Do_ADBG_EndSubCase(c, NULL); |
| } |
| |
| out: |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4103, test_4103, |
| "Test TEE Internal API Arithmetical API - S32"); |
| |
| static TEEC_Result compare_str(ADBG_Case_t *c, TEEC_Session *s, |
| const char str1[], const char str2[], |
| int32_t cmp_res) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| int32_t cres = 0; |
| uint32_t h1 = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t h2 = TA_CRYPT_ARITH_INVALID_HANDLE; |
| |
| res = cmd_new_var(c, s, 512, &h1); |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, res)) |
| goto out; |
| res = cmd_new_var(c, s, 512, &h2); |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, res)) |
| goto out; |
| |
| res = convert_from_string(c, s, str1, h1); |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, res)) |
| goto out; |
| res = convert_from_string(c, s, str2, h2); |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, res)) |
| goto out; |
| |
| res = cmd_cmp(c, s, h1, h2, &cres); |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, res)) |
| goto out; |
| |
| ADBG_EXPECT_COMPARE_SIGNED(c, cres, ==, cmp_res); |
| out: |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, h1)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, h2)); |
| return res; |
| } |
| |
| static TEEC_Result compare_s32(ADBG_Case_t *c, TEEC_Session *s, |
| const char str[], int32_t val, |
| int32_t cmp_res) |
| { |
| TEEC_Result res = TEEC_ERROR_GENERIC; |
| int32_t cres = 0; |
| uint32_t h = TA_CRYPT_ARITH_INVALID_HANDLE; |
| |
| res = cmd_new_var(c, s, 512, &h); |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, res)) |
| return res; |
| |
| res = convert_from_string(c, s, str, h); |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, res)) |
| goto out; |
| |
| res = cmd_cmp_s32(c, s, h, val, &cres); |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, res)) |
| goto out; |
| |
| ADBG_EXPECT_COMPARE_SIGNED(c, cres, ==, cmp_res); |
| out: |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, h)); |
| |
| return res; |
| } |
| |
| static void test_4104(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| size_t n = 0; |
| const struct { |
| const char *str1; |
| const char *str2; |
| int32_t cmp_res; |
| } data[] = { |
| { "0", "1", -1 }, |
| { "1", "0", 1 }, |
| { "1", "2", -1 }, |
| { "2", "1", 1 }, |
| { "-1", "FFFFFFFFFF", -1 }, |
| { "FFFFFFFFFF", "-1", 1 }, |
| { "1", "-FFFFFFFFFF", 1 }, |
| { "-FFFFFFFFFF", "1", -1 }, |
| { "1", "100000000", -1 }, |
| { "0", "0", 0 }, |
| { "1", "1", 0 }, |
| { "-1", "-1", 0} |
| }; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| Do_ADBG_BeginSubCase(c, "Compare bigints"); |
| for (n = 0; n < ARRAY_SIZE(data); n++) { |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_str(c, &session, |
| data[n].str1, data[n].str2, data[n].cmp_res))) |
| goto out; |
| } |
| Do_ADBG_EndSubCase(c, "Compare bigints"); |
| |
| const struct { |
| const char *str; |
| int32_t val; |
| int32_t cmp_res; |
| } data_s32[] = { |
| {"0", 0, 0 }, |
| {"0", 1, -1 }, |
| {"1", 0, 1 }, |
| {"0", -1, 1 }, |
| {"-1", 0, -1 }, |
| {"1", 1, 0 }, |
| {"-1", -1, 0 }, |
| {"-1", 1, -1 }, |
| {"1", -1, 1 }, |
| {"123", 0x123, 0 }, |
| {"-123", -0x123, 0 }, |
| |
| /* corner case */ |
| {"7FFFFFFF", INT32_MAX, 0 }, |
| {"-7FFFFFFF", INT32_MIN, 1 }, |
| {"7FFFFFFF", 0, 1 }, |
| {"-7FFFFFFF", 0, -1 }, |
| {"-80000000", INT32_MIN, 0 }, |
| {"80000000", INT32_MAX, 1 }, |
| {"-80000001", INT32_MIN, -1 }, |
| {"-7FFFFFFF", INT32_MIN, 1 }, |
| |
| /* large BigInt */ |
| {"1FFFFFFFF", 1, 1 }, |
| {"-1FFFFFFFF", 1, -1 }, |
| }; |
| |
| Do_ADBG_BeginSubCase(c, "Compare S32"); |
| for (n = 0; n < ARRAY_SIZE(data_s32); n++) { |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_s32(c, &session, |
| data_s32[n].str, data_s32[n].val, |
| data_s32[n].cmp_res))) |
| goto out; |
| } |
| Do_ADBG_EndSubCase(c, "Compare S32"); |
| |
| out: |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4104, test_4104, |
| "Test TEE Internal API Arithmetical API - Compare"); |
| |
| static TEEC_Result compare_handle(ADBG_Case_t *c, TEEC_Session *s, |
| uint32_t hop1, uint32_t hop2, int32_t cmp_res) |
| { |
| int32_t cres = 0; |
| TEEC_Result res = cmd_cmp(c, s, hop1, hop2, &cres); |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, res)) |
| return res; |
| if (!ADBG_EXPECT_COMPARE_SIGNED(c, cres, ==, cmp_res)) |
| return TEEC_ERROR_GENERIC; |
| |
| return TEEC_SUCCESS; |
| } |
| |
| static bool do_addsub(ADBG_Case_t *c, TEEC_Session *s, const char *str_s, |
| const char *str_t, const char *str_r) |
| { |
| bool res = false; |
| uint32_t ha = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hb = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hr = TA_CRYPT_ARITH_INVALID_HANDLE; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 1024, &ha))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 1024, &hb))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 1024, &hc))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 1024, &hr))) |
| goto out; |
| |
| /* First do the ADD dominated phase */ |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_r, hr))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_s, ha))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_t, hb))) |
| goto out; |
| |
| /* hc = ha + hb */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_add(c, s, ha, hb, hc))) |
| goto out; |
| /* check hc == hr */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hr, 0))) |
| goto out; |
| /* ha = ha + hb */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_add(c, s, ha, hb, ha))) |
| goto out; |
| /* check ha == hr */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, ha, hr, 0))) |
| goto out; |
| /* ha = ha - hb */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_sub(c, s, ha, hb, ha))) |
| goto out; |
| /* hb = ha + hb */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_add(c, s, ha, hb, hb))) |
| goto out; |
| /* check hb == hr */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hb, hr, 0))) |
| goto out; |
| |
| /* Do the SUB dominated phase */ |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_s, hr))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_r, ha))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_t, hb))) |
| goto out; |
| |
| /* hc = ha - hb */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_sub(c, s, ha, hb, hc))) |
| goto out; |
| /* check hc == hr */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hr, 0))) |
| goto out; |
| /* ha = ha - hb */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_sub(c, s, ha, hb, ha))) |
| goto out; |
| /* check ha == hr */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, ha, hr, 0))) |
| goto out; |
| /* ha = ha + hb */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_add(c, s, ha, hb, ha))) |
| goto out; |
| /* hb = ha - hb */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_sub(c, s, ha, hb, hb))) |
| goto out; |
| /* check hb == hr */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hb, hr, 0))) |
| goto out; |
| |
| res = true; |
| out: |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, ha)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hb)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hr)); |
| |
| return res; |
| } |
| |
| static void test_4105(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| size_t n = 0; |
| static const struct { |
| const char *s; |
| const char *t; |
| const char *r; |
| } data[] = { |
| { "1", "1", "2" }, |
| { "-1", "1", "0" }, |
| { "0", "0", "0" }, |
| { "0", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" }, |
| /* single word, no carry */ |
| { "FF", "FF", "1FE" }, |
| /* single word, with carry */ |
| { "FFFFFFFF", "FFFFFFFF", "1FFFFFFFE" }, |
| /* mult word with partial carry */ |
| { "FFFFFFFF", "100000000FFFFFFFFFFFFFFFF", |
| "10000000100000000FFFFFFFE" }, |
| /* mult word with carry all the way */ |
| { "FFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFF", |
| "1FFFFFFFFFFFFFFFE" }, |
| /* single word, no carry */ |
| { "-FF", "-FF", "-1FE" }, |
| /* single word, with carry */ |
| { "-FFFFFFFF", "-FFFFFFFF", "-1FFFFFFFE" }, |
| /* mult word with partial carry */ |
| { "-FFFFFFFF", "-100000000FFFFFFFFFFFFFFFF", |
| "-10000000100000000FFFFFFFE" }, |
| /* mult word with carry */ |
| { "-FFFFFFFFFFFFFFFF", "-FFFFFFFFFFFFFFFF", |
| "-1FFFFFFFFFFFFFFFE" }, |
| /* single word, no carry */ |
| { "FFFF", "-FF", "FF00" }, |
| /* single word, with carry */ |
| { "F00000000", "-00000FFFF", "EFFFF0001" }, |
| /* multi words with carry */ |
| { "FFFFFFFF00000000", "-FFFFFFFF", "FFFFFFFE00000001" }, |
| { "10000000FFFFFFFF00000000", "-FFFFFFFF", |
| "10000000FFFFFFFE00000001" }, |
| { "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", |
| "-FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE", "1" }, |
| { "FF", "-FFFF", "-FF00" }, |
| { "FFFFFFFF", "-1FFFFFFFF", "-100000000" }, |
| /* single word, no carry */ |
| { "-FFFF", "FF", "-FF00" }, |
| /* single word, with carry */ |
| { "-F00000000", "00000FFFF", "-EFFFF0001" }, |
| /* multi words with carry */ |
| { "-FFFFFFFF00000000", "FFFFFFFF", "-FFFFFFFE00000001" }, |
| { "-10000000FFFFFFFF00000000", "FFFFFFFF", |
| "-10000000FFFFFFFE00000001" }, |
| { "-FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE", "-1" }, |
| { "-FF", "FFFF", "FF00" }, |
| { "-FFFFFFFF", "1FFFFFFFF", "100000000" }, |
| }; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| for (n = 0; n < ARRAY_SIZE(data); n++) { |
| if (!ADBG_EXPECT_TRUE(c, do_addsub(c, &session, data[n].s, |
| data[n].t, data[n].r))) { |
| Do_ADBG_Log("n %zu", n); |
| break; |
| } |
| } |
| |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4105, test_4105, |
| "Test TEE Internal API Arithmetical API - Add, Sub"); |
| |
| static void test_4106(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| size_t n = 0; |
| uint32_t h1 = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t h2 = TA_CRYPT_ARITH_INVALID_HANDLE; |
| static const struct { |
| const char *val; |
| const char *neg_val; |
| } data[] = { |
| { "0", "0" }, |
| { "1", "-1" }, |
| { "123", "-123" }, |
| { "123456789123456789", "-123456789123456789" }, |
| }; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, &session, 1024, &h1))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, &session, 1024, &h2))) |
| goto out; |
| |
| for (n = 0; n < ARRAY_SIZE(data); n++) { |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, |
| &session, data[n].val, h1))) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, |
| &session, data[n].neg_val, h2))) |
| goto out; |
| |
| if (n && !ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, |
| &session, h1, h2, 1))) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_neg(c, &session, h1, h1))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, &session, |
| h1, h2, 0))) |
| goto out; |
| } |
| out: |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4106, test_4106, |
| "Test TEE Internal API Arithmetical API - Neg"); |
| |
| static bool do_mul(ADBG_Case_t *c, TEEC_Session *s, const char *str_s, |
| const char *str_t, const char *str_r) |
| { |
| bool res = false; |
| uint32_t ha = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hb = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hr = TA_CRYPT_ARITH_INVALID_HANDLE; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 1024, &ha))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 1024, &hb))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hc))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hr))) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_r, hr))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_s, ha))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_t, hb))) |
| goto out; |
| |
| /* hc = ha * hb */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mul(c, s, ha, hb, hc))) |
| goto out; |
| /* check hc == hr */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hr, 0))) |
| goto out; |
| /* ha = ha * hb */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mul(c, s, ha, hb, ha))) |
| goto out; |
| /* check ha == hr */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, ha, hr, 0))) |
| goto out; |
| |
| res = true; |
| out: |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, ha)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hb)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hr)); |
| |
| return res; |
| } |
| |
| static void test_4107(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| size_t n = 0; |
| static const struct { |
| const char *s; |
| const char *t; |
| const char *r; |
| } data[] = { |
| { "0", "0", "0" }, |
| { "0", "FFFFFFFF", "0" }, |
| { "1", "1", "1" }, |
| { "-1", "1", "-1" }, |
| { "-1", "-1", "1" }, |
| { "FF", "1", "FF" }, |
| { "2", "2", "4" }, |
| { "3", "3", "9" }, |
| { "100", "100", "10000" }, |
| { "FFFFFFFF", "FFFFFFFF", "FFFFFFFE00000001" }, |
| { "4F239BBAE89A447149CDB0B50A103C69591DD9E0C91A57955A6C266" |
| "C7ED42A5ED5F4", |
| "44FF5A67036657E041D55AE42AE25517A1", |
| "155465C8221717FFC135C87ABF6D34184DF5E6906D2EBA7C364879AA" |
| "0BE840FD06F1E0A7036BC3B7B1844FF95F07A39CE17A74" }, |
| { "4F239BBAE89A447149CDB0B50A103C69591DD9E0C91A57955A6C266C" |
| "7ED42A5ED5F4", |
| "-44FF5A67036657E041D55AE42AE25517A1", |
| "-155465C8221717FFC135C87ABF6D34184DF5E6906D2EBA7C364879A" |
| "A0BE840FD06F1E0A7036BC3B7B1844FF95F07A39CE17A74" }, |
| { "-4F239BBAE89A447149CDB0B50A103C69591DD9E0C91A57955A6C266" |
| "C7ED42A5ED5F4", |
| "-44FF5A67036657E041D55AE42AE25517A1", |
| "155465C8221717FFC135C87ABF6D34184DF5E6906D2EBA7C364879AA" |
| "0BE840FD06F1E0A7036BC3B7B1844FF95F07A39CE17A74" }, |
| }; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| for (n = 0; n < ARRAY_SIZE(data); n++) { |
| if (!ADBG_EXPECT_TRUE(c, do_mul(c, &session, data[n].s, |
| data[n].t, data[n].r))) { |
| Do_ADBG_Log("n %zu", n); |
| break; |
| } |
| } |
| |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4107, test_4107, |
| "Test TEE Internal API Arithmetical API - Mul"); |
| |
| static bool 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) |
| { |
| bool res = false; |
| int32_t cres = 0; |
| uint32_t hn = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hd = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hq = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hr = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hv = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hout = TA_CRYPT_ARITH_INVALID_HANDLE; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hn))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hd))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hq))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hr))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hv))) |
| goto out; |
| |
| if (str_out) { |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_new_var(c, s, 2048, &hout))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_out, hout))) |
| goto out; |
| } |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_s, hn))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_t, hd))) |
| goto out; |
| |
| /* (hq, hr) = n / d */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_div(c, s, hn, hd, hq, hr))) |
| goto out; |
| if (str_out) { |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| compare_handle(c, s, hq, hout, 0))) |
| goto out; |
| } |
| |
| /* hv = hq * hd */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mul(c, s, hq, hd, hv))) |
| goto out; |
| /* hv = hv + hr */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_add(c, s, hv, hr, hv))) |
| goto out; |
| /* check hn == hv */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hn, hv, 0))) |
| goto out; |
| |
| if (qsign) { |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_cmp_s32(c, s, hq, 0, &cres))) |
| goto out; |
| if (!ADBG_EXPECT_COMPARE_SIGNED(c, cres, ==, qsign)) |
| goto out; |
| } |
| |
| if (rsign) { |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_cmp_s32(c, s, hr, 0, &cres))) |
| goto out; |
| if (!ADBG_EXPECT_COMPARE_SIGNED(c, cres, ==, rsign)) |
| goto out; |
| } |
| |
| res = true; |
| out: |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hn)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hd)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hq)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hr)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hv)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hout)); |
| |
| return res; |
| } |
| |
| static void test_4108(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| size_t n = 0; |
| static const struct { |
| const char *s; |
| const char *t; |
| const char *out; |
| int32_t qsign; |
| int32_t rsign; |
| } data[] = { |
| { "811111100000000112345678", "8000000012345678" }, |
| { "0", "1", "0" }, |
| { "1", "1", "1" }, |
| { "b7fb", "5", "24CB" }, |
| { "124378912734891273894712890347102358129034789120374", |
| "1984086C15FA011154C86FA68", "B73D14EC7205D3311F6E78411D" }, |
| { "124378912734891273894712890347102358129034789120374", |
| "1984086C15FA011154C86FA68" }, |
| { "-124378912734891273894712890347102358129034789120374", |
| "1984086C15FA011154C86FA68" }, |
| { "124378912734891273894712890347102358129034789120374", |
| "-1984086C15FA011154C86FA68" }, |
| { "-124378912734891273894712890347102358129034789120374", |
| "-1984086C15FA011154C86FA68" }, |
| { "12345678", "10" }, |
| { "-12345678", "10" }, |
| { "12345678", "-10" }, |
| { "-12345678", "-10" }, |
| { "12345678901234567890123456789012345678901", "10" }, |
| { "1234567890123456789012345678901234567890", "10" }, |
| { "123456789012345678901234567890123456789", "10" }, |
| { "53", "7", NULL, 1, 1 }, |
| { "-53", "7", NULL, -1, -1 }, |
| { "53", "-7", NULL, -1, 1 }, |
| { "-53", "-7", NULL, 1, -1 }, |
| { "123456789abcdef123456789abcdef", "fedcba98765432100", |
| NULL, 1, 1 }, |
| { "-123456789abcdef123456789abcdef", "fedcba98765432100", |
| NULL, -1, -1 }, |
| { "123456789abcdef123456789abcdef", "-fedcba98765432100", |
| NULL, -1, 1 }, |
| { "-123456789abcdef123456789abcdef", "-fedcba98765432100", |
| NULL, 1, -1 }, |
| }; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| for (n = 0; n < ARRAY_SIZE(data); n++) { |
| if (!ADBG_EXPECT_TRUE(c, do_div(c, &session, data[n].s, |
| data[n].t, data[n].out, data[n].qsign, |
| data[n].rsign))) { |
| Do_ADBG_Log("n %zu", n); |
| break; |
| } |
| } |
| |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4108, test_4108, |
| "Test TEE Internal API Arithmetical API - Div"); |
| |
| static const struct { |
| const char *op; |
| const char *n; |
| const char *res; |
| } test_4109_data[] = { |
| { "10", "A", "6" }, |
| { "10", "20", "10" }, |
| { "-1", "123", "122" }, |
| { "-122", "123", "1" }, |
| { "-1", "100000000000000000000", "FFFFFFFFFFFFFFFFFFFF" }, |
| |
| { "42176E7CD0386C94194C3C3DACFA7237" |
| "CCF4E0829E2EBEAB59DE12CAE3305C9E" |
| "576F837A42D9C13BB1D83E4DFD330B65" |
| "76FD516B2AE9FBDD152F0A820C5DD18E" |
| "D048D476EC791DC989D6D8C30B2B30FF" |
| "C2A4ABAC082C672B38E138610B74CE0C" |
| "30D1B378BE6FE0C44E09EC11586245CD" |
| "8F1216619392E6B2C857C71EA78DD4D8" |
| "61A482D9D1251C341D1D6205AFB2BFB5" |
| "3DD1F272B5624FA61B020936745387CD" |
| "F1F3EBC4435CBE6C6B323497098FDE9D" |
| "61AA0CC87416235E706A71F73EC3C291" |
| "D9ACA2EECD712DA40966DD251310AE94" |
| "9713F69B2A32E42732A7F6669547D88A" |
| "415B25C582FDBBF06C5EC5F5750053D4" |
| "9F7ED68DED168C92F9C531828A", |
| "A9A9C49F0015DBEF9EB0D927F379821AE2C59", |
| "3460EB99F07BC4617A7586E6522B98F66E5B2" }, |
| |
| { "42176E7CD0386C94194C3C3DACFA7237" |
| "CCF4E0829E2EBEAB59DE12CAE3305C9E" |
| "576F837A42D9C13BB1D83E4DFD330B65" |
| "76FD516B2AE9FBDD152F0A820C5DD18E" |
| "D048D476EC791DC989D6D8C30B2B30FF" |
| "C2A4ABAC082C672B38E138610B74CE0C" |
| "30D1B378BE6FE0C44E09EC11586245CD" |
| "8F1216619392E6B2C857C71EA78DD4D8" |
| "61A482D9D1251C341D1D6205AFB2BFB5" |
| "3DD1F272B5624FA61B020936745387CD" |
| "F1F3EBC4435CBE6C6B323497098FDE9D" |
| "61AA0CC87416235E706A71F73EC3C291" |
| "D9ACA2EECD712DA40966DD251310AE94" |
| "9713F69B2A32E42732A7F6669547D88A" |
| "415B25C582FDBBF06C5EC5F5750053D4" |
| "9F7ED68DED168C92F9C531828A", |
| "1234", "1082" }, |
| |
| { "FFFF6E7CD0386C94194C3C3DACFA7237" |
| "CCF4E0829E2EBEAB59DE12CAE3305C9E" |
| "576F837A42D9C13BB1D83E4DFD330B65" |
| "76FD516B2AE9FBDD152F0A820C5DD18E" |
| "D048D476EC791DC989D6D8C30B2B30FF" |
| "C2A4ABAC082C672B38E138610B74CE0C" |
| "30D1B378BE6FE0C44E09EC11586245CD" |
| "8F1216619392E6B2C857C71EA78DD4D8" |
| "61A482D9D1251C341D1D6205AFB2BFB5" |
| "3DD1F272B5624FA61B020936745387CD" |
| "F1F3EBC4435CBE6C6B323497098FDE9D" |
| "61AA0CC87416235E706A71F73EC3C291" |
| "D9ACA2EECD712DA40966DD251310AE94" |
| "9713F69B2A32E42732A7F6669547D88A" |
| "415B25C582FDBBF06C5EC5F5750053D4" |
| "9F7ED68DED168C92F9C531828A", |
| "2", "0" }, |
| |
| { "FFFF6E7CD0386C94194C3C3DACFA7237" |
| "CCF4E0829E2EBEAB59DE12CAE3305C9E" |
| "576F837A42D9C13BB1D83E4DFD330B65" |
| "76FD516B2AE9FBDD152F0A820C5DD18E" |
| "D048D476EC791DC989D6D8C30B2B30FF" |
| "C2A4ABAC082C672B38E138610B74CE0C" |
| "30D1B378BE6FE0C44E09EC11586245CD" |
| "8F1216619392E6B2C857C71EA78DD4D8" |
| "61A482D9D1251C341D1D6205AFB2BFB5" |
| "3DD1F272B5624FA61B020936745387CD" |
| "F1F3EBC4435CBE6C6B323497098FDE9D" |
| "61AA0CC87416235E706A71F73EC3C291" |
| "D9ACA2EECD712DA40966DD251310AE94" |
| "9713F69B2A32E42732A7F6669547D88A" |
| "415B25C582FDBBF06C5EC5F5750053D4" |
| "9F7ED68DED168C92F9C531828A", |
| "FFFF6E7CD0386C94194C3C3DACFA7237" |
| "CCF4E0829E2EBEAB59DE12CAE3305C9E" |
| "576F837A42D9C13BB1D83E4DFD330B65" |
| "76FD516B2AE9FBDD152F0A820C5DD18E" |
| "D048D476EC791DC989D6D8C30B2B30FF" |
| "C2A4ABAC082C672B38E138610B74CE0C" |
| "30D1B378BE6FE0C44E09EC11586245CD" |
| "8F1216619392E6B2C857C71EA78DD4D8" |
| "61A482D9D1251C341D1D6205AFB2BFB5" |
| "3DD1F272B5624FA61B020936745387CD" |
| "F1F3EBC4435CBE6C6B323497098FDE9D" |
| "61AA0CC87416235E706A71F73EC3C291" |
| "D9ACA2EECD712DA40966DD251310AE94" |
| "9713F69B2A32E42732A7F6669547D88A" |
| "415B25C582FDBBF06C5EC5F5750053D4" |
| "9F7ED68DED168C92F9C531828A", |
| "0" }, |
| |
| { "FFFF6E7CD0386C94194C3C3DACFA7237" |
| "CCF4E0829E2EBEAB59DE12CAE3305C9E" |
| "576F837A42D9C13BB1D83E4DFD330B65" |
| "76FD516B2AE9FBDD152F0A820C5DD18E" |
| "D048D476EC791DC989D6D8C30B2B30FF" |
| "C2A4ABAC082C672B38E138610B74CE0C" |
| "30D1B378BE6FE0C44E09EC11586245CD" |
| "8F1216619392E6B2C857C71EA78DD4D8" |
| "61A482D9D1251C341D1D6205AFB2BFB5" |
| "3DD1F272B5624FA61B020936745387CD" |
| "F1F3EBC4435CBE6C6B323497098FDE9D" |
| "61AA0CC87416235E706A71F73EC3C291" |
| "D9ACA2EECD712DA40966DD251310AE94" |
| "9713F69B2A32E42732A7F6669547D88A" |
| "415B25C582FDBBF06C5EC5F5750053D4" |
| "9F7ED68DED168C92F9C531828A", |
| "FFFF6E7CD0386C94194C3C3DACFA7237" |
| "CCF4E0829E2EBEAB59DE12CAE3305C9E" |
| "576F837A42D9C13BB1D83E4DFD330B65" |
| "76FD516B2AE9FBDD152F0A820C5DD18E" |
| "D048D476EC791DC989D6D8C30B2B30FF" |
| "C2A4ABAC082C672B38E138610B74CE0C" |
| "30D1B378BE6FE0C44E09EC11586245CD" |
| "8F1216619392E6B2C857C71EA78DD4D8" |
| "61A482D9D1251C341D1D6205AFB2BFB5" |
| "3DD1F272B5624FA61B020936745387CD" |
| "F1F3EBC4435CBE6C6B323497098FDE9D" |
| "61AA0CC87416235E706A71F73EC3C291" |
| "D9ACA2EECD712DA40966DD251310AE94" |
| "9713F69B2A32E42732A7F6669547D88A" |
| "415B25C582FDBBF06C5EC5F5750053D4" |
| "9F7ED68DED168C92F9C531828B", |
| "FFFF6E7CD0386C94194C3C3DACFA7237" |
| "CCF4E0829E2EBEAB59DE12CAE3305C9E" |
| "576F837A42D9C13BB1D83E4DFD330B65" |
| "76FD516B2AE9FBDD152F0A820C5DD18E" |
| "D048D476EC791DC989D6D8C30B2B30FF" |
| "C2A4ABAC082C672B38E138610B74CE0C" |
| "30D1B378BE6FE0C44E09EC11586245CD" |
| "8F1216619392E6B2C857C71EA78DD4D8" |
| "61A482D9D1251C341D1D6205AFB2BFB5" |
| "3DD1F272B5624FA61B020936745387CD" |
| "F1F3EBC4435CBE6C6B323497098FDE9D" |
| "61AA0CC87416235E706A71F73EC3C291" |
| "D9ACA2EECD712DA40966DD251310AE94" |
| "9713F69B2A32E42732A7F6669547D88A" |
| "415B25C582FDBBF06C5EC5F5750053D4" |
| "9F7ED68DED168C92F9C531828A" }, |
| }; |
| |
| static bool test_4109_mod(ADBG_Case_t *c, TEEC_Session *s, const char *str_op, |
| const char *str_n, const char *str_res) |
| { |
| bool res = false; |
| uint32_t hop = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hn = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hres = TA_CRYPT_ARITH_INVALID_HANDLE; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hop))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hn))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hc))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hres))) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_res, hres))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_op, hop))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_n, hn))) |
| goto out; |
| |
| /* hc = hop mod hn */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mod(c, s, hop, hn, hc))) |
| goto out; |
| /* check hc == hres */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hres, 0))) |
| goto out; |
| |
| res = true; |
| out: |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hn)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hres)); |
| |
| return res; |
| } |
| |
| static void test_4109(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| size_t n = 0; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| for (n = 0; n < ARRAY_SIZE(test_4109_data); n++) { |
| if (!ADBG_EXPECT_TRUE(c, test_4109_mod(c, &session, |
| test_4109_data[n].op, test_4109_data[n].n, |
| test_4109_data[n].res))) { |
| Do_ADBG_Log("n %zu", n); |
| break; |
| } |
| } |
| |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4109, test_4109, |
| "Test TEE Internal API Arithmetical API - Mod"); |
| |
| static const char n2048str[] = "F9000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "000000000000000000000000000005C5"; |
| |
| static const struct { |
| const char *op1; |
| const char *op2; |
| const char *n; |
| const char *addres; |
| const char *mulres; |
| } test_4110_data[] = { |
| { "0", "0", "2", "0", "0" }, |
| { "1", "1", "2", "0", "1" }, |
| { "2", "2", "9", "4", "4" }, |
| { "123", "123", "200", "46", "C9" }, |
| { "0", "123", "200", "123", "0" }, |
| { "123", "0", "200", "123", "0" }, |
| |
| /* Testing some 2048 bit numbers */ |
| { "F9000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| , |
| "F9000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000001", |
| n2048str, |
| "F8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFA3C", |
| "2143D4" }, |
| |
| { "F9000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000", |
| "5C5", n2048str, "0", |
| "F8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFDEBC2C" }, |
| }; |
| |
| static bool 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) |
| { |
| bool res = false; |
| uint32_t hop1 = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hop2 = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hn = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t haddres = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hmulres = TA_CRYPT_ARITH_INVALID_HANDLE; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hop1))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hop2))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hn))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hc))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &haddres))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hmulres))) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_add_res, haddres))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_mul_res, hmulres))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_op1, hop1))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_op2, hop2))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_n, hn))) |
| goto out; |
| |
| /* hc = (hop1 + hop2) mod hn */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_addmod(c, s, hop1, hop2, hn, hc))) |
| goto out; |
| /* check hc == haddres */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, haddres, 0))) |
| goto out; |
| /* hc = (haddres - hop2) mod hn */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_submod(c, s, haddres, hop2, hn, |
| hc))) |
| goto out; |
| /* check hc == hop1 */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hop1, 0))) |
| goto out; |
| |
| /* hc = (hop1 * hop2) mod hn */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mulmod(c, s, hop1, hop2, hn, hc))) |
| goto out; |
| /* check hc == hmulres */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hmulres, 0))) |
| goto out; |
| |
| res = true; |
| out: |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop1)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop2)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hn)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, haddres)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hmulres)); |
| |
| return res; |
| } |
| |
| static bool 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) |
| { |
| bool res = false; |
| uint32_t hop1 = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hop2 = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hn = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hres = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hfmmres = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hctx = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t nbitsize = 0; |
| uint32_t n_is_odd = 0; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_fmm_var(c, s, 2048, &hop1))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_fmm_var(c, s, 2048, &hop2))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hn))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hres))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_fmm_var(c, s, 2048, &hfmmres))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hc))) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, str_n, hn))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_res, hres))) |
| goto out; |
| /* Check if FMM is applicable on this modulus */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_get_bit(c, s, hn, 0, &n_is_odd))) |
| goto out; |
| if (!n_is_odd) { |
| res = true; |
| goto out; |
| } |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_get_bit_count(c, s, hn, &nbitsize))) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_new_fmm_ctx(c, s, nbitsize, hn, &hctx))) |
| goto out; |
| |
| /* hop1 */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_op1, hc))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_to_fmm(c, s, hc, hn, hctx, hop1))) |
| goto out; |
| |
| /* hop2 */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_op2, hc))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_to_fmm(c, s, hc, hn, hctx, hop2))) |
| goto out; |
| |
| /* hfmmres = hop1 * hop2 */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_compute_fmm(c, s, hop1, hop2, hn, hctx, hfmmres))) |
| goto out; |
| /* hc = hfmmres mod hn*/ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_from_fmm(c, s, hfmmres, hn, hctx, hc))) |
| goto out; |
| /* check hc == hres */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hres, 0))) |
| goto out; |
| |
| res = true; |
| out: |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop1)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop2)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hn)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hres)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hfmmres)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hctx)); |
| return res; |
| } |
| |
| static void test_4110(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| size_t n = 0; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| for (n = 0; n < ARRAY_SIZE(test_4110_data); n++) { |
| if (!ADBG_EXPECT_TRUE(c, test_4110_mod(c, &session, |
| test_4110_data[n].op1, test_4110_data[n].op2, |
| test_4110_data[n].n, |
| test_4110_data[n].addres, |
| test_4110_data[n].mulres))) { |
| Do_ADBG_Log("n %zu", n); |
| break; |
| } |
| if (!ADBG_EXPECT_TRUE(c, test_4110_fmm(c, &session, |
| test_4110_data[n].op1, test_4110_data[n].op2, |
| test_4110_data[n].n, |
| test_4110_data[n].mulres))) { |
| Do_ADBG_Log("n %zu", n); |
| break; |
| } |
| } |
| |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4110, test_4110, |
| "Test TEE Internal API Arithmetical API - Mod arith"); |
| |
| static const struct { |
| const char *op; |
| const char *n; |
| const char *res; |
| } test_4111_data[] = { |
| { "2", "3", "2" }, |
| { "3", "7", "5" }, |
| { "5", "7", "3" }, |
| { "7B", "FA1", "8E5" }, |
| { "462D578CF0F88", "AB54A98CEB1F0AD3", "5ABBF22B54DBD000" }, |
| { "7", n2048str, |
| "B1DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6" |
| "DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB" |
| "6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6D" |
| "B6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6" |
| "DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB" |
| "6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6D" |
| "B6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6" |
| "DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB" |
| "6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6D" |
| "B6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6" |
| "DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB" |
| "6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6D" |
| "B6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6" |
| "DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB" |
| "6DB6DB6DB6DB6DB6DB6DB6DB6DB6DB6D" |
| "B6DB6DB6DB6DB6DB6DB6DB6DB6DB71D6" }, |
| }; |
| |
| static bool test_4111_invmod(ADBG_Case_t *c, TEEC_Session *s, |
| const char *str_op, const char *str_n, |
| const char *str_res) |
| { |
| bool res = false; |
| uint32_t hop = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hn = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hres = TA_CRYPT_ARITH_INVALID_HANDLE; |
| int32_t cres = 0; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hop))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hn))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hc))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hres))) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_res, hres))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_op, hop))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_n, hn))) |
| goto out; |
| |
| /* hc = hop^-1 mod hn */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_invmod(c, s, hop, hn, hc))) |
| goto out; |
| /* check hc == hres */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hres, 0))) |
| goto out; |
| |
| /* hc = (hres * hop) mod hn */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mulmod(c, s, hres, hop, hn, hc))) |
| goto out; |
| /* check hc == 1 */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_cmp_s32(c, s, hc, 1, &cres))) |
| goto out; |
| if (!ADBG_EXPECT_COMPARE_SIGNED(c, cres, ==, 0)) |
| goto out; |
| |
| /* hc = hres^-1 mod hn */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_invmod(c, s, hres, hn, hc))) |
| goto out; |
| /* check hc == hop */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hop, 0))) |
| goto out; |
| |
| res = true; |
| out: |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hn)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hres)); |
| |
| return res; |
| } |
| |
| static void test_4111(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| size_t n = 0; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| for (n = 0; n < ARRAY_SIZE(test_4111_data); n++) { |
| if (!ADBG_EXPECT_TRUE(c, test_4111_invmod(c, &session, |
| test_4111_data[n].op, test_4111_data[n].n, |
| test_4111_data[n].res))) { |
| Do_ADBG_Log("n %zu", n); |
| break; |
| } |
| } |
| |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4111, test_4111, |
| "Test TEE Internal API Arithmetical API - Invmod"); |
| |
| static const struct { |
| uint32_t level; |
| int32_t res1; |
| int32_t res2; |
| const char *op; |
| } test_4112_data[] = { |
| /* Simple cases */ |
| { 80, 0, 0, "0" }, |
| { 80, 0, 0, "1" }, |
| { 80, 1, -1, "2" }, |
| { 80, 1, -1, "3" }, |
| { 80, 1, -1, "17" }, |
| { 80, 1, -1, "FA1" }, |
| { 80, 0, 0, "FA0" }, |
| /* |
| * Testing large composites and the only allowed classification is |
| * "composite", aka "0". |
| */ |
| { 80, 0, 0, "136233FDE5569" }, |
| { 80, 0, 0, "177B96388FD94D5D7EC9AE513" }, |
| { 80, 0, 0, "22770A7DC599BC90B2FF981CCB5CF057" |
| "03344C8F3504189ED" }, |
| { 80, 0, 0, "0002ECD53B2150542D1494A424D50322" |
| "EBABBBD5DB89392A368D7759" }, |
| { 80, 0, 0, "00000004C8971C2B6F7A8503AB80749E" |
| "2BBA5BB6B6031BD43564DCA8003F0E3E" |
| "54E677A0A4B1B6153662B3130C11C273" |
| "C0F9408445B2ABB47D64153BEB48C154" |
| "659FDFDEDC496C8EA81AA7B7CE2B2CB1" |
| "AA7C8B407DE8C86F122607B2A226385D" |
| "9432F6CB30B5E4DE033E3363D48A1865" |
| "D9BC95DC7883D9DC9331691A17964979" }, |
| { 80, 0, 0, "00038AFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" |
| "FFFFFFFFFFFFFFEA5C6D11EDD2905192" |
| "C5429E6A6D796E89250BF563DA53D393" |
| "25129B70435894B56E337D5866F0BEF6" |
| "63D6C26DA889B69D4B1508ED63A17AFD" |
| "8BC0C5BE09AC18B64B2B7D87279D32EB" |
| "4F3375C10D58DF1F7CA2147A61CFA557" |
| "235244D4A4700AB5953C4C6ED428EB5F" |
| "09F07DAED46A995B8FFE48EFB93390C9" |
| "60685A31987879F818CCE9B9816E13DE" |
| "E4BEA5CC38C56A5D1983425DDD909C88" |
| "463B447F" }, |
| /* Large primes */ |
| { 80, 1, -1, "000136A352B2C7A5" }, |
| { 80, 1, -1, "000000022770A7DC599BC90B2FF981CC" |
| "B5CF05703344C8F350418AAD" }, |
| |
| { 80, 1, -1, "000067E04F440C5FECCA2694B1A4AB4F" |
| "CEC2D2B2D286FC93DD259D2B36A3A00D" |
| "F3726A4D4DFA99195998D92F43DD7370" |
| "B8C079E23072036F0C13F3F6ABA1D6DF" }, |
| |
| { 80, 1, -1, "000BC9F7E42CE74132EC6933DE1B8357" |
| "CD2AEB9E4B8A5F26BD233D1E6F295555" |
| "4D2CFA9760F3F69CCC52E8E428F68C37" |
| "AD5BC70CDB12F4DCEF23CB101C36A2A7" }, |
| |
| { 80, 1, -1, "00000005233FE157B5B44102598513AE" |
| "BB8876B0D1791769C8A1B0F36875D06F" |
| "E26951C7372192C7B21CAB67ADF0D6FE" |
| "1A718FB3FC4A51454DE87CD3F852005B" |
| "AAEC35D5" }, |
| |
| { 80, 1, -1, "0000001A655954FBC4408E09FE97EB82" |
| "5E0F096426B42317A36E53FF9608DD3F" |
| "A661040245906334496987EFB14BEA5F" |
| "7C050444C9B22A09EC76AF4EBDC609D8" |
| "A90C05E9E5AF06829C542DFCF7E6B9DC" |
| "0B065659C1816309CD6012C37F8CE649" |
| "8DECF850F33943F0F83081406846D306" |
| "22E0BCE697E612FC1F7A5D902280D6E0" |
| "3009E585" }, |
| }; |
| |
| static bool 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) |
| { |
| bool res = false; |
| uint32_t hop = TA_CRYPT_ARITH_INVALID_HANDLE; |
| int32_t pres = 11; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hop))) |
| return res; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_val, hop))) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_is_prime(c, s, hop, conf_level, |
| &pres))) |
| goto out; |
| if (!ADBG_EXPECT_TRUE(c, pres == res1 || pres == res2)) { |
| Do_ADBG_Log("Unexpected prime clasification %" PRId32 ", expected %" PRId32 " or %" PRId32, |
| pres, res1, res2); |
| goto out; |
| } |
| |
| res = true; |
| out: |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop)); |
| |
| return res; |
| } |
| |
| static void test_4112(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| size_t n = 0; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| for (n = 0; n < ARRAY_SIZE(test_4112_data); n++) { |
| if (!ADBG_EXPECT_TRUE(c, test_4112_is_prime(c, &session, |
| test_4112_data[n].level, |
| test_4112_data[n].res1, |
| test_4112_data[n].res2, |
| test_4112_data[n].op))) { |
| Do_ADBG_Log("n %zu", n); |
| break; |
| } |
| } |
| |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4112, test_4112, |
| "Test TEE Internal API Arithmetical API - Is prime"); |
| |
| static const struct { |
| const char *res; |
| size_t bits; |
| const char *op; |
| } test_4113_data[] = { |
| { "0", 31, "7FFFFFFF" }, |
| { "0", 65, "7FFFFFFF" }, |
| { "0", 1, "0" }, |
| { "-1",1, "-2" }, |
| { "1", 0, "1" }, |
| { "1", 1, "2" }, |
| { "1", 2, "4" }, |
| { "1", 3, "8" }, |
| { "1", 4, "10" }, |
| { "1", 5, "20" }, |
| { "1", 6, "40" }, |
| { "1", 7, "80" }, |
| { "1", 8, "100" }, |
| { "1", 9, "200" }, |
| { "1", 10, "400" }, |
| { "1", 11, "800" }, |
| { "1", 12, "1000" }, |
| { "1", 13, "2000" }, |
| { "1", 14, "4000" }, |
| { "1", 15, "8000" }, |
| { "1", 16, "10000" }, |
| { "1", 17, "20000" }, |
| { "1", 18, "40000" }, |
| { "1", 19, "80000" }, |
| { "1", 20, "100000" }, |
| { "1", 21, "200000" }, |
| { "1", 22, "400000" }, |
| { "1", 23, "800000" }, |
| { "1", 24, "1000000" }, |
| { "1", 25, "2000000" }, |
| { "1", 26, "4000000" }, |
| { "1", 27, "8000000" }, |
| { "1", 28, "10000000" }, |
| { "1", 29, "20000000" }, |
| { "1", 30, "40000000" }, |
| { "1", 31, "80000000" }, |
| { "1", 32, "100000000" }, |
| { "1", 64, "10000000000000000" }, |
| { "FFFFFFFF", 64, "FFFFFFFF0000000000000000" }, |
| { "1111FFFF0000", 64," 1111FFFF00000000000000000000" }, |
| { "1", 33, "200000000" }, |
| { "1", 65, "20000000000000000" }, |
| { "FFFFFFFF", 65, "1FFFFFFFE0000000000000000" }, |
| { "24B0D975EC8FCC8E1D54CA4BF7ACFC4534F04", 81, |
| "4961B2EBD91F991C3AA99497EF59F88A69E08AD5C340167793C3CC32F" }, |
| }; |
| |
| static bool test_4113_shift_right(ADBG_Case_t *c, TEEC_Session *s, |
| const char *str_op, size_t bits, |
| const char *str_res) |
| { |
| bool res = false; |
| uint32_t hop = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hc = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hres = TA_CRYPT_ARITH_INVALID_HANDLE; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hop))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hc))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hres))) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_res, hres))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| convert_from_string(c, s, str_op, hop))) |
| goto out; |
| |
| /* hc = hop shift_right bits */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_shift_right(c, s, hop, bits, hc))) |
| goto out; |
| /* check hc == hres */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hc, hres, 0))) |
| goto out; |
| |
| res = true; |
| out: |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hop)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hc)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hres)); |
| |
| return res; |
| } |
| |
| static void test_4113(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| size_t n = 0; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| for (n = 0; n < ARRAY_SIZE(test_4113_data); n++) { |
| if (!ADBG_EXPECT_TRUE(c, test_4113_shift_right(c, &session, |
| test_4113_data[n].op, test_4113_data[n].bits, |
| test_4113_data[n].res))) { |
| Do_ADBG_Log("n %zu", n); |
| break; |
| } |
| } |
| |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4113, test_4113, |
| "Test TEE Internal API Arithmetical API - shift right"); |
| |
| static const struct { |
| const char *strx; |
| const char *stry; |
| } test_4114_data[] = { |
| { "0", "0" }, |
| { "0", "123" }, |
| { "1", "1" }, |
| { "1", "-1" }, |
| { "2", "2" }, |
| { "-2", "2" }, |
| { "2", "4" }, |
| { "-2", "-4" }, |
| { "400", "800" }, |
| { "261", "2B5" }, |
| { "F", "A" }, |
| { "C", "13" }, |
| { "165D662", "1664FEA" }, |
| { "AB59CDFD83CE2B24", |
| "4961BF04008953A7F9567AAFBA94D4AF55F473F14FD68AA022982F0FE" }, |
| /* two large primes */ |
| { "5D0A380DC40EDE5E036FA051FC6D7F93", |
| "3277FD425328576569AFB2EAC6B1430578099CA8ADA4BC73" }, |
| /* two large powers of 2 */ |
| { "20000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "0", |
| "40000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "00000000000000000000000000000000" |
| "000000000000000000000" }, |
| }; |
| |
| static bool test_4114_gcd(ADBG_Case_t *c, TEEC_Session *s, const char *strx, |
| const char *stry) |
| { |
| bool res = false; |
| uint32_t hx = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hy = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t ha = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hb = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t hgcd = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t ht1 = TA_CRYPT_ARITH_INVALID_HANDLE; |
| uint32_t ht2 = TA_CRYPT_ARITH_INVALID_HANDLE; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hx))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hy))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &ha))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hb))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &hgcd))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &ht1))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_new_var(c, s, 2048, &ht2))) |
| goto out; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, strx, hx))) |
| goto out; |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, convert_from_string(c, s, stry, hy))) |
| goto out; |
| |
| /* (hgcd, a, b) = ExtendedGCD(x, y) */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| cmd_compute_egcd(c, s, hx, hy, ha, hb, hgcd))) |
| goto out; |
| /* ht1 = GCD(x, y) */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_compute_gcd(c, s, hx, hy, ht1))) |
| goto out; |
| /* check hgcd == ht1 */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hgcd, ht1, 0))) |
| goto out; |
| |
| /* ht1 = a * x */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mul(c, s, ha, hx, ht1))) |
| goto out; |
| /* ht2 = b * y */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_mul(c, s, hb, hy, ht2))) |
| goto out; |
| /* ht1 = ht1 + ht2 */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, cmd_add(c, s, ht1, ht2, ht1))) |
| goto out; |
| /* check hgcd == ht1 */ |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, compare_handle(c, s, hgcd, ht1, 0))) |
| goto out; |
| |
| res = true; |
| out: |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hx)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hy)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, ha)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hb)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, hgcd)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, ht1)); |
| ADBG_EXPECT_TEEC_SUCCESS(c, cmd_free_handle(c, s, ht2)); |
| |
| return res; |
| } |
| |
| static void test_4114(ADBG_Case_t *c) |
| { |
| TEEC_Session session = { }; |
| uint32_t ret_orig = 0; |
| size_t n = 0; |
| |
| if (!ADBG_EXPECT_TEEC_SUCCESS(c, |
| xtest_teec_open_session(&session, &crypt_user_ta_uuid, |
| NULL, &ret_orig))) |
| return; |
| |
| for (n = 0; n < ARRAY_SIZE(test_4114_data); n++) { |
| if (!ADBG_EXPECT_TRUE(c, test_4114_gcd(c, &session, |
| test_4114_data[n].strx, |
| test_4114_data[n].stry))) { |
| Do_ADBG_Log("n %zu", n); |
| break; |
| } |
| } |
| |
| TEEC_CloseSession(&session); |
| } |
| ADBG_CASE_DEFINE(regression, 4114, test_4114, |
| "Test TEE Internal API Arithmetical API - GCD"); |