mirror of
https://github.com/Mbed-TLS/mbedtls.git
synced 2025-06-24 01:41:35 +03:00
Merge branch 'development' into sha3
Signed-off-by: Pol Henarejos <pol.henarejos@cttc.es>
This commit is contained in:
Pol Henarejos
@ -215,6 +215,8 @@ EXCLUDE_FROM_FULL = frozenset([
|
||||
'MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN', # build dependency (clang+memsan)
|
||||
'MBEDTLS_TEST_CONSTANT_FLOW_VALGRIND', # build dependency (valgrind headers)
|
||||
'MBEDTLS_X509_REMOVE_INFO', # removes a feature
|
||||
'MBEDTLS_SSL_RECORD_SIZE_LIMIT', # in development, currently breaks other tests
|
||||
'MBEDTLS_P256M_EXAMPLE_DRIVER_ENABLED' # influences SECP256R1 KeyGen/ECDH/ECDSA
|
||||
])
|
||||
|
||||
def is_seamless_alt(name):
|
||||
@ -229,7 +231,7 @@ def is_seamless_alt(name):
|
||||
Exclude alternative implementations of library functions since they require
|
||||
an implementation of the relevant functions and an xxx_alt.h header.
|
||||
"""
|
||||
if name == 'MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT':
|
||||
if name in ('MBEDTLS_PLATFORM_SETUP_TEARDOWN_ALT', 'MBEDTLS_PLATFORM_MS_TIME_ALT'):
|
||||
# Similar to non-platform xxx_ALT, requires platform_alt.h
|
||||
return False
|
||||
return name.startswith('MBEDTLS_PLATFORM_')
|
||||
|
||||
@ -28,6 +28,7 @@
|
||||
#include "psa_crypto_driver_wrappers.h"
|
||||
#include "psa_crypto_hash.h"
|
||||
#include "psa_crypto_mac.h"
|
||||
#include "psa_crypto_pake.h"
|
||||
#include "psa_crypto_rsa.h"
|
||||
|
||||
#include "mbedtls/platform.h"
|
||||
@ -36,7 +37,6 @@
|
||||
#if defined(MBEDTLS_PSA_CRYPTO_C)
|
||||
|
||||
/* BEGIN-driver headers */
|
||||
#if defined(MBEDTLS_PSA_CRYPTO_DRIVERS)
|
||||
{% for driver in drivers -%}
|
||||
/* Headers for {{driver.prefix}} {{driver.type}} driver */
|
||||
{% if driver['mbedtls/h_condition'] is defined -%}
|
||||
@ -49,7 +49,6 @@
|
||||
#endif
|
||||
{% endif -%}
|
||||
{% endfor %}
|
||||
#endif /* MBEDTLS_PSA_CRYPTO_DRIVERS */
|
||||
/* END-driver headers */
|
||||
|
||||
/* Auto-generated values depending on which drivers are registered.
|
||||
@ -317,6 +316,26 @@ psa_status_t psa_driver_wrapper_sign_hash(
|
||||
if( status != PSA_ERROR_NOT_SUPPORTED )
|
||||
return( status );
|
||||
#endif /* PSA_CRYPTO_DRIVER_TEST */
|
||||
#if defined (MBEDTLS_P256M_EXAMPLE_DRIVER_ENABLED)
|
||||
if( PSA_KEY_TYPE_IS_ECC( attributes->core.type ) &&
|
||||
PSA_ALG_IS_ECDSA(alg) &&
|
||||
!PSA_ALG_ECDSA_IS_DETERMINISTIC( alg ) &&
|
||||
PSA_KEY_TYPE_ECC_GET_FAMILY(attributes->core.type) == PSA_ECC_FAMILY_SECP_R1 &&
|
||||
attributes->core.bits == 256 )
|
||||
{
|
||||
status = p256_transparent_sign_hash( attributes,
|
||||
key_buffer,
|
||||
key_buffer_size,
|
||||
alg,
|
||||
hash,
|
||||
hash_length,
|
||||
signature,
|
||||
signature_size,
|
||||
signature_length );
|
||||
if( status != PSA_ERROR_NOT_SUPPORTED )
|
||||
return( status );
|
||||
}
|
||||
#endif /* MBEDTLS_P256M_EXAMPLE_DRIVER_ENABLED */
|
||||
#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
|
||||
/* Fell through, meaning no accelerator supports this operation */
|
||||
return( psa_sign_hash_builtin( attributes,
|
||||
@ -401,6 +420,25 @@ psa_status_t psa_driver_wrapper_verify_hash(
|
||||
if( status != PSA_ERROR_NOT_SUPPORTED )
|
||||
return( status );
|
||||
#endif /* PSA_CRYPTO_DRIVER_TEST */
|
||||
#if defined (MBEDTLS_P256M_EXAMPLE_DRIVER_ENABLED)
|
||||
if( PSA_KEY_TYPE_IS_ECC( attributes->core.type ) &&
|
||||
PSA_ALG_IS_ECDSA(alg) &&
|
||||
!PSA_ALG_ECDSA_IS_DETERMINISTIC( alg ) &&
|
||||
PSA_KEY_TYPE_ECC_GET_FAMILY(attributes->core.type) == PSA_ECC_FAMILY_SECP_R1 &&
|
||||
attributes->core.bits == 256 )
|
||||
{
|
||||
status = p256_transparent_verify_hash( attributes,
|
||||
key_buffer,
|
||||
key_buffer_size,
|
||||
alg,
|
||||
hash,
|
||||
hash_length,
|
||||
signature,
|
||||
signature_length );
|
||||
if( status != PSA_ERROR_NOT_SUPPORTED )
|
||||
return( status );
|
||||
}
|
||||
#endif /* MBEDTLS_P256M_EXAMPLE_DRIVER_ENABLED */
|
||||
#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
|
||||
|
||||
return( psa_verify_hash_builtin( attributes,
|
||||
@ -815,6 +853,20 @@ psa_status_t psa_driver_wrapper_generate_key(
|
||||
if( status != PSA_ERROR_NOT_SUPPORTED )
|
||||
break;
|
||||
#endif /* PSA_CRYPTO_DRIVER_TEST */
|
||||
#if defined(MBEDTLS_P256M_EXAMPLE_DRIVER_ENABLED)
|
||||
if( PSA_KEY_TYPE_IS_ECC( attributes->core.type ) &&
|
||||
attributes->core.type == PSA_KEY_TYPE_ECC_KEY_PAIR(PSA_ECC_FAMILY_SECP_R1) &&
|
||||
attributes->core.bits == 256 )
|
||||
{
|
||||
status = p256_transparent_generate_key( attributes,
|
||||
key_buffer,
|
||||
key_buffer_size,
|
||||
key_buffer_length );
|
||||
if( status != PSA_ERROR_NOT_SUPPORTED )
|
||||
break;
|
||||
}
|
||||
|
||||
#endif /* MBEDTLS_P256M_EXAMPLE_DRIVER_ENABLED */
|
||||
}
|
||||
#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
|
||||
|
||||
@ -2753,6 +2805,25 @@ psa_status_t psa_driver_wrapper_key_agreement(
|
||||
if( status != PSA_ERROR_NOT_SUPPORTED )
|
||||
return( status );
|
||||
#endif /* PSA_CRYPTO_DRIVER_TEST */
|
||||
#if defined(MBEDTLS_P256M_EXAMPLE_DRIVER_ENABLED)
|
||||
if( PSA_KEY_TYPE_IS_ECC( attributes->core.type ) &&
|
||||
PSA_ALG_IS_ECDH(alg) &&
|
||||
PSA_KEY_TYPE_ECC_GET_FAMILY(attributes->core.type) == PSA_ECC_FAMILY_SECP_R1 &&
|
||||
attributes->core.bits == 256 )
|
||||
{
|
||||
status = p256_transparent_key_agreement( attributes,
|
||||
key_buffer,
|
||||
key_buffer_size,
|
||||
alg,
|
||||
peer_key,
|
||||
peer_key_length,
|
||||
shared_secret,
|
||||
shared_secret_size,
|
||||
shared_secret_length );
|
||||
if( status != PSA_ERROR_NOT_SUPPORTED)
|
||||
return( status );
|
||||
}
|
||||
#endif /* MBEDTLS_P256M_EXAMPLE_DRIVER_ENABLED */
|
||||
#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
|
||||
|
||||
/* Software Fallback */
|
||||
@ -2790,4 +2861,162 @@ psa_status_t psa_driver_wrapper_key_agreement(
|
||||
}
|
||||
}
|
||||
|
||||
psa_status_t psa_driver_wrapper_pake_setup(
|
||||
psa_pake_operation_t *operation,
|
||||
const psa_crypto_driver_pake_inputs_t *inputs )
|
||||
{
|
||||
psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
|
||||
|
||||
psa_key_location_t location =
|
||||
PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime( &inputs->attributes ) );
|
||||
|
||||
switch( location )
|
||||
{
|
||||
case PSA_KEY_LOCATION_LOCAL_STORAGE:
|
||||
/* Key is stored in the slot in export representation, so
|
||||
* cycle through all known transparent accelerators */
|
||||
#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
|
||||
#if defined(PSA_CRYPTO_DRIVER_TEST)
|
||||
status = mbedtls_test_transparent_pake_setup(
|
||||
&operation->data.ctx.transparent_test_driver_ctx,
|
||||
inputs );
|
||||
if( status == PSA_SUCCESS )
|
||||
operation->id = MBEDTLS_TEST_TRANSPARENT_DRIVER_ID;
|
||||
/* Declared with fallback == true */
|
||||
if( status != PSA_ERROR_NOT_SUPPORTED )
|
||||
return( status );
|
||||
#endif /* PSA_CRYPTO_DRIVER_TEST */
|
||||
#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_PAKE)
|
||||
status = mbedtls_psa_pake_setup( &operation->data.ctx.mbedtls_ctx,
|
||||
inputs );
|
||||
if( status == PSA_SUCCESS )
|
||||
operation->id = PSA_CRYPTO_MBED_TLS_DRIVER_ID;
|
||||
return status;
|
||||
#endif
|
||||
return( PSA_ERROR_NOT_SUPPORTED );
|
||||
/* Add cases for opaque driver here */
|
||||
default:
|
||||
/* Key is declared with a lifetime not known to us */
|
||||
(void)operation;
|
||||
(void)inputs;
|
||||
(void)status;
|
||||
return( PSA_ERROR_INVALID_ARGUMENT );
|
||||
}
|
||||
}
|
||||
psa_status_t psa_driver_wrapper_pake_output(
|
||||
psa_pake_operation_t *operation,
|
||||
psa_crypto_driver_pake_step_t step,
|
||||
uint8_t *output,
|
||||
size_t output_size,
|
||||
size_t *output_length )
|
||||
{
|
||||
switch( operation->id )
|
||||
{
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_PAKE)
|
||||
case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
|
||||
return( mbedtls_psa_pake_output( &operation->data.ctx.mbedtls_ctx, step,
|
||||
output, output_size, output_length ) );
|
||||
#endif /* MBEDTLS_PSA_BUILTIN_PAKE */
|
||||
|
||||
#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
|
||||
#if defined(PSA_CRYPTO_DRIVER_TEST)
|
||||
case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
|
||||
return( mbedtls_test_transparent_pake_output(
|
||||
&operation->data.ctx.transparent_test_driver_ctx,
|
||||
step, output, output_size, output_length ) );
|
||||
#endif /* PSA_CRYPTO_DRIVER_TEST */
|
||||
#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
|
||||
default:
|
||||
(void) step;
|
||||
(void) output;
|
||||
(void) output_size;
|
||||
(void) output_length;
|
||||
return( PSA_ERROR_INVALID_ARGUMENT );
|
||||
}
|
||||
}
|
||||
|
||||
psa_status_t psa_driver_wrapper_pake_input(
|
||||
psa_pake_operation_t *operation,
|
||||
psa_crypto_driver_pake_step_t step,
|
||||
const uint8_t *input,
|
||||
size_t input_length )
|
||||
{
|
||||
switch( operation->id )
|
||||
{
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_PAKE)
|
||||
case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
|
||||
return( mbedtls_psa_pake_input( &operation->data.ctx.mbedtls_ctx,
|
||||
step, input,
|
||||
input_length ) );
|
||||
#endif /* MBEDTLS_PSA_BUILTIN_PAKE */
|
||||
|
||||
#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
|
||||
#if defined(PSA_CRYPTO_DRIVER_TEST)
|
||||
case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
|
||||
return( mbedtls_test_transparent_pake_input(
|
||||
&operation->data.ctx.transparent_test_driver_ctx,
|
||||
step,
|
||||
input, input_length ) );
|
||||
#endif /* PSA_CRYPTO_DRIVER_TEST */
|
||||
#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
|
||||
default:
|
||||
(void) step;
|
||||
(void) input;
|
||||
(void) input_length;
|
||||
return( PSA_ERROR_INVALID_ARGUMENT );
|
||||
}
|
||||
}
|
||||
|
||||
psa_status_t psa_driver_wrapper_pake_get_implicit_key(
|
||||
psa_pake_operation_t *operation,
|
||||
uint8_t *output, size_t output_size,
|
||||
size_t *output_length )
|
||||
{
|
||||
switch( operation->id )
|
||||
{
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_PAKE)
|
||||
case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
|
||||
return( mbedtls_psa_pake_get_implicit_key( &operation->data.ctx.mbedtls_ctx,
|
||||
output, output_size, output_length ) );
|
||||
#endif /* MBEDTLS_PSA_BUILTIN_PAKE */
|
||||
|
||||
#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
|
||||
#if defined(PSA_CRYPTO_DRIVER_TEST)
|
||||
case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
|
||||
return( mbedtls_test_transparent_pake_get_implicit_key(
|
||||
&operation->data.ctx.transparent_test_driver_ctx,
|
||||
output, output_size, output_length ) );
|
||||
#endif /* PSA_CRYPTO_DRIVER_TEST */
|
||||
#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
|
||||
default:
|
||||
(void) output;
|
||||
(void) output_size;
|
||||
(void) output_length;
|
||||
return( PSA_ERROR_INVALID_ARGUMENT );
|
||||
}
|
||||
}
|
||||
|
||||
psa_status_t psa_driver_wrapper_pake_abort(
|
||||
psa_pake_operation_t * operation )
|
||||
{
|
||||
switch( operation->id )
|
||||
{
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_PAKE)
|
||||
case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
|
||||
return( mbedtls_psa_pake_abort( &operation->data.ctx.mbedtls_ctx ) );
|
||||
#endif /* MBEDTLS_PSA_BUILTIN_PAKE */
|
||||
|
||||
#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
|
||||
#if defined(PSA_CRYPTO_DRIVER_TEST)
|
||||
case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
|
||||
return( mbedtls_test_transparent_pake_abort(
|
||||
&operation->data.ctx.transparent_test_driver_ctx ) );
|
||||
#endif /* PSA_CRYPTO_DRIVER_TEST */
|
||||
#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
|
||||
default:
|
||||
return( PSA_ERROR_INVALID_ARGUMENT );
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* MBEDTLS_PSA_CRYPTO_C */
|
||||
|
||||
@ -17,6 +17,7 @@
|
||||
from abc import abstractmethod
|
||||
import enum
|
||||
from typing import Iterator, List, Tuple, TypeVar, Any
|
||||
from copy import deepcopy
|
||||
from itertools import chain
|
||||
|
||||
from . import test_case
|
||||
@ -68,12 +69,17 @@ def bound_mpi_limbs(limbs: int, bits_in_limb: int) -> int:
|
||||
|
||||
def limbs_mpi(val: int, bits_in_limb: int) -> int:
|
||||
"""Return the number of limbs required to store value."""
|
||||
return (val.bit_length() + bits_in_limb - 1) // bits_in_limb
|
||||
bit_length = max(val.bit_length(), 1)
|
||||
return (bit_length + bits_in_limb - 1) // bits_in_limb
|
||||
|
||||
def combination_pairs(values: List[T]) -> List[Tuple[T, T]]:
|
||||
"""Return all pair combinations from input values."""
|
||||
return [(x, y) for x in values for y in values]
|
||||
|
||||
def hex_digits_for_limb(limbs: int, bits_in_limb: int) -> int:
|
||||
""" Retrun the hex digits need for a number of limbs. """
|
||||
return 2 * (limbs * bits_in_limb // 8)
|
||||
|
||||
class OperationCommon(test_data_generation.BaseTest):
|
||||
"""Common features for bignum binary operations.
|
||||
|
||||
@ -99,6 +105,7 @@ class OperationCommon(test_data_generation.BaseTest):
|
||||
symbol = ""
|
||||
input_values = INPUTS_DEFAULT # type: List[str]
|
||||
input_cases = [] # type: List[Any]
|
||||
dependencies = [] # type: List[Any]
|
||||
unique_combinations_only = False
|
||||
input_styles = ["variable", "fixed", "arch_split"] # type: List[str]
|
||||
input_style = "variable" # type: str
|
||||
@ -114,10 +121,11 @@ class OperationCommon(test_data_generation.BaseTest):
|
||||
# provides earlier/more robust input validation.
|
||||
self.int_a = hex_to_int(val_a)
|
||||
self.int_b = hex_to_int(val_b)
|
||||
self.dependencies = deepcopy(self.dependencies)
|
||||
if bits_in_limb not in self.limb_sizes:
|
||||
raise ValueError("Invalid number of bits in limb!")
|
||||
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
|
||||
|
||||
@property
|
||||
@ -138,7 +146,7 @@ class OperationCommon(test_data_generation.BaseTest):
|
||||
|
||||
@property
|
||||
def hex_digits(self) -> int:
|
||||
return 2 * (self.limbs * self.bits_in_limb // 8)
|
||||
return hex_digits_for_limb(self.limbs, self.bits_in_limb)
|
||||
|
||||
def format_arg(self, val: str) -> str:
|
||||
if self.input_style not in self.input_styles:
|
||||
@ -384,43 +392,3 @@ class ModOperationCommon(OperationCommon):
|
||||
lambda test_object: test_object.is_valid,
|
||||
chain(test_objects, special_cases)
|
||||
))
|
||||
|
||||
# BEGIN MERGE SLOT 1
|
||||
|
||||
# END MERGE SLOT 1
|
||||
|
||||
# BEGIN MERGE SLOT 2
|
||||
|
||||
# END MERGE SLOT 2
|
||||
|
||||
# BEGIN MERGE SLOT 3
|
||||
|
||||
# END MERGE SLOT 3
|
||||
|
||||
# BEGIN MERGE SLOT 4
|
||||
|
||||
# END MERGE SLOT 4
|
||||
|
||||
# BEGIN MERGE SLOT 5
|
||||
|
||||
# END MERGE SLOT 5
|
||||
|
||||
# BEGIN MERGE SLOT 6
|
||||
|
||||
# END MERGE SLOT 6
|
||||
|
||||
# BEGIN MERGE SLOT 7
|
||||
|
||||
# END MERGE SLOT 7
|
||||
|
||||
# BEGIN MERGE SLOT 8
|
||||
|
||||
# END MERGE SLOT 8
|
||||
|
||||
# BEGIN MERGE SLOT 9
|
||||
|
||||
# END MERGE SLOT 9
|
||||
|
||||
# BEGIN MERGE SLOT 10
|
||||
|
||||
# END MERGE SLOT 10
|
||||
|
||||
@ -230,6 +230,31 @@ class BignumCoreMLA(BignumCoreTarget, bignum_common.OperationCommon):
|
||||
yield cur_op.create_test_case()
|
||||
|
||||
|
||||
class BignumCoreMul(BignumCoreTarget, bignum_common.OperationCommon):
|
||||
"""Test cases for bignum core multiplication."""
|
||||
count = 0
|
||||
input_style = "arch_split"
|
||||
symbol = "*"
|
||||
test_function = "mpi_core_mul"
|
||||
test_name = "mbedtls_mpi_core_mul"
|
||||
arity = 2
|
||||
unique_combinations_only = True
|
||||
|
||||
def format_arg(self, val: str) -> str:
|
||||
return val
|
||||
|
||||
def format_result(self, res: int) -> str:
|
||||
res_str = '{:x}'.format(res)
|
||||
a_limbs = bignum_common.limbs_mpi(self.int_a, self.bits_in_limb)
|
||||
b_limbs = bignum_common.limbs_mpi(self.int_b, self.bits_in_limb)
|
||||
hex_digits = bignum_common.hex_digits_for_limb(a_limbs + b_limbs, self.bits_in_limb)
|
||||
return bignum_common.quote_str(self.format_arg(res_str).zfill(hex_digits))
|
||||
|
||||
def result(self) -> List[str]:
|
||||
result = self.int_a * self.int_b
|
||||
return [self.format_result(result)]
|
||||
|
||||
|
||||
class BignumCoreMontmul(BignumCoreTarget, test_data_generation.BaseTest):
|
||||
"""Test cases for Montgomery multiplication."""
|
||||
count = 0
|
||||
@ -749,7 +774,6 @@ def mpi_modmul_case_generate() -> None:
|
||||
i += 1
|
||||
print(generated_inputs)
|
||||
|
||||
# BEGIN MERGE SLOT 1
|
||||
|
||||
class BignumCoreExpMod(BignumCoreTarget, bignum_common.ModOperationCommon):
|
||||
"""Test cases for bignum core exponentiation."""
|
||||
@ -771,13 +795,6 @@ class BignumCoreExpMod(BignumCoreTarget, bignum_common.ModOperationCommon):
|
||||
# the modulus (see for example exponent blinding)
|
||||
return bool(self.int_a < self.int_n)
|
||||
|
||||
# END MERGE SLOT 1
|
||||
|
||||
# BEGIN MERGE SLOT 2
|
||||
|
||||
# END MERGE SLOT 2
|
||||
|
||||
# BEGIN MERGE SLOT 3
|
||||
|
||||
class BignumCoreSubInt(BignumCoreTarget, bignum_common.OperationCommon):
|
||||
"""Test cases for bignum core sub int."""
|
||||
@ -823,33 +840,3 @@ class BignumCoreZeroCheckCT(BignumCoreTarget, bignum_common.OperationCommon):
|
||||
def result(self) -> List[str]:
|
||||
result = 1 if self.int_a == 0 else 0
|
||||
return [str(result)]
|
||||
|
||||
# END MERGE SLOT 3
|
||||
|
||||
# BEGIN MERGE SLOT 4
|
||||
|
||||
# END MERGE SLOT 4
|
||||
|
||||
# BEGIN MERGE SLOT 5
|
||||
|
||||
# END MERGE SLOT 5
|
||||
|
||||
# BEGIN MERGE SLOT 6
|
||||
|
||||
# END MERGE SLOT 6
|
||||
|
||||
# BEGIN MERGE SLOT 7
|
||||
|
||||
# END MERGE SLOT 7
|
||||
|
||||
# BEGIN MERGE SLOT 8
|
||||
|
||||
# END MERGE SLOT 8
|
||||
|
||||
# BEGIN MERGE SLOT 9
|
||||
|
||||
# END MERGE SLOT 9
|
||||
|
||||
# BEGIN MERGE SLOT 10
|
||||
|
||||
# END MERGE SLOT 10
|
||||
|
||||
@ -25,11 +25,6 @@ class BignumModTarget(test_data_generation.BaseTarget):
|
||||
"""Target for bignum mod test case generation."""
|
||||
target_basename = 'test_suite_bignum_mod.generated'
|
||||
|
||||
# BEGIN MERGE SLOT 1
|
||||
|
||||
# END MERGE SLOT 1
|
||||
|
||||
# BEGIN MERGE SLOT 2
|
||||
|
||||
class BignumModMul(bignum_common.ModOperationCommon,
|
||||
BignumModTarget):
|
||||
@ -51,9 +46,6 @@ class BignumModMul(bignum_common.ModOperationCommon,
|
||||
result = (self.int_a * self.int_b) % self.int_n
|
||||
return [self.format_result(self.to_montgomery(result))]
|
||||
|
||||
# END MERGE SLOT 2
|
||||
|
||||
# BEGIN MERGE SLOT 3
|
||||
|
||||
class BignumModSub(bignum_common.ModOperationCommon, BignumModTarget):
|
||||
"""Test cases for bignum mpi_mod_sub()."""
|
||||
@ -105,13 +97,7 @@ class BignumModInvMont(bignum_common.ModOperationCommon, BignumModTarget):
|
||||
# generated cases
|
||||
return [self.format_result(mont_result), "0"]
|
||||
|
||||
# END MERGE SLOT 3
|
||||
|
||||
# BEGIN MERGE SLOT 4
|
||||
|
||||
# END MERGE SLOT 4
|
||||
|
||||
# BEGIN MERGE SLOT 5
|
||||
class BignumModAdd(bignum_common.ModOperationCommon, BignumModTarget):
|
||||
"""Test cases for bignum mpi_mod_add()."""
|
||||
count = 0
|
||||
@ -125,26 +111,3 @@ class BignumModAdd(bignum_common.ModOperationCommon, BignumModTarget):
|
||||
# To make negative tests easier, append "0" for success to the
|
||||
# generated cases
|
||||
return [self.format_result(result), "0"]
|
||||
|
||||
|
||||
# END MERGE SLOT 5
|
||||
|
||||
# BEGIN MERGE SLOT 6
|
||||
|
||||
# END MERGE SLOT 6
|
||||
|
||||
# BEGIN MERGE SLOT 7
|
||||
|
||||
# END MERGE SLOT 7
|
||||
|
||||
# BEGIN MERGE SLOT 8
|
||||
|
||||
# END MERGE SLOT 8
|
||||
|
||||
# BEGIN MERGE SLOT 9
|
||||
|
||||
# END MERGE SLOT 9
|
||||
|
||||
# BEGIN MERGE SLOT 10
|
||||
|
||||
# END MERGE SLOT 10
|
||||
|
||||
@ -26,11 +26,6 @@ class BignumModRawTarget(test_data_generation.BaseTarget):
|
||||
"""Target for bignum mod_raw test case generation."""
|
||||
target_basename = 'test_suite_bignum_mod_raw.generated'
|
||||
|
||||
# BEGIN MERGE SLOT 1
|
||||
|
||||
# END MERGE SLOT 1
|
||||
|
||||
# BEGIN MERGE SLOT 2
|
||||
|
||||
class BignumModRawSub(bignum_common.ModOperationCommon,
|
||||
BignumModRawTarget):
|
||||
@ -101,9 +96,6 @@ class BignumModRawMul(bignum_common.ModOperationCommon,
|
||||
result = (self.int_a * self.int_b) % self.int_n
|
||||
return [self.format_result(self.to_montgomery(result))]
|
||||
|
||||
# END MERGE SLOT 2
|
||||
|
||||
# BEGIN MERGE SLOT 3
|
||||
|
||||
class BignumModRawInvPrime(bignum_common.ModOperationCommon,
|
||||
BignumModRawTarget):
|
||||
@ -123,13 +115,6 @@ class BignumModRawInvPrime(bignum_common.ModOperationCommon,
|
||||
mont_result = self.to_montgomery(result)
|
||||
return [self.format_result(mont_result)]
|
||||
|
||||
# END MERGE SLOT 3
|
||||
|
||||
# BEGIN MERGE SLOT 4
|
||||
|
||||
# END MERGE SLOT 4
|
||||
|
||||
# BEGIN MERGE SLOT 5
|
||||
|
||||
class BignumModRawAdd(bignum_common.ModOperationCommon,
|
||||
BignumModRawTarget):
|
||||
@ -144,9 +129,6 @@ class BignumModRawAdd(bignum_common.ModOperationCommon,
|
||||
result = (self.int_a + self.int_b) % self.int_n
|
||||
return [self.format_result(result)]
|
||||
|
||||
# END MERGE SLOT 5
|
||||
|
||||
# BEGIN MERGE SLOT 6
|
||||
|
||||
class BignumModRawConvertRep(bignum_common.ModOperationCommon,
|
||||
BignumModRawTarget):
|
||||
@ -230,9 +212,6 @@ class BignumModRawModulusToCanonicalRep(BignumModRawConvertRep):
|
||||
def result(self) -> List[str]:
|
||||
return [self.format_result(self.int_a)]
|
||||
|
||||
# END MERGE SLOT 6
|
||||
|
||||
# BEGIN MERGE SLOT 7
|
||||
|
||||
class BignumModRawConvertToMont(bignum_common.ModOperationCommon,
|
||||
BignumModRawTarget):
|
||||
@ -272,16 +251,3 @@ class BignumModRawModNegate(bignum_common.ModOperationCommon,
|
||||
def result(self) -> List[str]:
|
||||
result = (self.int_n - self.int_a) % self.int_n
|
||||
return [self.format_result(result)]
|
||||
# END MERGE SLOT 7
|
||||
|
||||
# BEGIN MERGE SLOT 8
|
||||
|
||||
# END MERGE SLOT 8
|
||||
|
||||
# BEGIN MERGE SLOT 9
|
||||
|
||||
# END MERGE SLOT 9
|
||||
|
||||
# BEGIN MERGE SLOT 10
|
||||
|
||||
# END MERGE SLOT 10
|
||||
|
||||
@ -19,19 +19,22 @@ from typing import List
|
||||
from . import test_data_generation
|
||||
from . import bignum_common
|
||||
|
||||
|
||||
class EcpTarget(test_data_generation.BaseTarget):
|
||||
#pylint: disable=abstract-method, too-few-public-methods
|
||||
"""Target for ecp test case generation."""
|
||||
target_basename = 'test_suite_ecp.generated'
|
||||
|
||||
|
||||
class EcpP192R1Raw(bignum_common.ModOperationCommon,
|
||||
EcpTarget):
|
||||
"""Test cases for ecp quasi_reduction()."""
|
||||
"""Test cases for ECP P192 fast reduction."""
|
||||
symbol = "-"
|
||||
test_function = "ecp_mod_p192_raw"
|
||||
test_function = "ecp_mod_p_generic_raw"
|
||||
test_name = "ecp_mod_p192_raw"
|
||||
input_style = "fixed"
|
||||
arity = 1
|
||||
dependencies = ["MBEDTLS_ECP_DP_SECP192R1_ENABLED"]
|
||||
|
||||
moduli = ["fffffffffffffffffffffffffffffffeffffffffffffffff"] # type: List[str]
|
||||
|
||||
@ -41,6 +44,24 @@ class EcpP192R1Raw(bignum_common.ModOperationCommon,
|
||||
# Modulus - 1
|
||||
"fffffffffffffffffffffffffffffffefffffffffffffffe",
|
||||
|
||||
# Modulus + 1
|
||||
"ffffffffffffffffffffffffffffffff0000000000000000",
|
||||
|
||||
# 2^192 - 1
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffff",
|
||||
|
||||
# Maximum canonical P192 multiplication result
|
||||
("fffffffffffffffffffffffffffffffdfffffffffffffffc"
|
||||
"000000000000000100000000000000040000000000000004"),
|
||||
|
||||
# Generate an overflow during reduction
|
||||
("00000000000000000000000000000001ffffffffffffffff"
|
||||
"ffffffffffffffffffffffffffffffff0000000000000000"),
|
||||
|
||||
# Generate an overflow during carry reduction
|
||||
("ffffffffffffffff00000000000000010000000000000000"
|
||||
"fffffffffffffffeffffffffffffffff0000000000000000"),
|
||||
|
||||
# First 8 number generated by random.getrandbits(384) - seed(2,2)
|
||||
("cf1822ffbc6887782b491044d5e341245c6e433715ba2bdd"
|
||||
"177219d30e7a269fd95bafc8f2a4d27bdcf4bb99f4bea973"),
|
||||
@ -76,13 +97,302 @@ class EcpP192R1Raw(bignum_common.ModOperationCommon,
|
||||
def is_valid(self) -> bool:
|
||||
return True
|
||||
|
||||
def arguments(self):
|
||||
args = super().arguments()
|
||||
return ["MBEDTLS_ECP_DP_SECP192R1"] + args
|
||||
|
||||
|
||||
class EcpP224R1Raw(bignum_common.ModOperationCommon,
|
||||
EcpTarget):
|
||||
"""Test cases for ECP P224 fast reduction."""
|
||||
symbol = "-"
|
||||
test_function = "ecp_mod_p_generic_raw"
|
||||
test_name = "ecp_mod_p224_raw"
|
||||
input_style = "arch_split"
|
||||
arity = 1
|
||||
dependencies = ["MBEDTLS_ECP_DP_SECP224R1_ENABLED"]
|
||||
|
||||
moduli = ["ffffffffffffffffffffffffffffffff000000000000000000000001"] # type: List[str]
|
||||
|
||||
input_values = [
|
||||
"0", "1",
|
||||
|
||||
# Modulus - 1
|
||||
"ffffffffffffffffffffffffffffffff000000000000000000000000",
|
||||
|
||||
# Modulus + 1
|
||||
"ffffffffffffffffffffffffffffffff000000000000000000000002",
|
||||
|
||||
# 2^224 - 1
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
|
||||
|
||||
# Maximum canonical P224 multiplication result
|
||||
("fffffffffffffffffffffffffffffffe000000000000000000000000"
|
||||
"00000001000000000000000000000000000000000000000000000000"),
|
||||
|
||||
# Generate an overflow during reduction
|
||||
("00000000000000000000000000010000000070000000002000001000"
|
||||
"ffffffffffff9fffffffffe00000efff000070000000002000001003"),
|
||||
|
||||
# Generate an underflow during reduction
|
||||
("00000001000000000000000000000000000000000000000000000000"
|
||||
"00000000000dc0000000000000000001000000010000000100000003"),
|
||||
|
||||
# First 8 number generated by random.getrandbits(448) - seed(2,2)
|
||||
("da94e3e8ab73738fcf1822ffbc6887782b491044d5e341245c6e4337"
|
||||
"15ba2bdd177219d30e7a269fd95bafc8f2a4d27bdcf4bb99f4bea973"),
|
||||
("cdbd47d364be8049a372db8f6e405d93ffed9235288bc781ae662675"
|
||||
"94c9c9500925e4749b575bd13653f8dd9b1f282e4067c3584ee207f8"),
|
||||
("defc044a09325626e6b58de744ab6cce80877b6f71e1f6d2ef8acd12"
|
||||
"8b4f2fc15f3f57ebf30b94fa82523e86feac7eb7dc38f519b91751da"),
|
||||
("2d6c797f8f7d9b782a1be9cd8697bbd0e2520e33e44c50556c71c4a6"
|
||||
"6148a86fe8624fab5186ee32ee8d7ee9770348a05d300cb90706a045"),
|
||||
("8f54f8ceacaab39e83844b40ffa9b9f15c14bc4a829e07b0829a48d4"
|
||||
"22fe99a22c70501e533c91352d3d854e061b90303b08c6e33c729578"),
|
||||
("97eeab64ca2ce6bc5d3fd983c34c769fe89204e2e8168561867e5e15"
|
||||
"bc01bfce6a27e0dfcbf8754472154e76e4c11ab2fec3f6b32e8d4b8a"),
|
||||
("a7a83ee0761ebfd2bd143fa9b714210c665d7435c1066932f4767f26"
|
||||
"294365b2721dea3bf63f23d0dbe53fcafb2147df5ca495fa5a91c89b"),
|
||||
("74667bffe202849da9643a295a9ac6decbd4d3e2d4dec9ef83f0be4e"
|
||||
"80371eb97f81375eecc1cb6347733e847d718d733ff98ff387c56473"),
|
||||
|
||||
# Next 2 number generated by random.getrandbits(224)
|
||||
"eb9ac688b9d39cca91551e8259cc60b17604e4b4e73695c3e652c71a",
|
||||
"f0caeef038c89b38a8acb5137c9260dc74e088a9b9492f258ebdbfe3"
|
||||
]
|
||||
|
||||
@property
|
||||
def arg_a(self) -> str:
|
||||
hex_digits = bignum_common.hex_digits_for_limb(448 // self.bits_in_limb, self.bits_in_limb)
|
||||
return super().format_arg('{:x}'.format(self.int_a)).zfill(hex_digits)
|
||||
|
||||
def result(self) -> List[str]:
|
||||
result = self.int_a % self.int_n
|
||||
return [self.format_result(result)]
|
||||
|
||||
@property
|
||||
def is_valid(self) -> bool:
|
||||
return True
|
||||
|
||||
def arguments(self):
|
||||
args = super().arguments()
|
||||
return ["MBEDTLS_ECP_DP_SECP224R1"] + args
|
||||
|
||||
|
||||
class EcpP256R1Raw(bignum_common.ModOperationCommon,
|
||||
EcpTarget):
|
||||
"""Test cases for ECP P256 fast reduction."""
|
||||
symbol = "-"
|
||||
test_function = "ecp_mod_p_generic_raw"
|
||||
test_name = "ecp_mod_p256_raw"
|
||||
input_style = "fixed"
|
||||
arity = 1
|
||||
dependencies = ["MBEDTLS_ECP_DP_SECP256R1_ENABLED"]
|
||||
|
||||
moduli = ["ffffffff00000001000000000000000000000000ffffffffffffffffffffffff"] # type: List[str]
|
||||
|
||||
input_values = [
|
||||
"0", "1",
|
||||
|
||||
# Modulus - 1
|
||||
"ffffffff00000001000000000000000000000000fffffffffffffffffffffffe",
|
||||
|
||||
# Modulus + 1
|
||||
"ffffffff00000001000000000000000000000001000000000000000000000000",
|
||||
|
||||
# 2^256 - 1
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
|
||||
|
||||
# Maximum canonical P256 multiplication result
|
||||
("fffffffe00000002fffffffe0000000100000001fffffffe00000001fffffffc"
|
||||
"00000003fffffffcfffffffffffffffffffffffc000000000000000000000004"),
|
||||
|
||||
# Generate an overflow during reduction
|
||||
("0000000000000000000000010000000000000000000000000000000000000000"
|
||||
"00000000000000000000000000000000000000000000000000000000ffffffff"),
|
||||
|
||||
# Generate an underflow during reduction
|
||||
("0000000000000000000000000000000000000000000000000000000000000010"
|
||||
"ffffffff00000000000000000000000000000000000000000000000000000000"),
|
||||
|
||||
# Generate an overflow during carry reduction
|
||||
("aaaaaaaa00000000000000000000000000000000000000000000000000000000"
|
||||
"00000000000000000000000000000000aaaaaaacaaaaaaaaaaaaaaaa00000000"),
|
||||
|
||||
# Generate an underflow during carry reduction
|
||||
("000000000000000000000001ffffffff00000000000000000000000000000000"
|
||||
"0000000000000000000000000000000000000002000000020000000100000002"),
|
||||
|
||||
# First 8 number generated by random.getrandbits(512) - seed(2,2)
|
||||
("4067c3584ee207f8da94e3e8ab73738fcf1822ffbc6887782b491044d5e34124"
|
||||
"5c6e433715ba2bdd177219d30e7a269fd95bafc8f2a4d27bdcf4bb99f4bea973"),
|
||||
("82523e86feac7eb7dc38f519b91751dacdbd47d364be8049a372db8f6e405d93"
|
||||
"ffed9235288bc781ae66267594c9c9500925e4749b575bd13653f8dd9b1f282e"),
|
||||
("e8624fab5186ee32ee8d7ee9770348a05d300cb90706a045defc044a09325626"
|
||||
"e6b58de744ab6cce80877b6f71e1f6d2ef8acd128b4f2fc15f3f57ebf30b94fa"),
|
||||
("829a48d422fe99a22c70501e533c91352d3d854e061b90303b08c6e33c729578"
|
||||
"2d6c797f8f7d9b782a1be9cd8697bbd0e2520e33e44c50556c71c4a66148a86f"),
|
||||
("e89204e2e8168561867e5e15bc01bfce6a27e0dfcbf8754472154e76e4c11ab2"
|
||||
"fec3f6b32e8d4b8a8f54f8ceacaab39e83844b40ffa9b9f15c14bc4a829e07b0"),
|
||||
("bd143fa9b714210c665d7435c1066932f4767f26294365b2721dea3bf63f23d0"
|
||||
"dbe53fcafb2147df5ca495fa5a91c89b97eeab64ca2ce6bc5d3fd983c34c769f"),
|
||||
("74667bffe202849da9643a295a9ac6decbd4d3e2d4dec9ef83f0be4e80371eb9"
|
||||
"7f81375eecc1cb6347733e847d718d733ff98ff387c56473a7a83ee0761ebfd2"),
|
||||
("d08f1bb2531d6460f0caeef038c89b38a8acb5137c9260dc74e088a9b9492f25"
|
||||
"8ebdbfe3eb9ac688b9d39cca91551e8259cc60b17604e4b4e73695c3e652c71a"),
|
||||
|
||||
# Next 2 number generated by random.getrandbits(256)
|
||||
"c5e2486c44a4a8f69dc8db48e86ec9c6e06f291b2a838af8d5c44a4eb3172062",
|
||||
"d4c0dca8b4c9e755cc9c3adcf515a8234da4daeb4f3f87777ad1f45ae9500ec9"
|
||||
]
|
||||
|
||||
@property
|
||||
def arg_a(self) -> str:
|
||||
return super().format_arg('{:x}'.format(self.int_a)).zfill(2 * self.hex_digits)
|
||||
|
||||
def result(self) -> List[str]:
|
||||
result = self.int_a % self.int_n
|
||||
return [self.format_result(result)]
|
||||
|
||||
@property
|
||||
def is_valid(self) -> bool:
|
||||
return True
|
||||
|
||||
def arguments(self):
|
||||
args = super().arguments()
|
||||
return ["MBEDTLS_ECP_DP_SECP256R1"] + args
|
||||
|
||||
|
||||
class EcpP384R1Raw(bignum_common.ModOperationCommon,
|
||||
EcpTarget):
|
||||
"""Test cases for ECP P384 fast reduction."""
|
||||
test_function = "ecp_mod_p_generic_raw"
|
||||
test_name = "ecp_mod_p384_raw"
|
||||
input_style = "fixed"
|
||||
arity = 1
|
||||
dependencies = ["MBEDTLS_ECP_DP_SECP384R1_ENABLED"]
|
||||
|
||||
moduli = [("ffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
"fffffffffffffffeffffffff0000000000000000ffffffff")
|
||||
] # type: List[str]
|
||||
|
||||
input_values = [
|
||||
"0", "1",
|
||||
|
||||
# Modulus - 1
|
||||
("ffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
"fffffffffffffffeffffffff0000000000000000fffffffe"),
|
||||
|
||||
# Modulus + 1
|
||||
("ffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
"fffffffffffffffeffffffff000000000000000100000000"),
|
||||
|
||||
# 2^384 - 1
|
||||
("ffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
|
||||
# Maximum canonical P384 multiplication result
|
||||
("ffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
"fffffffffffffffdfffffffe0000000000000001fffffffc"
|
||||
"000000000000000000000000000000010000000200000000"
|
||||
"fffffffe000000020000000400000000fffffffc00000004"),
|
||||
|
||||
# Testing with overflow in A(12) + A(21) + A(20);
|
||||
("497811378624857a2c2af60d70583376545484cfae5c812f"
|
||||
"e2999fc1abb51d18b559e8ca3b50aaf263fdf8f24bdfb98f"
|
||||
"ffffffff20e65bf9099e4e73a5e8b517cf4fbeb8fd1750fd"
|
||||
"ae6d43f2e53f82d5ffffffffffffffffcc6f1e06111c62e0"),
|
||||
|
||||
# Testing with underflow in A(13) + A(22) + A(23) - A(12) - A(20);
|
||||
("dfdd25e96777406b3c04b8c7b406f5fcf287e1e576003a09"
|
||||
"2852a6fbe517f2712b68abef41dbd35183a0614fb7222606"
|
||||
"ffffffff84396eee542f18a9189d94396c784059c17a9f18"
|
||||
"f807214ef32f2f10ffffffff8a77fac20000000000000000"),
|
||||
|
||||
# Testing with overflow in A(23) + A(20) + A(19) - A(22);
|
||||
("783753f8a5afba6c1862eead1deb2fcdd907272be3ffd185"
|
||||
"42b24a71ee8b26cab0aa33513610ff973042bbe1637cc9fc"
|
||||
"99ad36c7f703514572cf4f5c3044469a8f5be6312c19e5d3"
|
||||
"f8fc1ac6ffffffffffffffff8c86252400000000ffffffff"),
|
||||
|
||||
# Testing with underflow in A(23) + A(20) + A(19) - A(22);
|
||||
("65e1d2362fce922663b7fd517586e88842a9b4bd092e93e6"
|
||||
"251c9c69f278cbf8285d99ae3b53da5ba36e56701e2b17c2"
|
||||
"25f1239556c5f00117fa140218b46ebd8e34f50d0018701f"
|
||||
"a8a0a5cc00000000000000004410bcb4ffffffff00000000"),
|
||||
|
||||
# Testing the second round of carry reduction
|
||||
("000000000000000000000000ffffffffffffffffffffffff"
|
||||
"ffffffffffffffffffffffffffffffff0000000000000000"
|
||||
"0000000000000000ffffffff000000000000000000000001"
|
||||
"00000000000000000000000000000000ffffffff00000001"),
|
||||
|
||||
# First 8 number generated by random.getrandbits(768) - seed(2,2)
|
||||
("ffed9235288bc781ae66267594c9c9500925e4749b575bd1"
|
||||
"3653f8dd9b1f282e4067c3584ee207f8da94e3e8ab73738f"
|
||||
"cf1822ffbc6887782b491044d5e341245c6e433715ba2bdd"
|
||||
"177219d30e7a269fd95bafc8f2a4d27bdcf4bb99f4bea973"),
|
||||
("e8624fab5186ee32ee8d7ee9770348a05d300cb90706a045"
|
||||
"defc044a09325626e6b58de744ab6cce80877b6f71e1f6d2"
|
||||
"ef8acd128b4f2fc15f3f57ebf30b94fa82523e86feac7eb7"
|
||||
"dc38f519b91751dacdbd47d364be8049a372db8f6e405d93"),
|
||||
("fec3f6b32e8d4b8a8f54f8ceacaab39e83844b40ffa9b9f1"
|
||||
"5c14bc4a829e07b0829a48d422fe99a22c70501e533c9135"
|
||||
"2d3d854e061b90303b08c6e33c7295782d6c797f8f7d9b78"
|
||||
"2a1be9cd8697bbd0e2520e33e44c50556c71c4a66148a86f"),
|
||||
("bd143fa9b714210c665d7435c1066932f4767f26294365b2"
|
||||
"721dea3bf63f23d0dbe53fcafb2147df5ca495fa5a91c89b"
|
||||
"97eeab64ca2ce6bc5d3fd983c34c769fe89204e2e8168561"
|
||||
"867e5e15bc01bfce6a27e0dfcbf8754472154e76e4c11ab2"),
|
||||
("8ebdbfe3eb9ac688b9d39cca91551e8259cc60b17604e4b4"
|
||||
"e73695c3e652c71a74667bffe202849da9643a295a9ac6de"
|
||||
"cbd4d3e2d4dec9ef83f0be4e80371eb97f81375eecc1cb63"
|
||||
"47733e847d718d733ff98ff387c56473a7a83ee0761ebfd2"),
|
||||
("d4c0dca8b4c9e755cc9c3adcf515a8234da4daeb4f3f8777"
|
||||
"7ad1f45ae9500ec9c5e2486c44a4a8f69dc8db48e86ec9c6"
|
||||
"e06f291b2a838af8d5c44a4eb3172062d08f1bb2531d6460"
|
||||
"f0caeef038c89b38a8acb5137c9260dc74e088a9b9492f25"),
|
||||
("0227eeb7b9d7d01f5769da05d205bbfcc8c69069134bccd3"
|
||||
"e1cf4f589f8e4ce0af29d115ef24bd625dd961e6830b54fa"
|
||||
"7d28f93435339774bb1e386c4fd5079e681b8f5896838b76"
|
||||
"9da59b74a6c3181c81e220df848b1df78feb994a81167346"),
|
||||
("d322a7353ead4efe440e2b4fda9c025a22f1a83185b98f5f"
|
||||
"c11e60de1b343f52ea748db9e020307aaeb6db2c3a038a70"
|
||||
"9779ac1f45e9dd320c855fdfa7251af0930cdbd30f0ad2a8"
|
||||
"1b2d19a2beaa14a7ff3fe32a30ffc4eed0a7bd04e85bfcdd"),
|
||||
|
||||
# Next 2 number generated by random.getrandbits(384)
|
||||
("5c3747465cc36c270e8a35b10828d569c268a20eb78ac332"
|
||||
"e5e138e26c4454b90f756132e16dce72f18e859835e1f291"),
|
||||
("eb2b5693babb7fbb0a76c196067cfdcb11457d9cf45e2fa0"
|
||||
"1d7f4275153924800600571fac3a5b263fdf57cd2c006497")
|
||||
]
|
||||
|
||||
@property
|
||||
def arg_a(self) -> str:
|
||||
return super().format_arg('{:x}'.format(self.int_a)).zfill(2 * self.hex_digits)
|
||||
|
||||
def result(self) -> List[str]:
|
||||
result = self.int_a % self.int_n
|
||||
return [self.format_result(result)]
|
||||
|
||||
@property
|
||||
def is_valid(self) -> bool:
|
||||
return True
|
||||
|
||||
def arguments(self):
|
||||
args = super().arguments()
|
||||
return ["MBEDTLS_ECP_DP_SECP384R1"] + args
|
||||
|
||||
|
||||
class EcpP521R1Raw(bignum_common.ModOperationCommon,
|
||||
EcpTarget):
|
||||
"""Test cases for ecp quasi_reduction()."""
|
||||
test_function = "ecp_mod_p521_raw"
|
||||
"""Test cases for ECP P521 fast reduction."""
|
||||
test_function = "ecp_mod_p_generic_raw"
|
||||
test_name = "ecp_mod_p521_raw"
|
||||
input_style = "arch_split"
|
||||
arity = 1
|
||||
dependencies = ["MBEDTLS_ECP_DP_SECP521R1_ENABLED"]
|
||||
|
||||
moduli = [("01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
|
||||
@ -91,7 +401,15 @@ class EcpP521R1Raw(bignum_common.ModOperationCommon,
|
||||
input_values = [
|
||||
"0", "1",
|
||||
|
||||
# Corner case: maximum canonical P521 multiplication result
|
||||
# Modulus - 1
|
||||
("01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"),
|
||||
|
||||
# Modulus + 1
|
||||
("020000000000000000000000000000000000000000000000000000000000000000"
|
||||
"000000000000000000000000000000000000000000000000000000000000000000"),
|
||||
|
||||
# Maximum canonical P521 multiplication result
|
||||
("0003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
"fffff800"
|
||||
@ -166,3 +484,290 @@ class EcpP521R1Raw(bignum_common.ModOperationCommon,
|
||||
@property
|
||||
def is_valid(self) -> bool:
|
||||
return True
|
||||
|
||||
def arguments(self):
|
||||
args = super().arguments()
|
||||
return ["MBEDTLS_ECP_DP_SECP521R1"] + args
|
||||
|
||||
|
||||
class EcpP192K1Raw(bignum_common.ModOperationCommon,
|
||||
EcpTarget):
|
||||
"""Test cases for ECP P192K1 fast reduction."""
|
||||
symbol = "-"
|
||||
test_function = "ecp_mod_p192k1"
|
||||
test_name = "ecp_mod_p192k1"
|
||||
input_style = "fixed"
|
||||
arity = 1
|
||||
dependencies = ["MBEDTLS_ECP_DP_SECP192K1_ENABLED"]
|
||||
|
||||
moduli = ["fffffffffffffffffffffffffffffffffffffffeffffee37"] # type: List[str]
|
||||
|
||||
input_values = [
|
||||
"0", "1",
|
||||
|
||||
# Modulus - 1
|
||||
"fffffffffffffffffffffffffffffffffffffffeffffee36",
|
||||
|
||||
# Modulus + 1
|
||||
"fffffffffffffffffffffffffffffffffffffffeffffee38",
|
||||
|
||||
# 2^192 - 1
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffff",
|
||||
|
||||
# Maximum canonical P192K1 multiplication result
|
||||
("fffffffffffffffffffffffffffffffffffffffdffffdc6c"
|
||||
"0000000000000000000000000000000100002394013c7364"),
|
||||
|
||||
# First 8 number generated by random.getrandbits(384) - seed(2,2)
|
||||
("cf1822ffbc6887782b491044d5e341245c6e433715ba2bdd"
|
||||
"177219d30e7a269fd95bafc8f2a4d27bdcf4bb99f4bea973"),
|
||||
("ffed9235288bc781ae66267594c9c9500925e4749b575bd1"
|
||||
"3653f8dd9b1f282e4067c3584ee207f8da94e3e8ab73738f"),
|
||||
("ef8acd128b4f2fc15f3f57ebf30b94fa82523e86feac7eb7"
|
||||
"dc38f519b91751dacdbd47d364be8049a372db8f6e405d93"),
|
||||
("e8624fab5186ee32ee8d7ee9770348a05d300cb90706a045"
|
||||
"defc044a09325626e6b58de744ab6cce80877b6f71e1f6d2"),
|
||||
("2d3d854e061b90303b08c6e33c7295782d6c797f8f7d9b78"
|
||||
"2a1be9cd8697bbd0e2520e33e44c50556c71c4a66148a86f"),
|
||||
("fec3f6b32e8d4b8a8f54f8ceacaab39e83844b40ffa9b9f1"
|
||||
"5c14bc4a829e07b0829a48d422fe99a22c70501e533c9135"),
|
||||
("97eeab64ca2ce6bc5d3fd983c34c769fe89204e2e8168561"
|
||||
"867e5e15bc01bfce6a27e0dfcbf8754472154e76e4c11ab2"),
|
||||
("bd143fa9b714210c665d7435c1066932f4767f26294365b2"
|
||||
"721dea3bf63f23d0dbe53fcafb2147df5ca495fa5a91c89b"),
|
||||
|
||||
# Next 2 number generated by random.getrandbits(192)
|
||||
"47733e847d718d733ff98ff387c56473a7a83ee0761ebfd2",
|
||||
"cbd4d3e2d4dec9ef83f0be4e80371eb97f81375eecc1cb63"
|
||||
]
|
||||
|
||||
@property
|
||||
def arg_a(self) -> str:
|
||||
return super().format_arg('{:x}'.format(self.int_a)).zfill(2 * self.hex_digits)
|
||||
|
||||
def result(self) -> List[str]:
|
||||
result = self.int_a % self.int_n
|
||||
return [self.format_result(result)]
|
||||
|
||||
@property
|
||||
def is_valid(self) -> bool:
|
||||
return True
|
||||
|
||||
|
||||
class EcpP224K1Raw(bignum_common.ModOperationCommon,
|
||||
EcpTarget):
|
||||
"""Test cases for ECP P224 fast reduction."""
|
||||
symbol = "-"
|
||||
test_function = "ecp_mod_p224k1"
|
||||
test_name = "ecp_mod_p224k1"
|
||||
input_style = "fixed"
|
||||
arity = 1
|
||||
dependencies = ["MBEDTLS_ECP_DP_SECP224K1_ENABLED"]
|
||||
|
||||
moduli = ["fffffffffffffffffffffffffffffffffffffffffffffffeffffe56d"] # type: List[str]
|
||||
|
||||
input_values = [
|
||||
"0", "1",
|
||||
|
||||
# Modulus - 1
|
||||
"fffffffffffffffffffffffffffffffffffffffffffffffeffffe56c",
|
||||
|
||||
# Modulus + 1
|
||||
"fffffffffffffffffffffffffffffffffffffffffffffffeffffe56e",
|
||||
|
||||
# 2^224 - 1
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
|
||||
|
||||
# Maximum canonical P224 multiplication result
|
||||
("fffffffffffffffffffffffffffffffffffffffffffffffdffffcad8"
|
||||
"00000000000000000000000000000000000000010000352802c26590"),
|
||||
|
||||
# First 8 number generated by random.getrandbits(448) - seed(2,2)
|
||||
("da94e3e8ab73738fcf1822ffbc6887782b491044d5e341245c6e4337"
|
||||
"15ba2bdd177219d30e7a269fd95bafc8f2a4d27bdcf4bb99f4bea973"),
|
||||
("cdbd47d364be8049a372db8f6e405d93ffed9235288bc781ae662675"
|
||||
"94c9c9500925e4749b575bd13653f8dd9b1f282e4067c3584ee207f8"),
|
||||
("defc044a09325626e6b58de744ab6cce80877b6f71e1f6d2ef8acd12"
|
||||
"8b4f2fc15f3f57ebf30b94fa82523e86feac7eb7dc38f519b91751da"),
|
||||
("2d6c797f8f7d9b782a1be9cd8697bbd0e2520e33e44c50556c71c4a6"
|
||||
"6148a86fe8624fab5186ee32ee8d7ee9770348a05d300cb90706a045"),
|
||||
("8f54f8ceacaab39e83844b40ffa9b9f15c14bc4a829e07b0829a48d4"
|
||||
"22fe99a22c70501e533c91352d3d854e061b90303b08c6e33c729578"),
|
||||
("97eeab64ca2ce6bc5d3fd983c34c769fe89204e2e8168561867e5e15"
|
||||
"bc01bfce6a27e0dfcbf8754472154e76e4c11ab2fec3f6b32e8d4b8a"),
|
||||
("a7a83ee0761ebfd2bd143fa9b714210c665d7435c1066932f4767f26"
|
||||
"294365b2721dea3bf63f23d0dbe53fcafb2147df5ca495fa5a91c89b"),
|
||||
("74667bffe202849da9643a295a9ac6decbd4d3e2d4dec9ef83f0be4e"
|
||||
"80371eb97f81375eecc1cb6347733e847d718d733ff98ff387c56473"),
|
||||
|
||||
# Next 2 number generated by random.getrandbits(224)
|
||||
("eb9ac688b9d39cca91551e8259cc60b17604e4b4e73695c3e652c71a"),
|
||||
("f0caeef038c89b38a8acb5137c9260dc74e088a9b9492f258ebdbfe3"),
|
||||
]
|
||||
|
||||
@property
|
||||
def arg_a(self) -> str:
|
||||
hex_digits = bignum_common.hex_digits_for_limb(448 // self.bits_in_limb, self.bits_in_limb)
|
||||
return super().format_arg('{:x}'.format(self.int_a)).zfill(hex_digits)
|
||||
|
||||
def result(self) -> List[str]:
|
||||
result = self.int_a % self.int_n
|
||||
return [self.format_result(result)]
|
||||
|
||||
@property
|
||||
def is_valid(self) -> bool:
|
||||
return True
|
||||
|
||||
|
||||
class EcpP256K1Raw(bignum_common.ModOperationCommon,
|
||||
EcpTarget):
|
||||
"""Test cases for ECP P256 fast reduction."""
|
||||
symbol = "-"
|
||||
test_function = "ecp_mod_p256k1"
|
||||
test_name = "ecp_mod_p256k1"
|
||||
input_style = "fixed"
|
||||
arity = 1
|
||||
dependencies = ["MBEDTLS_ECP_DP_SECP256K1_ENABLED"]
|
||||
|
||||
moduli = ["fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"] # type: List[str]
|
||||
|
||||
input_values = [
|
||||
"0", "1",
|
||||
|
||||
# Modulus - 1
|
||||
"fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2e",
|
||||
|
||||
# Modulus + 1
|
||||
"fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc30",
|
||||
|
||||
# 2^256 - 1
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
|
||||
|
||||
# Maximum canonical P256 multiplication result
|
||||
("fffffffffffffffffffffffffffffffffffffffffffffffffffffffdfffff85c0"
|
||||
"00000000000000000000000000000000000000000000001000007a4000e9844"),
|
||||
|
||||
# First 8 number generated by random.getrandbits(512) - seed(2,2)
|
||||
("4067c3584ee207f8da94e3e8ab73738fcf1822ffbc6887782b491044d5e34124"
|
||||
"5c6e433715ba2bdd177219d30e7a269fd95bafc8f2a4d27bdcf4bb99f4bea973"),
|
||||
("82523e86feac7eb7dc38f519b91751dacdbd47d364be8049a372db8f6e405d93"
|
||||
"ffed9235288bc781ae66267594c9c9500925e4749b575bd13653f8dd9b1f282e"),
|
||||
("e8624fab5186ee32ee8d7ee9770348a05d300cb90706a045defc044a09325626"
|
||||
"e6b58de744ab6cce80877b6f71e1f6d2ef8acd128b4f2fc15f3f57ebf30b94fa"),
|
||||
("829a48d422fe99a22c70501e533c91352d3d854e061b90303b08c6e33c729578"
|
||||
"2d6c797f8f7d9b782a1be9cd8697bbd0e2520e33e44c50556c71c4a66148a86f"),
|
||||
("e89204e2e8168561867e5e15bc01bfce6a27e0dfcbf8754472154e76e4c11ab2"
|
||||
"fec3f6b32e8d4b8a8f54f8ceacaab39e83844b40ffa9b9f15c14bc4a829e07b0"),
|
||||
("bd143fa9b714210c665d7435c1066932f4767f26294365b2721dea3bf63f23d0"
|
||||
"dbe53fcafb2147df5ca495fa5a91c89b97eeab64ca2ce6bc5d3fd983c34c769f"),
|
||||
("74667bffe202849da9643a295a9ac6decbd4d3e2d4dec9ef83f0be4e80371eb9"
|
||||
"7f81375eecc1cb6347733e847d718d733ff98ff387c56473a7a83ee0761ebfd2"),
|
||||
("d08f1bb2531d6460f0caeef038c89b38a8acb5137c9260dc74e088a9b9492f25"
|
||||
"8ebdbfe3eb9ac688b9d39cca91551e8259cc60b17604e4b4e73695c3e652c71a"),
|
||||
|
||||
# Next 2 number generated by random.getrandbits(256)
|
||||
("c5e2486c44a4a8f69dc8db48e86ec9c6e06f291b2a838af8d5c44a4eb3172062"),
|
||||
("d4c0dca8b4c9e755cc9c3adcf515a8234da4daeb4f3f87777ad1f45ae9500ec9"),
|
||||
]
|
||||
|
||||
@property
|
||||
def arg_a(self) -> str:
|
||||
hex_digits = bignum_common.hex_digits_for_limb(448 // self.bits_in_limb, self.bits_in_limb)
|
||||
return super().format_arg('{:x}'.format(self.int_a)).zfill(hex_digits)
|
||||
|
||||
def result(self) -> List[str]:
|
||||
result = self.int_a % self.int_n
|
||||
return [self.format_result(result)]
|
||||
|
||||
@property
|
||||
def is_valid(self) -> bool:
|
||||
return True
|
||||
|
||||
|
||||
class EcpP448Raw(bignum_common.ModOperationCommon,
|
||||
EcpTarget):
|
||||
"""Test cases for ECP P448 fast reduction."""
|
||||
symbol = "-"
|
||||
test_function = "ecp_mod_p448"
|
||||
test_name = "ecp_mod_p448"
|
||||
input_style = "fixed"
|
||||
arity = 1
|
||||
dependencies = ["MBEDTLS_ECP_DP_CURVE448_ENABLED"]
|
||||
|
||||
moduli = [("fffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")] # type: List[str]
|
||||
|
||||
input_values = [
|
||||
"0", "1",
|
||||
|
||||
# Modulus - 1
|
||||
("fffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
|
||||
"fffffffffffffffffffffffffffffffffffffffffffffffffffffffe"),
|
||||
|
||||
# Modulus + 1
|
||||
("ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
"00000000000000000000000000000000000000000000000000000000"),
|
||||
|
||||
# 2^448 - 1
|
||||
("ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
||||
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
|
||||
|
||||
# Maximum canonical P448 multiplication result
|
||||
("fffffffffffffffffffffffffffffffffffffffffffffffffffffffd"
|
||||
"fffffffffffffffffffffffffffffffffffffffffffffffffffffffd"
|
||||
"00000000000000000000000000000000000000000000000000000004"
|
||||
"00000000000000000000000000000000000000000000000000000004"),
|
||||
|
||||
# First 8 number generated by random.getrandbits(896) - seed(2,2)
|
||||
("74667bffe202849da9643a295a9ac6decbd4d3e2d4dec9ef83f0be4e"
|
||||
"80371eb97f81375eecc1cb6347733e847d718d733ff98ff387c56473"
|
||||
"a7a83ee0761ebfd2bd143fa9b714210c665d7435c1066932f4767f26"
|
||||
"294365b2721dea3bf63f23d0dbe53fcafb2147df5ca495fa5a91c89b"),
|
||||
("4da4daeb4f3f87777ad1f45ae9500ec9c5e2486c44a4a8f69dc8db48"
|
||||
"e86ec9c6e06f291b2a838af8d5c44a4eb3172062d08f1bb2531d6460"
|
||||
"f0caeef038c89b38a8acb5137c9260dc74e088a9b9492f258ebdbfe3"
|
||||
"eb9ac688b9d39cca91551e8259cc60b17604e4b4e73695c3e652c71a"),
|
||||
("bc1b00d92838e766ef9b6bf2d037fe2e20b6a8464174e75a5f834da7"
|
||||
"0569c018eb2b5693babb7fbb0a76c196067cfdcb11457d9cf45e2fa0"
|
||||
"1d7f4275153924800600571fac3a5b263fdf57cd2c0064975c374746"
|
||||
"5cc36c270e8a35b10828d569c268a20eb78ac332e5e138e26c4454b9"),
|
||||
("8d2f527e72daf0a54ef25c0707e338687d1f71575653a45c49390aa5"
|
||||
"1cf5192bbf67da14be11d56ba0b4a2969d8055a9f03f2d71581d8e83"
|
||||
"0112ff0f0948eccaf8877acf26c377c13f719726fd70bddacb4deeec"
|
||||
"0b0c995e96e6bc4d62b47204007ee4fab105d83e85e951862f0981ae"),
|
||||
("84ae65e920a63ac1f2b64df6dff07870c9d531ae72a47403063238da"
|
||||
"1a1fe3f9d6a179fa50f96cd4aff9261aa92c0e6f17ec940639bc2ccd"
|
||||
"f572df00790813e32748dd1db4917fc09f20dbb0dcc93f0e66dfe717"
|
||||
"c17313394391b6e2e6eacb0f0bb7be72bd6d25009aeb7fa0c4169b14"),
|
||||
("2bb3b36f29421c4021b7379f0897246a40c270b00e893302aba9e7b8"
|
||||
"23fc5ad2f58105748ed5d1b7b310b730049dd332a73fa0b26b75196c"
|
||||
"f87eb8a09b27ec714307c68c425424a1574f1eedf5b0f16cdfdb8394"
|
||||
"24d201e653f53d6883ca1c107ca6e706649889c0c7f3860895bfa813"),
|
||||
("af3f5d7841b1256d5c1dc12fb5a1ae519fb8883accda6559caa538a0"
|
||||
"9fc9370d3a6b86a7975b54a31497024640332b0612d4050771d7b14e"
|
||||
"b6c004cc3b8367dc3f2bb31efe9934ad0809eae3ef232a32b5459d83"
|
||||
"fbc46f1aea990e94821d46063b4dbf2ca294523d74115c86188b1044"),
|
||||
("7430051376e31f5aab63ad02854efa600641b4fa37a47ce41aeffafc"
|
||||
"3b45402ac02659fe2e87d4150511baeb198ababb1a16daff3da95cd2"
|
||||
"167b75dfb948f82a8317cba01c75f67e290535d868a24b7f627f2855"
|
||||
"09167d4126af8090013c3273c02c6b9586b4625b475b51096c4ad652"),
|
||||
|
||||
# Next 2 number generated by random.getrandbits(448)
|
||||
("8f54f8ceacaab39e83844b40ffa9b9f15c14bc4a829e07b0829a48d4"
|
||||
"22fe99a22c70501e533c91352d3d854e061b90303b08c6e33c729578"),
|
||||
("97eeab64ca2ce6bc5d3fd983c34c769fe89204e2e8168561867e5e15"
|
||||
"bc01bfce6a27e0dfcbf8754472154e76e4c11ab2fec3f6b32e8d4b8a"),
|
||||
|
||||
]
|
||||
|
||||
@property
|
||||
def arg_a(self) -> str:
|
||||
return super().format_arg('{:x}'.format(self.int_a)).zfill(2 * self.hex_digits)
|
||||
|
||||
def result(self) -> List[str]:
|
||||
result = self.int_a % self.int_n
|
||||
return [self.format_result(result)]
|
||||
|
||||
@property
|
||||
def is_valid(self) -> bool:
|
||||
return True
|
||||
|
||||
Reference in New Issue
Block a user