// 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");
|
