mbedtls/scripts/mbedtls_dev/bignum_core.py

"""Framework classes for generation of bignum core test cases."""
# Copyright The Mbed TLS Contributors
# SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
#

import random

from typing import Dict, Iterator, List, Tuple

from . import test_case
from . import test_data_generation
from . import bignum_common
from .bignum_data import ADD_SUB_DATA

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 BignumCoreShiftL(BignumCoreTarget, bignum_common.ModOperationCommon):
    """Test cases for mbedtls_bignum_core_shift_l()."""

    BIT_SHIFT_VALUES = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a',
                        '1f', '20', '21', '3f', '40', '41', '47', '48', '4f',
                        '50', '51', '58', '80', '81', '88']
    DATA = ["0", "1", "40", "dee5ca1a7ef10a75", "a1055eb0bb1efa1150ff",
            "002e7ab0070ad57001", "020100000000000000001011121314151617",
            "1946e2958a85d8863ae21f4904fcc49478412534ed53eaf321f63f2a222"
            "7a3c63acbf50b6305595f90cfa8327f6db80d986fe96080bcbb5df1bdbe"
            "9b74fb8dedf2bddb3f8215b54dffd66409323bcc473e45a8fe9d08e77a51"
            "1698b5dad0416305db7fcf"]
    arity = 1
    test_function = "mpi_core_shift_l"
    test_name = "Core shift(L)"
    input_style = "arch_split"
    symbol = "<<"
    input_values = BIT_SHIFT_VALUES
    moduli = DATA

    @property
    def val_n_max_limbs(self) -> int:
        """ Return the limb count required to store the maximum number that can
        fit in a the number of digits used by val_n """
        m = bignum_common.hex_digits_max_int(self.val_n, self.bits_in_limb) - 1
        return bignum_common.limbs_mpi(m, self.bits_in_limb)

    def arguments(self) -> List[str]:
        return [bignum_common.quote_str(self.val_n),
                str(self.int_a)
                ] + self.result()

    def description(self) -> str:
        """ Format the output as:
        #{count} {hex input} ({input bits} {limbs capacity}) << {bit shift} """
        bits = "({} bits in {} limbs)".format(self.int_n.bit_length(), self.val_n_max_limbs)
        return "{} #{} {} {} {} {}".format(self.test_name,
                                           self.count,
                                           self.val_n,
                                           bits,
                                           self.symbol,
                                           self.int_a)

    def format_result(self, res: int) -> str:
        # Override to match zero-pading for leading digits between the output and input.
        res_str = bignum_common.zfill_match(self.val_n, "{:x}".format(res))
        return bignum_common.quote_str(res_str)

    def result(self) -> List[str]:
        result = (self.int_n << self.int_a)
        # Calculate if there is space for shifting to the left(leading zero limbs)
        mx = bignum_common.hex_digits_max_int(self.val_n, self.bits_in_limb)
        # If there are empty limbs ahead, adjust the bitmask accordingly
        result = result & (mx - 1)
        return [self.format_result(result)]

    @property
    def is_valid(self) -> bool:
        return True


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"
    input_values = ADD_SUB_DATA
    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"
    input_values = ADD_SUB_DATA

    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 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
    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)


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)


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)]