855 lines
34 KiB
Python
855 lines
34 KiB
Python
"""Framework classes for generation of bignum core test cases."""
|
|
# Copyright The Mbed TLS Contributors
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import random
|
|
|
|
from typing import Dict, Iterator, List, Tuple
|
|
|
|
from . import test_case
|
|
from . import test_data_generation
|
|
from . import bignum_common
|
|
|
|
class BignumCoreTarget(test_data_generation.BaseTarget):
|
|
#pylint: disable=abstract-method, too-few-public-methods
|
|
"""Target for bignum core test case generation."""
|
|
target_basename = 'test_suite_bignum_core.generated'
|
|
|
|
|
|
class BignumCoreShiftR(BignumCoreTarget, test_data_generation.BaseTest):
|
|
"""Test cases for mbedtls_bignum_core_shift_r()."""
|
|
count = 0
|
|
test_function = "mpi_core_shift_r"
|
|
test_name = "Core shift right"
|
|
|
|
DATA = [
|
|
('00', '0', [0, 1, 8]),
|
|
('01', '1', [0, 1, 2, 8, 64]),
|
|
('dee5ca1a7ef10a75', '64-bit',
|
|
list(range(11)) + [31, 32, 33, 63, 64, 65, 71, 72]),
|
|
('002e7ab0070ad57001', '[leading 0 limb]',
|
|
[0, 1, 8, 63, 64]),
|
|
('a1055eb0bb1efa1150ff', '80-bit',
|
|
[0, 1, 8, 63, 64, 65, 72, 79, 80, 81, 88, 128, 129, 136]),
|
|
('020100000000000000001011121314151617', '138-bit',
|
|
[0, 1, 8, 9, 16, 72, 73, 136, 137, 138, 144]),
|
|
]
|
|
|
|
def __init__(self, input_hex: str, descr: str, count: int) -> None:
|
|
self.input_hex = input_hex
|
|
self.number_description = descr
|
|
self.shift_count = count
|
|
self.result = bignum_common.hex_to_int(input_hex) >> count
|
|
|
|
def arguments(self) -> List[str]:
|
|
return ['"{}"'.format(self.input_hex),
|
|
str(self.shift_count),
|
|
'"{:0{}x}"'.format(self.result, len(self.input_hex))]
|
|
|
|
def description(self) -> str:
|
|
return 'Core shift {} >> {}'.format(self.number_description,
|
|
self.shift_count)
|
|
|
|
@classmethod
|
|
def generate_function_tests(cls) -> Iterator[test_case.TestCase]:
|
|
for input_hex, descr, counts in cls.DATA:
|
|
for count in counts:
|
|
yield cls(input_hex, descr, count).create_test_case()
|
|
|
|
class BignumCoreCTLookup(BignumCoreTarget, test_data_generation.BaseTest):
|
|
"""Test cases for mbedtls_mpi_core_ct_uint_table_lookup()."""
|
|
test_function = "mpi_core_ct_uint_table_lookup"
|
|
test_name = "Constant time MPI table lookup"
|
|
|
|
bitsizes = [
|
|
(32, "One limb"),
|
|
(192, "Smallest curve sized"),
|
|
(512, "Largest curve sized"),
|
|
(2048, "Small FF/RSA sized"),
|
|
(4096, "Large FF/RSA sized"),
|
|
]
|
|
|
|
window_sizes = [0, 1, 2, 3, 4, 5, 6]
|
|
|
|
def __init__(self,
|
|
bitsize: int, descr: str, window_size: int) -> None:
|
|
self.bitsize = bitsize
|
|
self.bitsize_description = descr
|
|
self.window_size = window_size
|
|
|
|
def arguments(self) -> List[str]:
|
|
return [str(self.bitsize), str(self.window_size)]
|
|
|
|
def description(self) -> str:
|
|
return '{} - {} MPI with {} bit window'.format(
|
|
BignumCoreCTLookup.test_name,
|
|
self.bitsize_description,
|
|
self.window_size
|
|
)
|
|
|
|
@classmethod
|
|
def generate_function_tests(cls) -> Iterator[test_case.TestCase]:
|
|
for bitsize, bitsize_description in cls.bitsizes:
|
|
for window_size in cls.window_sizes:
|
|
yield (cls(bitsize, bitsize_description, window_size)
|
|
.create_test_case())
|
|
|
|
|
|
class BignumCoreAddAndAddIf(BignumCoreTarget, bignum_common.OperationCommon):
|
|
"""Test cases for bignum core add and add-if."""
|
|
count = 0
|
|
symbol = "+"
|
|
test_function = "mpi_core_add_and_add_if"
|
|
test_name = "mpi_core_add_and_add_if"
|
|
input_style = "arch_split"
|
|
unique_combinations_only = True
|
|
|
|
def result(self) -> List[str]:
|
|
result = self.int_a + self.int_b
|
|
|
|
carry, result = divmod(result, self.limb_boundary)
|
|
|
|
return [
|
|
self.format_result(result),
|
|
str(carry)
|
|
]
|
|
|
|
|
|
class BignumCoreSub(BignumCoreTarget, bignum_common.OperationCommon):
|
|
"""Test cases for bignum core sub."""
|
|
count = 0
|
|
input_style = "arch_split"
|
|
symbol = "-"
|
|
test_function = "mpi_core_sub"
|
|
test_name = "mbedtls_mpi_core_sub"
|
|
|
|
def result(self) -> List[str]:
|
|
if self.int_a >= self.int_b:
|
|
result = self.int_a - self.int_b
|
|
carry = 0
|
|
else:
|
|
result = self.limb_boundary + self.int_a - self.int_b
|
|
carry = 1
|
|
return [
|
|
self.format_result(result),
|
|
str(carry)
|
|
]
|
|
|
|
|
|
class BignumCoreMLA(BignumCoreTarget, bignum_common.OperationCommon):
|
|
"""Test cases for fixed-size multiply accumulate."""
|
|
count = 0
|
|
test_function = "mpi_core_mla"
|
|
test_name = "mbedtls_mpi_core_mla"
|
|
|
|
input_values = [
|
|
"0", "1", "fffe", "ffffffff", "100000000", "20000000000000",
|
|
"ffffffffffffffff", "10000000000000000", "1234567890abcdef0",
|
|
"fffffffffffffffffefefefefefefefe",
|
|
"100000000000000000000000000000000",
|
|
"1234567890abcdef01234567890abcdef0",
|
|
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
|
|
"1234567890abcdef01234567890abcdef01234567890abcdef01234567890abcdef0",
|
|
(
|
|
"4df72d07b4b71c8dacb6cffa954f8d88254b6277099308baf003fab73227f"
|
|
"34029643b5a263f66e0d3c3fa297ef71755efd53b8fb6cb812c6bbf7bcf17"
|
|
"9298bd9947c4c8b14324140a2c0f5fad7958a69050a987a6096e9f055fb38"
|
|
"edf0c5889eca4a0cfa99b45fbdeee4c696b328ddceae4723945901ec02507"
|
|
"6b12b"
|
|
)
|
|
] # type: List[str]
|
|
input_scalars = [
|
|
"0", "3", "fe", "ff", "ffff", "10000", "ffffffff", "100000000",
|
|
"7f7f7f7f7f7f7f7f", "8000000000000000", "fffffffffffffffe"
|
|
] # type: List[str]
|
|
|
|
def __init__(self, val_a: str, val_b: str, val_s: str) -> None:
|
|
super().__init__(val_a, val_b)
|
|
self.arg_scalar = val_s
|
|
self.int_scalar = bignum_common.hex_to_int(val_s)
|
|
if bignum_common.limbs_mpi(self.int_scalar, 32) > 1:
|
|
self.dependencies = ["MBEDTLS_HAVE_INT64"]
|
|
|
|
def arguments(self) -> List[str]:
|
|
return [
|
|
bignum_common.quote_str(self.arg_a),
|
|
bignum_common.quote_str(self.arg_b),
|
|
bignum_common.quote_str(self.arg_scalar)
|
|
] + self.result()
|
|
|
|
def description(self) -> str:
|
|
"""Override and add the additional scalar."""
|
|
if not self.case_description:
|
|
self.case_description = "0x{} + 0x{} * 0x{}".format(
|
|
self.arg_a, self.arg_b, self.arg_scalar
|
|
)
|
|
return super().description()
|
|
|
|
def result(self) -> List[str]:
|
|
result = self.int_a + (self.int_b * self.int_scalar)
|
|
bound_val = max(self.int_a, self.int_b)
|
|
bound_4 = bignum_common.bound_mpi(bound_val, 32)
|
|
bound_8 = bignum_common.bound_mpi(bound_val, 64)
|
|
carry_4, remainder_4 = divmod(result, bound_4)
|
|
carry_8, remainder_8 = divmod(result, bound_8)
|
|
return [
|
|
"\"{:x}\"".format(remainder_4),
|
|
"\"{:x}\"".format(carry_4),
|
|
"\"{:x}\"".format(remainder_8),
|
|
"\"{:x}\"".format(carry_8)
|
|
]
|
|
|
|
@classmethod
|
|
def get_value_pairs(cls) -> Iterator[Tuple[str, str]]:
|
|
"""Generator to yield pairs of inputs.
|
|
|
|
Combinations are first generated from all input values, and then
|
|
specific cases provided.
|
|
"""
|
|
yield from super().get_value_pairs()
|
|
yield from cls.input_cases
|
|
|
|
@classmethod
|
|
def generate_function_tests(cls) -> Iterator[test_case.TestCase]:
|
|
"""Override for additional scalar input."""
|
|
for a_value, b_value in cls.get_value_pairs():
|
|
for s_value in cls.input_scalars:
|
|
cur_op = cls(a_value, b_value, s_value)
|
|
yield cur_op.create_test_case()
|
|
|
|
|
|
class BignumCoreMontmul(BignumCoreTarget, test_data_generation.BaseTest):
|
|
"""Test cases for Montgomery multiplication."""
|
|
count = 0
|
|
test_function = "mpi_core_montmul"
|
|
test_name = "mbedtls_mpi_core_montmul"
|
|
|
|
start_2_mpi4 = False
|
|
start_2_mpi8 = False
|
|
|
|
replay_test_cases = [
|
|
(2, 1, 1, 1, "19", "1", "1D"), (2, 1, 1, 1, "7", "1", "9"),
|
|
(2, 1, 1, 1, "4", "1", "9"),
|
|
(
|
|
12, 1, 6, 1, (
|
|
"3C246D0E059A93A266288A7718419EC741661B474C58C032C5EDAF92709402"
|
|
"B07CC8C7CE0B781C641A1EA8DB2F4343"
|
|
), "1", (
|
|
"66A198186C18C10B2F5ED9B522752A9830B69916E535C8F047518A889A43A5"
|
|
"94B6BED27A168D31D4A52F88925AA8F5"
|
|
)
|
|
), (
|
|
8, 1, 4, 1,
|
|
"1E442976B0E63D64FCCE74B999E470CA9888165CB75BFA1F340E918CE03C6211",
|
|
"1", "B3A119602EE213CDE28581ECD892E0F592A338655DCE4CA88054B3D124D0E561"
|
|
), (
|
|
22, 1, 11, 1, (
|
|
"7CF5AC97304E0B63C65413F57249F59994B0FED1D2A8D3D83ED5FA38560FFB"
|
|
"82392870D6D08F87D711917FD7537E13B7E125BE407E74157776839B0AC9DB"
|
|
"23CBDFC696104353E4D2780B2B4968F8D8542306BCA7A2366E"
|
|
), "1", (
|
|
"284139EA19C139EBE09A8111926AAA39A2C2BE12ED487A809D3CB5BC558547"
|
|
"25B4CDCB5734C58F90B2F60D99CC1950CDBC8D651793E93C9C6F0EAD752500"
|
|
"A32C56C62082912B66132B2A6AA42ADA923E1AD22CEB7BA0123"
|
|
)
|
|
)
|
|
] # type: List[Tuple[int, int, int, int, str, str, str]]
|
|
|
|
random_test_cases = [
|
|
("2", "2", "3", ""), ("1", "2", "3", ""), ("2", "1", "3", ""),
|
|
("6", "5", "7", ""), ("3", "4", "7", ""), ("1", "6", "7", ""), ("5", "6", "7", ""),
|
|
("3", "4", "B", ""), ("7", "4", "B", ""), ("9", "7", "B", ""), ("2", "a", "B", ""),
|
|
("25", "16", "29", "(0x29 is prime)"), ("8", "28", "29", ""),
|
|
("18", "21", "29", ""), ("15", "f", "29", ""),
|
|
("e2", "ea", "FF", ""), ("43", "72", "FF", ""),
|
|
("d8", "70", "FF", ""), ("3c", "7c", "FF", ""),
|
|
("99", "b9", "101", "(0x101 is prime)"), ("65", "b2", "101", ""),
|
|
("81", "32", "101", ""), ("51", "dd", "101", ""),
|
|
("d5", "143", "38B", "(0x38B is prime)"), ("3d", "387", "38B", ""),
|
|
("160", "2e5", "38B", ""), ("10f", "137", "38B", ""),
|
|
("7dac", "25a", "8003", "(0x8003 is prime)"), ("6f1c", "3286", "8003", ""),
|
|
("59ed", "2f3f", "8003", ""), ("6893", "736d", "8003", ""),
|
|
("d199", "2832", "10001", "(0x10001 is prime)"), ("c3b2", "3e5b", "10001", ""),
|
|
("abe4", "214e", "10001", ""), ("4360", "a05d", "10001", ""),
|
|
("3f5a1", "165b2", "7F7F7", ""), ("3bd29", "37863", "7F7F7", ""),
|
|
("60c47", "64819", "7F7F7", ""), ("16584", "12c49", "7F7F7", ""),
|
|
("1ff03f", "610347", "800009", "(0x800009 is prime)"), ("340fd5", "19812e", "800009", ""),
|
|
("3fe2e8", "4d0dc7", "800009", ""), ("40356", "e6392", "800009", ""),
|
|
("dd8a1d", "266c0e", "100002B", "(0x100002B is prime)"),
|
|
("3fa1cb", "847fd6", "100002B", ""), ("5f439d", "5c3196", "100002B", ""),
|
|
("18d645", "f72dc6", "100002B", ""),
|
|
("20051ad", "37def6e", "37EEE9D", "(0x37EEE9D is prime)"),
|
|
("2ec140b", "3580dbf", "37EEE9D", ""), ("1d91b46", "190d4fc", "37EEE9D", ""),
|
|
("34e488d", "1224d24", "37EEE9D", ""),
|
|
("2a4fe2cb", "263466a9", "8000000B", "(0x8000000B is prime)"),
|
|
("5643fe94", "29a1aefa", "8000000B", ""), ("29633513", "7b007ac4", "8000000B", ""),
|
|
("2439cef5", "5c9d5a47", "8000000B", ""),
|
|
("4de3cfaa", "50dea178", "8CD626B9", "(0x8CD626B9 is prime)"),
|
|
("b8b8563", "10dbbbac", "8CD626B9", ""), ("4e8a6151", "5574ec19", "8CD626B9", ""),
|
|
("69224878", "309cfc23", "8CD626B9", ""),
|
|
("fb6f7fb6", "afb05423", "10000000F", "(0x10000000F is prime)"),
|
|
("8391a243", "26034dcd", "10000000F", ""), ("d26b98c", "14b2d6aa", "10000000F", ""),
|
|
("6b9f1371", "a21daf1d", "10000000F", ""),
|
|
(
|
|
"9f49435ad", "c8264ade8", "174876E7E9",
|
|
"0x174876E7E9 is prime (dec) 99999999977"
|
|
),
|
|
("c402da434", "1fb427acf", "174876E7E9", ""),
|
|
("f6ebc2bb1", "1096d39f2a", "174876E7E9", ""),
|
|
("153b7f7b6b", "878fda8ff", "174876E7E9", ""),
|
|
("2c1adbb8d6", "4384d2d3c6", "8000000017", "(0x8000000017 is prime)"),
|
|
("2e4f9cf5fb", "794f3443d9", "8000000017", ""),
|
|
("149e495582", "3802b8f7b7", "8000000017", ""),
|
|
("7b9d49df82", "69c68a442a", "8000000017", ""),
|
|
("683a134600", "6dd80ea9f6", "864CB9076D", "(0x864CB9076D is prime)"),
|
|
("13a870ff0d", "59b099694a", "864CB9076D", ""),
|
|
("37d06b0e63", "4d2147e46f", "864CB9076D", ""),
|
|
("661714f8f4", "22e55df507", "864CB9076D", ""),
|
|
("2f0a96363", "52693307b4", "F7F7F7F7F7", ""),
|
|
("3c85078e64", "f2275ecb6d", "F7F7F7F7F7", ""),
|
|
("352dae68d1", "707775b4c6", "F7F7F7F7F7", ""),
|
|
("37ae0f3e0b", "912113040f", "F7F7F7F7F7", ""),
|
|
("6dada15e31", "f58ed9eff7", "1000000000F", "(0x1000000000F is prime)"),
|
|
("69627a7c89", "cfb5ebd13d", "1000000000F", ""),
|
|
("a5e1ad239b", "afc030c731", "1000000000F", ""),
|
|
("f1cc45f4c5", "c64ad607c8", "1000000000F", ""),
|
|
("2ebad87d2e31", "4c72d90bca78", "800000000005", "(0x800000000005 is prime)"),
|
|
("a30b3cc50d", "29ac4fe59490", "800000000005", ""),
|
|
("33674e9647b4", "5ec7ee7e72d3", "800000000005", ""),
|
|
("3d956f474f61", "74070040257d", "800000000005", ""),
|
|
("48348e3717d6", "43fcb4399571", "800795D9BA47", "(0x800795D9BA47 is prime)"),
|
|
("5234c03cc99b", "2f3cccb87803", "800795D9BA47", ""),
|
|
("3ed13db194ab", "44b8f4ba7030", "800795D9BA47", ""),
|
|
("1c11e843bfdb", "95bd1b47b08", "800795D9BA47", ""),
|
|
("a81d11cb81fd", "1e5753a3f33d", "1000000000015", "(0x1000000000015 is prime)"),
|
|
("688c4db99232", "36fc0cf7ed", "1000000000015", ""),
|
|
("f0720cc07e07", "fc76140ed903", "1000000000015", ""),
|
|
("2ec61f8d17d1", "d270c85e36d2", "1000000000015", ""),
|
|
(
|
|
"6a24cd3ab63820", "ed4aad55e5e348", "100000000000051",
|
|
"(0x100000000000051 is prime)"
|
|
),
|
|
("e680c160d3b248", "31e0d8840ed510", "100000000000051", ""),
|
|
("a80637e9aebc38", "bb81decc4e1738", "100000000000051", ""),
|
|
("9afa5a59e9d630", "be9e65a6d42938", "100000000000051", ""),
|
|
("ab5e104eeb71c000", "2cffbd639e9fea00", "ABCDEF0123456789", ""),
|
|
("197b867547f68a00", "44b796cf94654800", "ABCDEF0123456789", ""),
|
|
("329f9483a04f2c00", "9892f76961d0f000", "ABCDEF0123456789", ""),
|
|
("4a2e12dfb4545000", "1aa3e89a69794500", "ABCDEF0123456789", ""),
|
|
(
|
|
"8b9acdf013d140f000", "12e4ceaefabdf2b2f00", "25A55A46E5DA99C71C7",
|
|
"0x25A55A46E5DA99C71C7 is the 3rd repunit prime(dec) 11111111111111111111111"
|
|
),
|
|
("1b8d960ea277e3f5500", "14418aa980e37dd000", "25A55A46E5DA99C71C7", ""),
|
|
("7314524977e8075980", "8172fa45618ccd0d80", "25A55A46E5DA99C71C7", ""),
|
|
("ca14f031769be63580", "147a2f3cf2964ca9400", "25A55A46E5DA99C71C7", ""),
|
|
(
|
|
"18532ba119d5cd0cf39735c0000", "25f9838e31634844924733000000",
|
|
"314DC643FB763F2B8C0E2DE00879",
|
|
"0x314DC643FB763F2B8C0E2DE00879 is (dec)99999999977^3"
|
|
),
|
|
(
|
|
"a56e2d2517519e3970e70c40000", "ec27428d4bb380458588fa80000",
|
|
"314DC643FB763F2B8C0E2DE00879", ""
|
|
),
|
|
(
|
|
"1cb5e8257710e8653fff33a00000", "15fdd42fe440fd3a1d121380000",
|
|
"314DC643FB763F2B8C0E2DE00879", ""
|
|
),
|
|
(
|
|
"e50d07a65fc6f93e538ce040000", "1f4b059ca609f3ce597f61240000",
|
|
"314DC643FB763F2B8C0E2DE00879", ""
|
|
),
|
|
(
|
|
"1ea3ade786a095d978d387f30df9f20000000",
|
|
"127c448575f04af5a367a7be06c7da0000000",
|
|
"47BF19662275FA2F6845C74942ED1D852E521",
|
|
"0x47BF19662275FA2F6845C74942ED1D852E521 is (dec) 99999999977^4"
|
|
),
|
|
(
|
|
"16e15b0ca82764e72e38357b1f10a20000000",
|
|
"43e2355d8514bbe22b0838fdc3983a0000000",
|
|
"47BF19662275FA2F6845C74942ED1D852E521", ""
|
|
),
|
|
(
|
|
"be39332529d93f25c3d116c004c620000000",
|
|
"5cccec42370a0a2c89c6772da801a0000000",
|
|
"47BF19662275FA2F6845C74942ED1D852E521", ""
|
|
),
|
|
(
|
|
"ecaa468d90de0eeda474d39b3e1fc0000000",
|
|
"1e714554018de6dc0fe576bfd3b5660000000",
|
|
"47BF19662275FA2F6845C74942ED1D852E521", ""
|
|
),
|
|
(
|
|
"32298816711c5dce46f9ba06e775c4bedfc770e6700000000000000",
|
|
"8ee751fd5fb24f0b4a653cb3a0c8b7d9e724574d168000000000000",
|
|
"97EDD86E4B5C4592C6D32064AC55C888A7245F07CA3CC455E07C931",
|
|
(
|
|
"0x97EDD86E4B5C4592C6D32064AC55C888A7245F07CA3CC455E07C931"
|
|
" is (dec) 99999999977^6"
|
|
)
|
|
),
|
|
(
|
|
"29213b9df3cfd15f4b428645b67b677c29d1378d810000000000000",
|
|
"6cbb732c65e10a28872394dfdd1936d5171c3c3aac0000000000000",
|
|
"97EDD86E4B5C4592C6D32064AC55C888A7245F07CA3CC455E07C931", ""
|
|
),
|
|
(
|
|
"6f18db06ad4abc52c0c50643dd13098abccd4a232f0000000000000",
|
|
"7e6bf41f2a86098ad51f98dfc10490ba3e8081bc830000000000000",
|
|
"97EDD86E4B5C4592C6D32064AC55C888A7245F07CA3CC455E07C931", ""
|
|
),
|
|
(
|
|
"62d3286cd706ad9d73caff63f1722775d7e8c731208000000000000",
|
|
"530f7ba02ae2b04c2fe3e3d27ec095925631a6c2528000000000000",
|
|
"97EDD86E4B5C4592C6D32064AC55C888A7245F07CA3CC455E07C931", ""
|
|
),
|
|
(
|
|
"a6c6503e3c031fdbf6009a89ed60582b7233c5a85de28b16000000000000000",
|
|
"75c8ed18270b583f16d442a467d32bf95c5e491e9b8523798000000000000000",
|
|
"DD15FE80B731872AC104DB37832F7E75A244AA2631BC87885B861E8F20375499",
|
|
(
|
|
"0xDD15FE80B731872AC104DB37832F7E75A244AA2631BC87885B861E8F20375499"
|
|
" is (dec) 99999999977^7"
|
|
)
|
|
),
|
|
(
|
|
"bf84d1f85cf6b51e04d2c8f4ffd03532d852053cf99b387d4000000000000000",
|
|
"397ba5a743c349f4f28bc583ecd5f06e0a25f9c6d98f09134000000000000000",
|
|
"DD15FE80B731872AC104DB37832F7E75A244AA2631BC87885B861E8F20375499", ""
|
|
),
|
|
(
|
|
"6db11c3a4152ed1a2aa6fa34b0903ec82ea1b88908dcb482000000000000000",
|
|
"ac8ac576a74ad6ca48f201bf89f77350ce86e821358d85920000000000000000",
|
|
"DD15FE80B731872AC104DB37832F7E75A244AA2631BC87885B861E8F20375499", ""
|
|
),
|
|
(
|
|
"3001d96d7fe8b733f33687646fc3017e3ac417eb32e0ec708000000000000000",
|
|
"925ddbdac4174e8321a48a32f79640e8cf7ec6f46ea235a80000000000000000",
|
|
"DD15FE80B731872AC104DB37832F7E75A244AA2631BC87885B861E8F20375499", ""
|
|
),
|
|
(
|
|
"1029048755f2e60dd98c8de6d9989226b6bb4f0db8e46bd1939de560000000000000000000",
|
|
"51bb7270b2e25cec0301a03e8275213bb6c2f6e6ec93d4d46d36ca0000000000000000000",
|
|
"141B8EBD9009F84C241879A1F680FACCED355DA36C498F73E96E880CF78EA5F96146380E41",
|
|
(
|
|
"0x141B8EBD9009F84C241879A1F680FACCED355DA36C498F73E96E880CF78EA5F96146"
|
|
"380E41 is 99999999977^8"
|
|
)
|
|
),
|
|
(
|
|
"1c5337ff982b3ad6611257dbff5bbd7a9920ba2d4f5838a0cc681ce000000000000000000",
|
|
"520c5d049ca4702031ba728591b665c4d4ccd3b2b86864d4c160fd2000000000000000000",
|
|
"141B8EBD9009F84C241879A1F680FACCED355DA36C498F73E96E880CF78EA5F96146380E41",
|
|
""
|
|
),
|
|
(
|
|
"57074dfa00e42f6555bae624b7f0209f218adf57f73ed34ab0ff90c000000000000000000",
|
|
"41eb14b6c07bfd3d1fe4f4a610c17cc44fcfcda695db040e011065000000000000000000",
|
|
"141B8EBD9009F84C241879A1F680FACCED355DA36C498F73E96E880CF78EA5F96146380E41",
|
|
""
|
|
),
|
|
(
|
|
"d8ed7feed2fe855e6997ad6397f776158573d425031bf085a615784000000000000000000",
|
|
"6f121dcd18c578ab5e229881006007bb6d319b179f11015fe958b9c000000000000000000",
|
|
"141B8EBD9009F84C241879A1F680FACCED355DA36C498F73E96E880CF78EA5F96146380E41",
|
|
""
|
|
),
|
|
(
|
|
(
|
|
"2a462b156180ea5fe550d3758c764e06fae54e626b5f503265a09df76edbdfbf"
|
|
"a1e6000000000000000000000000"
|
|
), (
|
|
"1136f41d1879fd4fb9e49e0943a46b6704d77c068ee237c3121f9071cfd3e6a0"
|
|
"0315800000000000000000000000"
|
|
), (
|
|
"2A94608DE88B6D5E9F8920F5ABB06B24CC35AE1FBACC87D075C621C3E2833EC90"
|
|
"2713E40F51E3B3C214EDFABC451"
|
|
), (
|
|
"0x2A94608DE88B6D5E9F8920F5ABB06B24CC35AE1FBACC87D075C621C3E2833EC"
|
|
"902713E40F51E3B3C214EDFABC451 is (dec) 99999999977^10"
|
|
)
|
|
),
|
|
(
|
|
(
|
|
"c1ac3800dfb3c6954dea391d206200cf3c47f795bf4a5603b4cb88ae7e574de47"
|
|
"40800000000000000000000000"
|
|
), (
|
|
"c0d16eda0549ede42fa0deb4635f7b7ce061fadea02ee4d85cba4c4f709603419"
|
|
"3c800000000000000000000000"
|
|
), (
|
|
"2A94608DE88B6D5E9F8920F5ABB06B24CC35AE1FBACC87D075C621C3E2833EC90"
|
|
"2713E40F51E3B3C214EDFABC451"
|
|
), ""
|
|
),
|
|
(
|
|
(
|
|
"19e45bb7633094d272588ad2e43bcb3ee341991c6731b6fa9d47c4018d7ce7bba"
|
|
"5ee800000000000000000000000"
|
|
), (
|
|
"1e4f83166ae59f6b9cc8fd3e7677ed8bfc01bb99c98bd3eb084246b64c1e18c33"
|
|
"65b800000000000000000000000"
|
|
), (
|
|
"2A94608DE88B6D5E9F8920F5ABB06B24CC35AE1FBACC87D075C621C3E2833EC90"
|
|
"2713E40F51E3B3C214EDFABC451"
|
|
), ""
|
|
),
|
|
(
|
|
(
|
|
"1aa93395fad5f9b7f20b8f9028a054c0bb7c11bb8520e6a95e5a34f06cb70bcdd"
|
|
"01a800000000000000000000000"
|
|
), (
|
|
"54b45afa5d4310192f8d224634242dd7dcfb342318df3d9bd37b4c614788ba13b"
|
|
"8b000000000000000000000000"
|
|
), (
|
|
"2A94608DE88B6D5E9F8920F5ABB06B24CC35AE1FBACC87D075C621C3E2833EC90"
|
|
"2713E40F51E3B3C214EDFABC451"
|
|
), ""
|
|
),
|
|
(
|
|
(
|
|
"544f2628a28cfb5ce0a1b7180ee66b49716f1d9476c466c57f0c4b23089917843"
|
|
"06d48f78686115ee19e25400000000000000000000000000000000"
|
|
), (
|
|
"677eb31ef8d66c120fa872a60cd47f6e10cbfdf94f90501bd7883cba03d185be0"
|
|
"a0148d1625745e9c4c827300000000000000000000000000000000"
|
|
), (
|
|
"8335616AED761F1F7F44E6BD49E807B82E3BF2BF11BFA6AF813C808DBF33DBFA1"
|
|
"1DABD6E6144BEF37C6800000000000000000000000000000000051"
|
|
), (
|
|
"0x8335616AED761F1F7F44E6BD49E807B82E3BF2BF11BFA6AF813C808DBF33DBF"
|
|
"A11DABD6E6144BEF37C6800000000000000000000000000000000051 is prime,"
|
|
" (dec) 10^143 + 3^4"
|
|
)
|
|
),
|
|
(
|
|
(
|
|
"76bb3470985174915e9993522aec989666908f9e8cf5cb9f037bf4aee33d8865c"
|
|
"b6464174795d07e30015b80000000000000000000000000000000"
|
|
), (
|
|
"6aaaf60d5784dcef612d133613b179a317532ecca0eed40b8ad0c01e6d4a6d8c7"
|
|
"9a52af190abd51739009a900000000000000000000000000000000"
|
|
), (
|
|
"8335616AED761F1F7F44E6BD49E807B82E3BF2BF11BFA6AF813C808DBF33DBFA1"
|
|
"1DABD6E6144BEF37C6800000000000000000000000000000000051"
|
|
), ""
|
|
),
|
|
(
|
|
(
|
|
"6cfdd6e60912e441d2d1fc88f421b533f0103a5322ccd3f4db84861643ad63fd6"
|
|
"3d1d8cfbc1d498162786ba00000000000000000000000000000000"
|
|
), (
|
|
"1177246ec5e93814816465e7f8f248b350d954439d35b2b5d75d917218e7fd5fb"
|
|
"4c2f6d0667f9467fdcf33400000000000000000000000000000000"
|
|
), (
|
|
"8335616AED761F1F7F44E6BD49E807B82E3BF2BF11BFA6AF813C808DBF33DBFA1"
|
|
"1DABD6E6144BEF37C6800000000000000000000000000000000051"
|
|
), ""
|
|
),
|
|
(
|
|
(
|
|
"7a09a0b0f8bbf8057116fb0277a9bdf3a91b5eaa8830d448081510d8973888be5"
|
|
"a9f0ad04facb69aa3715f00000000000000000000000000000000"
|
|
), (
|
|
"764dec6c05a1c0d87b649efa5fd94c91ea28bffb4725d4ab4b33f1a3e8e3b314d"
|
|
"799020e244a835a145ec9800000000000000000000000000000000"
|
|
), (
|
|
"8335616AED761F1F7F44E6BD49E807B82E3BF2BF11BFA6AF813C808DBF33DBFA1"
|
|
"1DABD6E6144BEF37C6800000000000000000000000000000000051"
|
|
), ""
|
|
)
|
|
] # type: List[Tuple[str, str, str, str]]
|
|
|
|
def __init__(
|
|
self, val_a: str, val_b: str, val_n: str, case_description: str = ""
|
|
):
|
|
self.case_description = case_description
|
|
self.arg_a = val_a
|
|
self.int_a = bignum_common.hex_to_int(val_a)
|
|
self.arg_b = val_b
|
|
self.int_b = bignum_common.hex_to_int(val_b)
|
|
self.arg_n = val_n
|
|
self.int_n = bignum_common.hex_to_int(val_n)
|
|
|
|
limbs_a4 = bignum_common.limbs_mpi(self.int_a, 32)
|
|
limbs_a8 = bignum_common.limbs_mpi(self.int_a, 64)
|
|
self.limbs_b4 = bignum_common.limbs_mpi(self.int_b, 32)
|
|
self.limbs_b8 = bignum_common.limbs_mpi(self.int_b, 64)
|
|
self.limbs_an4 = bignum_common.limbs_mpi(self.int_n, 32)
|
|
self.limbs_an8 = bignum_common.limbs_mpi(self.int_n, 64)
|
|
|
|
if limbs_a4 > self.limbs_an4 or limbs_a8 > self.limbs_an8:
|
|
raise Exception("Limbs of input A ({}) exceeds N ({})".format(
|
|
self.arg_a, self.arg_n
|
|
))
|
|
|
|
def arguments(self) -> List[str]:
|
|
return [
|
|
str(self.limbs_an4), str(self.limbs_b4),
|
|
str(self.limbs_an8), str(self.limbs_b8),
|
|
bignum_common.quote_str(self.arg_a),
|
|
bignum_common.quote_str(self.arg_b),
|
|
bignum_common.quote_str(self.arg_n)
|
|
] + self.result()
|
|
|
|
def description(self) -> str:
|
|
if self.case_description != "replay":
|
|
if not self.start_2_mpi4 and self.limbs_an4 > 1:
|
|
tmp = "(start of 2-MPI 4-byte bignums) "
|
|
self.__class__.start_2_mpi4 = True
|
|
elif not self.start_2_mpi8 and self.limbs_an8 > 1:
|
|
tmp = "(start of 2-MPI 8-byte bignums) "
|
|
self.__class__.start_2_mpi8 = True
|
|
else:
|
|
tmp = "(gen) "
|
|
self.case_description = tmp + self.case_description
|
|
return super().description()
|
|
|
|
def result(self) -> List[str]:
|
|
"""Get the result of the operation."""
|
|
r4 = bignum_common.bound_mpi_limbs(self.limbs_an4, 32)
|
|
i4 = bignum_common.invmod(r4, self.int_n)
|
|
x4 = self.int_a * self.int_b * i4
|
|
x4 = x4 % self.int_n
|
|
|
|
r8 = bignum_common.bound_mpi_limbs(self.limbs_an8, 64)
|
|
i8 = bignum_common.invmod(r8, self.int_n)
|
|
x8 = self.int_a * self.int_b * i8
|
|
x8 = x8 % self.int_n
|
|
return [
|
|
"\"{:x}\"".format(x4),
|
|
"\"{:x}\"".format(x8)
|
|
]
|
|
|
|
def set_limbs(
|
|
self, limbs_an4: int, limbs_b4: int, limbs_an8: int, limbs_b8: int
|
|
) -> None:
|
|
"""Set number of limbs for each input.
|
|
|
|
Replaces default values set during initialization.
|
|
"""
|
|
self.limbs_an4 = limbs_an4
|
|
self.limbs_b4 = limbs_b4
|
|
self.limbs_an8 = limbs_an8
|
|
self.limbs_b8 = limbs_b8
|
|
|
|
@classmethod
|
|
def generate_function_tests(cls) -> Iterator[test_case.TestCase]:
|
|
"""Generate replay and randomly generated test cases."""
|
|
# Test cases which replay captured invocations during unit test runs.
|
|
for limbs_an4, limbs_b4, limbs_an8, limbs_b8, a, b, n in cls.replay_test_cases:
|
|
cur_op = cls(a, b, n, case_description="replay")
|
|
cur_op.set_limbs(limbs_an4, limbs_b4, limbs_an8, limbs_b8)
|
|
yield cur_op.create_test_case()
|
|
# Random test cases can be generated using mpi_modmul_case_generate()
|
|
# Uses a mixture of primes and odd numbers as N, with four randomly
|
|
# generated cases for each N.
|
|
for a, b, n, description in cls.random_test_cases:
|
|
cur_op = cls(a, b, n, case_description=description)
|
|
yield cur_op.create_test_case()
|
|
|
|
|
|
def mpi_modmul_case_generate() -> None:
|
|
"""Generate valid inputs for montmul tests using moduli.
|
|
|
|
For each modulus, generates random values for A and B and simple descriptions
|
|
for the test case.
|
|
"""
|
|
moduli = [
|
|
("3", ""), ("7", ""), ("B", ""), ("29", ""), ("FF", ""),
|
|
("101", ""), ("38B", ""), ("8003", ""), ("10001", ""),
|
|
("7F7F7", ""), ("800009", ""), ("100002B", ""), ("37EEE9D", ""),
|
|
("8000000B", ""), ("8CD626B9", ""), ("10000000F", ""),
|
|
("174876E7E9", "is prime (dec) 99999999977"),
|
|
("8000000017", ""), ("864CB9076D", ""), ("F7F7F7F7F7", ""),
|
|
("1000000000F", ""), ("800000000005", ""), ("800795D9BA47", ""),
|
|
("1000000000015", ""), ("100000000000051", ""), ("ABCDEF0123456789", ""),
|
|
(
|
|
"25A55A46E5DA99C71C7",
|
|
"is the 3rd repunit prime (dec) 11111111111111111111111"
|
|
),
|
|
("314DC643FB763F2B8C0E2DE00879", "is (dec)99999999977^3"),
|
|
("47BF19662275FA2F6845C74942ED1D852E521", "is (dec) 99999999977^4"),
|
|
(
|
|
"97EDD86E4B5C4592C6D32064AC55C888A7245F07CA3CC455E07C931",
|
|
"is (dec) 99999999977^6"
|
|
),
|
|
(
|
|
"DD15FE80B731872AC104DB37832F7E75A244AA2631BC87885B861E8F20375499",
|
|
"is (dec) 99999999977^7"
|
|
),
|
|
(
|
|
"141B8EBD9009F84C241879A1F680FACCED355DA36C498F73E96E880CF78EA5F96146380E41",
|
|
"is (dec) 99999999977^8"
|
|
),
|
|
(
|
|
(
|
|
"2A94608DE88B6D5E9F8920F5ABB06B24CC35AE1FBACC87D075C621C3E283"
|
|
"3EC902713E40F51E3B3C214EDFABC451"
|
|
),
|
|
"is (dec) 99999999977^10"
|
|
),
|
|
(
|
|
"8335616AED761F1F7F44E6BD49E807B82E3BF2BF11BFA6AF813C808DBF33DBFA11"
|
|
"DABD6E6144BEF37C6800000000000000000000000000000000051",
|
|
"is prime, (dec) 10^143 + 3^4"
|
|
)
|
|
] # type: List[Tuple[str, str]]
|
|
primes = [
|
|
"3", "7", "B", "29", "101", "38B", "8003", "10001", "800009",
|
|
"100002B", "37EEE9D", "8000000B", "8CD626B9",
|
|
# From here they require > 1 4-byte MPI
|
|
"10000000F", "174876E7E9", "8000000017", "864CB9076D", "1000000000F",
|
|
"800000000005", "800795D9BA47", "1000000000015", "100000000000051",
|
|
# From here they require > 1 8-byte MPI
|
|
"25A55A46E5DA99C71C7", # this is 11111111111111111111111 decimal
|
|
# 10^143 + 3^4: (which is prime)
|
|
# 100000000000000000000000000000000000000000000000000000000000000000000000000000
|
|
# 000000000000000000000000000000000000000000000000000000000000000081
|
|
(
|
|
"8335616AED761F1F7F44E6BD49E807B82E3BF2BF11BFA6AF813C808DBF33DBFA11"
|
|
"DABD6E6144BEF37C6800000000000000000000000000000000051"
|
|
)
|
|
] # type: List[str]
|
|
generated_inputs = []
|
|
for mod, description in moduli:
|
|
n = bignum_common.hex_to_int(mod)
|
|
mod_read = "{:x}".format(n)
|
|
case_count = 3 if n < 5 else 4
|
|
cases = {} # type: Dict[int, int]
|
|
i = 0
|
|
while i < case_count:
|
|
a = random.randint(1, n)
|
|
b = random.randint(1, n)
|
|
if cases.get(a) == b:
|
|
continue
|
|
cases[a] = b
|
|
if description:
|
|
out_description = "0x{} {}".format(mod_read, description)
|
|
elif i == 0 and len(mod) > 1 and mod in primes:
|
|
out_description = "(0x{} is prime)"
|
|
else:
|
|
out_description = ""
|
|
generated_inputs.append(
|
|
("{:x}".format(a), "{:x}".format(b), mod, out_description)
|
|
)
|
|
i += 1
|
|
print(generated_inputs)
|
|
|
|
# BEGIN MERGE SLOT 1
|
|
|
|
class BignumCoreExpMod(BignumCoreTarget, bignum_common.ModOperationCommon):
|
|
"""Test cases for bignum core exponentiation."""
|
|
symbol = "^"
|
|
test_function = "mpi_core_exp_mod"
|
|
test_name = "Core modular exponentiation (Mongtomery form only)"
|
|
input_style = "fixed"
|
|
montgomery_form_a = True
|
|
|
|
def result(self) -> List[str]:
|
|
# Result has to be given in Montgomery form too
|
|
result = pow(self.int_a, self.int_b, self.int_n)
|
|
mont_result = self.to_montgomery(result)
|
|
return [self.format_result(mont_result)]
|
|
|
|
@property
|
|
def is_valid(self) -> bool:
|
|
# The base needs to be canonical, but the exponent can be larger than
|
|
# 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."""
|
|
count = 0
|
|
symbol = "-"
|
|
test_function = "mpi_core_sub_int"
|
|
test_name = "mpi_core_sub_int"
|
|
input_style = "arch_split"
|
|
|
|
@property
|
|
def is_valid(self) -> bool:
|
|
# This is "sub int", so b is only one limb
|
|
if bignum_common.limbs_mpi(self.int_b, self.bits_in_limb) > 1:
|
|
return False
|
|
return True
|
|
|
|
# Overriding because we don't want leading zeros on b
|
|
@property
|
|
def arg_b(self) -> str:
|
|
return self.val_b
|
|
|
|
def result(self) -> List[str]:
|
|
result = self.int_a - self.int_b
|
|
|
|
borrow, result = divmod(result, self.limb_boundary)
|
|
|
|
# Borrow will be -1 if non-zero, but we want it to be 1 in the test data
|
|
return [
|
|
self.format_result(result),
|
|
str(-borrow)
|
|
]
|
|
|
|
class BignumCoreZeroCheckCT(BignumCoreTarget, bignum_common.OperationCommon):
|
|
"""Test cases for bignum core zero check (constant flow)."""
|
|
count = 0
|
|
symbol = "== 0"
|
|
test_function = "mpi_core_check_zero_ct"
|
|
test_name = "mpi_core_check_zero_ct"
|
|
input_style = "variable"
|
|
arity = 1
|
|
suffix = True
|
|
|
|
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
|