cuberite/polarssl
1
0
Fork 0
mirror of https://github.com/cuberite/polarssl.git synced 2025-09-30 08:56:50 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #7329 from minosgalanakis/ecp/unify_test_cases

Browse Source 
ecp: Unify test cases
This commit is contained in:
Janos Follath 2023-04-12 13:23:16 +01:00 committed by GitHub
commit 6d3ec55849
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 91 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
scripts/mbedtls_dev/bignum_common.py
View File

@ -17,6 +17,7 @@
from abc import abstractmethod from abc import abstractmethod
import enum import enum
from typing import Iterator, List, Tuple, TypeVar, Any from typing import Iterator, List, Tuple, TypeVar, Any
from copy import deepcopy
from itertools import chain from itertools import chain
from . import test_case from . import test_case
@ -104,6 +105,7 @@ class OperationCommon(test_data_generation.BaseTest):
symbol = "" symbol = ""
input_values = INPUTS_DEFAULT # type: List[str] input_values = INPUTS_DEFAULT # type: List[str]
input_cases = [] # type: List[Any] input_cases = [] # type: List[Any]
dependencies = [] # type: List[Any]
unique_combinations_only = False unique_combinations_only = False
input_styles = ["variable", "fixed", "arch_split"] # type: List[str] input_styles = ["variable", "fixed", "arch_split"] # type: List[str]
input_style = "variable" # type: str input_style = "variable" # type: str
@ -119,10 +121,11 @@ class OperationCommon(test_data_generation.BaseTest):
# provides earlier/more robust input validation. # provides earlier/more robust input validation.
self.int_a = hex_to_int(val_a) self.int_a = hex_to_int(val_a)
self.int_b = hex_to_int(val_b) self.int_b = hex_to_int(val_b)
self.dependencies = deepcopy(self.dependencies)
if bits_in_limb not in self.limb_sizes: if bits_in_limb not in self.limb_sizes:
raise ValueError("Invalid number of bits in limb!") raise ValueError("Invalid number of bits in limb!")
if self.input_style == "arch_split": if self.input_style == "arch_split":
self.dependencies = ["MBEDTLS_HAVE_INT{:d}".format(bits_in_limb)] self.dependencies.append("MBEDTLS_HAVE_INT{:d}".format(bits_in_limb))
self.bits_in_limb = bits_in_limb self.bits_in_limb = bits_in_limb
@property @property

36
scripts/mbedtls_dev/ecp.py
View File

@ -30,10 +30,11 @@ class EcpP192R1Raw(bignum_common.ModOperationCommon,
EcpTarget): EcpTarget):
"""Test cases for ECP P192 fast reduction.""" """Test cases for ECP P192 fast reduction."""
symbol = "-" symbol = "-"
test_function = "ecp_mod_p192_raw" test_function = "ecp_mod_p_generic_raw"
test_name = "ecp_mod_p192_raw" test_name = "ecp_mod_p192_raw"
input_style = "fixed" input_style = "fixed"
arity = 1 arity = 1
dependencies = ["MBEDTLS_ECP_DP_SECP192R1_ENABLED"]
moduli = ["fffffffffffffffffffffffffffffffeffffffffffffffff"] # type: List[str] moduli = ["fffffffffffffffffffffffffffffffeffffffffffffffff"] # type: List[str]
@ -96,15 +97,20 @@ class EcpP192R1Raw(bignum_common.ModOperationCommon,
def is_valid(self) -> bool: def is_valid(self) -> bool:
return True return True
def arguments(self):
args = super().arguments()
return ["MBEDTLS_ECP_DP_SECP192R1"] + args
class EcpP224R1Raw(bignum_common.ModOperationCommon, class EcpP224R1Raw(bignum_common.ModOperationCommon,
EcpTarget): EcpTarget):
"""Test cases for ECP P224 fast reduction.""" """Test cases for ECP P224 fast reduction."""
symbol = "-" symbol = "-"
test_function = "ecp_mod_p224_raw" test_function = "ecp_mod_p_generic_raw"
test_name = "ecp_mod_p224_raw" test_name = "ecp_mod_p224_raw"
input_style = "arch_split" input_style = "arch_split"
arity = 1 arity = 1
dependencies = ["MBEDTLS_ECP_DP_SECP224R1_ENABLED"]
moduli = ["ffffffffffffffffffffffffffffffff000000000000000000000001"] # type: List[str] moduli = ["ffffffffffffffffffffffffffffffff000000000000000000000001"] # type: List[str]
@ -168,15 +174,20 @@ class EcpP224R1Raw(bignum_common.ModOperationCommon,
def is_valid(self) -> bool: def is_valid(self) -> bool:
return True return True
def arguments(self):
args = super().arguments()
return ["MBEDTLS_ECP_DP_SECP224R1"] + args
class EcpP256R1Raw(bignum_common.ModOperationCommon, class EcpP256R1Raw(bignum_common.ModOperationCommon,
EcpTarget): EcpTarget):
"""Test cases for ECP P256 fast reduction.""" """Test cases for ECP P256 fast reduction."""
symbol = "-" symbol = "-"
test_function = "ecp_mod_p256_raw" test_function = "ecp_mod_p_generic_raw"
test_name = "ecp_mod_p256_raw" test_name = "ecp_mod_p256_raw"
input_style = "fixed" input_style = "fixed"
arity = 1 arity = 1
dependencies = ["MBEDTLS_ECP_DP_SECP256R1_ENABLED"]
moduli = ["ffffffff00000001000000000000000000000000ffffffffffffffffffffffff"] # type: List[str] moduli = ["ffffffff00000001000000000000000000000000ffffffffffffffffffffffff"] # type: List[str]
@ -247,14 +258,19 @@ class EcpP256R1Raw(bignum_common.ModOperationCommon,
def is_valid(self) -> bool: def is_valid(self) -> bool:
return True return True
def arguments(self):
args = super().arguments()
return ["MBEDTLS_ECP_DP_SECP256R1"] + args
class EcpP384R1Raw(bignum_common.ModOperationCommon, class EcpP384R1Raw(bignum_common.ModOperationCommon,
EcpTarget): EcpTarget):
"""Test cases for ECP P384 fast reduction.""" """Test cases for ECP P384 fast reduction."""
test_function = "ecp_mod_p384_raw" test_function = "ecp_mod_p_generic_raw"
test_name = "ecp_mod_p384_raw" test_name = "ecp_mod_p384_raw"
input_style = "fixed" input_style = "fixed"
arity = 1 arity = 1
dependencies = ["MBEDTLS_ECP_DP_SECP384R1_ENABLED"]
moduli = [("ffffffffffffffffffffffffffffffffffffffffffffffff" moduli = [("ffffffffffffffffffffffffffffffffffffffffffffffff"
"fffffffffffffffeffffffff0000000000000000ffffffff") "fffffffffffffffeffffffff0000000000000000ffffffff")
@ -364,13 +380,19 @@ class EcpP384R1Raw(bignum_common.ModOperationCommon,
def is_valid(self) -> bool: def is_valid(self) -> bool:
return True return True
def arguments(self):
args = super().arguments()
return ["MBEDTLS_ECP_DP_SECP384R1"] + args
class EcpP521R1Raw(bignum_common.ModOperationCommon, class EcpP521R1Raw(bignum_common.ModOperationCommon,
EcpTarget): EcpTarget):
"""Test cases for ECP P521 fast reduction.""" """Test cases for ECP P521 fast reduction."""
test_function = "ecp_mod_p521_raw" test_function = "ecp_mod_p_generic_raw"
test_name = "ecp_mod_p521_raw" test_name = "ecp_mod_p521_raw"
input_style = "arch_split" input_style = "arch_split"
arity = 1 arity = 1
dependencies = ["MBEDTLS_ECP_DP_SECP521R1_ENABLED"]
moduli = [("01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" moduli = [("01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff") "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
@ -462,3 +484,7 @@ class EcpP521R1Raw(bignum_common.ModOperationCommon,
@property @property
def is_valid(self) -> bool: def is_valid(self) -> bool:
return True return True
def arguments(self):
args = super().arguments()
return ["MBEDTLS_ECP_DP_SECP521R1"] + args

238
tests/suites/test_suite_ecp.function
View File

@ -1266,10 +1266,11 @@ exit:
} }
/* END_CASE */ /* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS:MBEDTLS_ECP_DP_SECP192R1_ENABLED */ /* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS */
void ecp_mod_p192_raw(char *input_N, void ecp_mod_p_generic_raw(int curve_id,
char *input_X, char *input_N,
char *result) char *input_X,
char *result)
{ {
mbedtls_mpi_uint *X = NULL; mbedtls_mpi_uint *X = NULL;
mbedtls_mpi_uint *N = NULL; mbedtls_mpi_uint *N = NULL;
@ -1278,48 +1279,10 @@ void ecp_mod_p192_raw(char *input_N,
size_t limbs_N; size_t limbs_N;
size_t limbs_res; size_t limbs_res;
mbedtls_mpi_mod_modulus m; size_t bytes;
mbedtls_mpi_mod_modulus_init(&m); size_t limbs;
size_t curve_bits;
TEST_EQUAL(mbedtls_test_read_mpi_core(&X, &limbs_X, input_X), 0); int (*curve_func)(mbedtls_mpi_uint *X, size_t X_limbs);
TEST_EQUAL(mbedtls_test_read_mpi_core(&N, &limbs_N, input_N), 0);
TEST_EQUAL(mbedtls_test_read_mpi_core(&res, &limbs_res, result), 0);
size_t limbs = limbs_N;
size_t bytes = limbs * sizeof(mbedtls_mpi_uint);
TEST_EQUAL(limbs_X, 2 * limbs);
TEST_EQUAL(limbs_res, limbs);
TEST_EQUAL(mbedtls_mpi_mod_modulus_setup(
&m, N, limbs,
MBEDTLS_MPI_MOD_REP_MONTGOMERY), 0);
TEST_EQUAL(mbedtls_ecp_mod_p192_raw(X, limbs_X), 0);
TEST_LE_U(mbedtls_mpi_core_bitlen(X, limbs_X), 192);
mbedtls_mpi_mod_raw_fix_quasi_reduction(X, &m);
ASSERT_COMPARE(X, bytes, res, bytes);
exit:
mbedtls_free(X);
mbedtls_free(res);
mbedtls_mpi_mod_modulus_free(&m);
mbedtls_free(N);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS:MBEDTLS_ECP_DP_SECP224R1_ENABLED */
void ecp_mod_p224_raw(char *input_N,
char *input_X,
char *result)
{
mbedtls_mpi_uint *X = NULL;
mbedtls_mpi_uint *N = NULL;
mbedtls_mpi_uint *res = NULL;
size_t limbs_X;
size_t limbs_N;
size_t limbs_res;
mbedtls_mpi_mod_modulus m; mbedtls_mpi_mod_modulus m;
mbedtls_mpi_mod_modulus_init(&m); mbedtls_mpi_mod_modulus_init(&m);
@ -1327,148 +1290,59 @@ void ecp_mod_p224_raw(char *input_N,
TEST_EQUAL(mbedtls_test_read_mpi_core(&X, &limbs_X, input_X), 0); TEST_EQUAL(mbedtls_test_read_mpi_core(&X, &limbs_X, input_X), 0);
TEST_EQUAL(mbedtls_test_read_mpi_core(&N, &limbs_N, input_N), 0); TEST_EQUAL(mbedtls_test_read_mpi_core(&N, &limbs_N, input_N), 0);
TEST_EQUAL(mbedtls_test_read_mpi_core(&res, &limbs_res, result), 0); TEST_EQUAL(mbedtls_test_read_mpi_core(&res, &limbs_res, result), 0);
bytes = limbs_N * sizeof(mbedtls_mpi_uint);
size_t limbs = limbs_N; switch (curve_id) {
size_t bytes = limbs * sizeof(mbedtls_mpi_uint); #if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
case MBEDTLS_ECP_DP_SECP192R1:
limbs = 2 * limbs_N;
curve_bits = 192;
curve_func = &mbedtls_ecp_mod_p192_raw;
break;
#endif
#if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
case MBEDTLS_ECP_DP_SECP224R1:
limbs = 448 / biL;
curve_bits = 224;
curve_func = &mbedtls_ecp_mod_p224_raw;
break;
#endif
#if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
case MBEDTLS_ECP_DP_SECP256R1:
limbs = 2 * limbs_N;
curve_bits = 256;
curve_func = &mbedtls_ecp_mod_p256_raw;
break;
#endif
#if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
case MBEDTLS_ECP_DP_SECP384R1:
limbs = 2 * limbs_N;
curve_bits = 384;
curve_func = &mbedtls_ecp_mod_p384_raw;
break;
#endif
#if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
case MBEDTLS_ECP_DP_SECP521R1:
limbs = 2 * limbs_N;
curve_bits = 522;
curve_func = &mbedtls_ecp_mod_p521_raw;
break;
#endif
default:
mbedtls_test_fail("Unsupported curve_id", __LINE__, __FILE__);
goto exit;
}
TEST_EQUAL(limbs_X, 448 / biL); TEST_EQUAL(limbs_X, limbs);
TEST_EQUAL(limbs_res, limbs); TEST_EQUAL(limbs_res, limbs_N);
TEST_EQUAL(mbedtls_mpi_mod_modulus_setup( TEST_EQUAL(mbedtls_mpi_mod_modulus_setup(
&m, N, limbs, &m, N, limbs_N,
MBEDTLS_MPI_MOD_REP_MONTGOMERY), 0); MBEDTLS_MPI_MOD_REP_OPT_RED), 0);
TEST_EQUAL(mbedtls_ecp_mod_p224_raw(X, limbs_X), 0); TEST_EQUAL((*curve_func)(X, limbs_X), 0);
TEST_LE_U(mbedtls_mpi_core_bitlen(X, limbs_X), 224);
mbedtls_mpi_mod_raw_fix_quasi_reduction(X, &m);
ASSERT_COMPARE(X, bytes, res, bytes);
exit: TEST_LE_U(mbedtls_mpi_core_bitlen(X, limbs_X), curve_bits);
mbedtls_free(X);
mbedtls_free(res);
mbedtls_mpi_mod_modulus_free(&m);
mbedtls_free(N);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS:MBEDTLS_ECP_DP_SECP256R1_ENABLED */
void ecp_mod_p256_raw(char *input_N,
char *input_X,
char *result)
{
mbedtls_mpi_uint *X = NULL;
mbedtls_mpi_uint *N = NULL;
mbedtls_mpi_uint *res = NULL;
size_t limbs_X;
size_t limbs_N;
size_t limbs_res;
mbedtls_mpi_mod_modulus m;
mbedtls_mpi_mod_modulus_init(&m);
TEST_EQUAL(mbedtls_test_read_mpi_core(&X, &limbs_X, input_X), 0);
TEST_EQUAL(mbedtls_test_read_mpi_core(&N, &limbs_N, input_N), 0);
TEST_EQUAL(mbedtls_test_read_mpi_core(&res, &limbs_res, result), 0);
size_t limbs = limbs_N;
size_t bytes = limbs * sizeof(mbedtls_mpi_uint);
TEST_EQUAL(limbs_X, 2 * limbs);
TEST_EQUAL(limbs_res, limbs);
TEST_EQUAL(mbedtls_mpi_mod_modulus_setup(
&m, N, limbs,
MBEDTLS_MPI_MOD_REP_MONTGOMERY), 0);
TEST_EQUAL(mbedtls_ecp_mod_p256_raw(X, limbs_X), 0);
TEST_LE_U(mbedtls_mpi_core_bitlen(X, limbs_X), 256);
mbedtls_mpi_mod_raw_fix_quasi_reduction(X, &m);
ASSERT_COMPARE(X, bytes, res, bytes);
exit:
mbedtls_free(X);
mbedtls_free(res);
mbedtls_mpi_mod_modulus_free(&m);
mbedtls_free(N);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS:MBEDTLS_ECP_DP_SECP384R1_ENABLED */
void ecp_mod_p384_raw(char *input_N,
char *input_X,
char *result)
{
mbedtls_mpi_uint *X = NULL;
mbedtls_mpi_uint *N = NULL;
mbedtls_mpi_uint *res = NULL;
size_t limbs_X;
size_t limbs_N;
size_t limbs_res;
mbedtls_mpi_mod_modulus m;
mbedtls_mpi_mod_modulus_init(&m);
TEST_EQUAL(mbedtls_test_read_mpi_core(&X, &limbs_X, input_X), 0);
TEST_EQUAL(mbedtls_test_read_mpi_core(&N, &limbs_N, input_N), 0);
TEST_EQUAL(mbedtls_test_read_mpi_core(&res, &limbs_res, result), 0);
size_t limbs = limbs_N;
size_t bytes = limbs * sizeof(mbedtls_mpi_uint);
TEST_EQUAL(limbs_X, 2 * limbs);
TEST_EQUAL(limbs_res, limbs);
TEST_EQUAL(mbedtls_mpi_mod_modulus_setup(
&m, N, limbs,
MBEDTLS_MPI_MOD_REP_MONTGOMERY), 0);
TEST_EQUAL(mbedtls_ecp_mod_p384_raw(X, limbs_X), 0);
TEST_LE_U(mbedtls_mpi_core_bitlen(X, limbs_X), 384);
mbedtls_mpi_mod_raw_fix_quasi_reduction(X, &m);
ASSERT_COMPARE(X, bytes, res, bytes);
exit:
mbedtls_free(X);
mbedtls_free(res);
mbedtls_mpi_mod_modulus_free(&m);
mbedtls_free(N);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS:MBEDTLS_ECP_DP_SECP521R1_ENABLED */
void ecp_mod_p521_raw(char *input_N,
char *input_X,
char *result)
{
mbedtls_mpi_uint *X = NULL;
mbedtls_mpi_uint *N = NULL;
mbedtls_mpi_uint *res = NULL;
size_t limbs_X;
size_t limbs_N;
size_t limbs_res;
mbedtls_mpi_mod_modulus m;
mbedtls_mpi_mod_modulus_init(&m);
TEST_EQUAL(mbedtls_test_read_mpi_core(&X, &limbs_X, input_X), 0);
TEST_EQUAL(mbedtls_test_read_mpi_core(&N, &limbs_N, input_N), 0);
TEST_EQUAL(mbedtls_test_read_mpi_core(&res, &limbs_res, result), 0);
size_t limbs = limbs_N;
size_t bytes = limbs * sizeof(mbedtls_mpi_uint);
TEST_EQUAL(limbs_X, 2 * limbs);
TEST_EQUAL(limbs_res, limbs);
TEST_EQUAL(mbedtls_mpi_mod_modulus_setup(
&m, N, limbs,
MBEDTLS_MPI_MOD_REP_MONTGOMERY), 0);
TEST_EQUAL(mbedtls_ecp_mod_p521_raw(X, limbs_X), 0);
TEST_LE_U(mbedtls_mpi_core_bitlen(X, limbs_X), 522);
mbedtls_mpi_mod_raw_fix_quasi_reduction(X, &m); mbedtls_mpi_mod_raw_fix_quasi_reduction(X, &m);
ASSERT_COMPARE(X, bytes, res, bytes); ASSERT_COMPARE(X, bytes, res, bytes);