def test_assumption(self):
with self.assertRaises(UnsatisfiedAssumptionError):
get_params("secg", "secp128r1", "projective-1")
with TemporaryConfig() as cfg:
cfg.ec.unsatisfied_coordinate_assumption_action = "ignore"
params = get_params("secg", "secp128r1", "projective-1")
self.assertIsNotNone(params)
self.assertIsNotNone(get_params("secg", "secp128r1", "projective-3"))
def setUp(self):
self.secp128r1 = get_params("secg", "secp128r1", "projective")
self.base = self.secp128r1.generator
self.coords = self.secp128r1.curve.coordinate_model
self.curve25519 = get_params("other", "Curve25519", "xz")
self.base25519 = self.curve25519.generator
self.coords25519 = self.curve25519.curve.coordinate_model
def setUp(self):
self.secp128r1 = get_params("secg", "secp128r1", "projective")
self.add = self.secp128r1.curve.coordinate_model.formulas[
"add-2007-bl"]
self.dbl = self.secp128r1.curve.coordinate_model.formulas[
"dbl-2007-bl"]
self.mdbl = self.secp128r1.curve.coordinate_model.formulas[
"mdbl-2007-bl"]
self.jac_secp128r1 = get_params("secg", "secp128r1", "jacobian")
self.jac_dbl = self.jac_secp128r1.curve.coordinate_model.formulas[
"dbl-1998-hnm"]
def setUpClass(cls):
if not has_pyscard:
return
from smartcard.System import readers
try:
rs = readers()
except BaseSCardException:
return
if not rs:
return
cls.reader = rs[0]
cls.secp256r1 = get_params("secg", "secp256r1", "affine")
cls.secp256r1_projective = get_params("secg", "secp256r1", "projective")
def setUp(self):
self.secp128r1 = get_params("secg", "secp128r1", "projective")
self.add = self.secp128r1.curve.coordinate_model.formulas[
"add-2007-bl"]
self.dbl = self.secp128r1.curve.coordinate_model.formulas[
"dbl-2007-bl"]
self.mult = LTRMultiplier(self.add, self.dbl)
def get_curve(ctx: click.Context, param, value: Optional[str]) -> DomainParameters:
if value is None:
return None
ctx.ensure_object(dict)
category, name = value.split("/")
curve = get_params(category, name, ctx.obj["coords"].name)
ctx.obj["params"] = curve
return curve
def setUp(self):
self.secp128r1 = get_params("secg", "secp128r1", "projective")
self.base = self.secp128r1.generator
self.coords = self.secp128r1.curve.coordinate_model
self.add = self.coords.formulas["add-1998-cmo"]
self.dbl = self.coords.formulas["dbl-1998-cmo"]
self.neg = self.coords.formulas["neg"]
self.scale = self.coords.formulas["z"]
def setUp(self):
self.secp128r1 = get_params("secg", "secp128r1", "projective")
self.base = self.secp128r1.generator
self.coords = self.secp128r1.curve.coordinate_model
self.mult = LTRMultiplier(self.coords.formulas["add-1998-cmo"],
self.coords.formulas["dbl-1998-cmo"],
self.coords.formulas["z"],
always=True)
self.mult.init(self.secp128r1, self.base)
def test_shortweierstrass(self):
secp128r2 = get_params("secg", "secp128r2", "affine")
m = SW2M(secp128r2)
self.assertIsNotNone(m)
self.assertTrue(m.curve.is_on_curve(m.generator))
self.assertTrue(m.curve.is_neutral(m.curve.neutral))
te = SW2TE(secp128r2)
self.assertIsNotNone(te)
self.assertTrue(te.curve.is_on_curve(te.generator))
self.assertTrue(te.curve.is_neutral(te.curve.neutral))
def test_montgomery(self):
curve25519 = get_params("other", "Curve25519", "affine")
sw = M2SW(curve25519)
self.assertIsNotNone(sw)
self.assertTrue(sw.curve.is_on_curve(sw.generator))
self.assertTrue(sw.curve.is_neutral(sw.curve.neutral))
te = M2TE(curve25519)
self.assertIsNotNone(te)
self.assertTrue(te.curve.is_on_curve(te.generator))
self.assertTrue(te.curve.is_neutral(te.curve.neutral))
def setUp(self):
self.secp128r1 = get_params("secg", "secp128r1", "projective")
self.add = self.secp128r1.curve.coordinate_model.formulas[
"add-2007-bl"]
self.dbl = self.secp128r1.curve.coordinate_model.formulas[
"dbl-2007-bl"]
self.mult = LTRMultiplier(self.add, self.dbl)
self.msg = 0xCAFEBABE.to_bytes(4, byteorder="big")
self.priv = Mod(0xDEADBEEF, self.secp128r1.order)
self.mult.init(self.secp128r1, self.secp128r1.generator)
self.pub = self.mult.multiply(self.priv.x)
def setUp(self):
self.secp128r1 = get_params("secg", "secp128r1", "projective")
self.add = self.secp128r1.curve.coordinate_model.formulas[
"add-2007-bl"]
self.dbl = self.secp128r1.curve.coordinate_model.formulas[
"dbl-2007-bl"]
self.mult = LTRMultiplier(self.add, self.dbl)
self.priv_a = Mod(0xDEADBEEF, self.secp128r1.order)
self.mult.init(self.secp128r1, self.secp128r1.generator)
self.pub_a = self.mult.multiply(int(self.priv_a))
self.priv_b = Mod(0xCAFEBABE, self.secp128r1.order)
self.pub_b = self.mult.multiply(int(self.priv_b))
def main(profiler, mod, operations, directory):
with TemporaryConfig() as cfg:
cfg.ec.mod_implementation = mod
p256 = get_params("secg", "secp256r1", "projective")
coords = p256.curve.coordinate_model
add = coords.formulas["add-2016-rcb"]
dbl = coords.formulas["dbl-2016-rcb"]
click.echo(
f"Profiling {operations} {p256.curve.prime.bit_length()}-bit doubling formula executions..."
)
one_point = p256.generator
with Profiler(profiler, directory,
f"formula_dbl2016rcb_p256_{operations}_{mod}"):
for _ in range(operations):
one_point = dbl(p256.curve.prime, one_point,
**p256.curve.parameters)[0]
click.echo(
f"Profiling {operations} {p256.curve.prime.bit_length()}-bit addition formula executions..."
)
other_point = p256.generator
with Profiler(profiler, directory,
f"formula_add2016rcb_p256_{operations}_{mod}"):
for _ in range(operations):
one_point = add(p256.curve.prime, one_point, other_point,
**p256.curve.parameters)[0]
ed25519 = get_params("other", "Ed25519", "extended")
ecoords = ed25519.curve.coordinate_model
dblg = ecoords.formulas["mdbl-2008-hwcd"]
click.echo(
f"Profiling {operations} {ed25519.curve.prime.bit_length()}-bit doubling formula executions (with assumption)..."
)
eone_point = ed25519.generator
with Profiler(profiler, directory,
f"formula_mdbl2008hwcd_ed25519_{operations}_{mod}"):
for _ in range(operations):
dblg(ed25519.curve.prime, eone_point,
**ed25519.curve.parameters)
def main(profiler, mod, operations, directory):
with TemporaryConfig() as cfg:
cfg.ec.mod_implementation = mod
p256 = get_params("secg", "secp256r1", "projective")
coords = p256.curve.coordinate_model
add = coords.formulas["add-2016-rcb"]
dbl = coords.formulas["dbl-2016-rcb"]
mult = LTRMultiplier(add, dbl)
click.echo(
f"Profiling {operations} {p256.curve.prime.bit_length()}-bit scalar multiplication executions..."
)
one_point = p256.generator
with Profiler(profiler, directory,
f"mult_ltr_rcb_p256_{operations}_{mod}"):
for _ in range(operations):
mult.init(p256, one_point)
one_point = mult.multiply(
0x71A55E0C1ABB3A0E069419E0F837BC195F1B9545E69FC51E53C4D48D7FEA3B1A
)
def test_ladder(self):
curve25519 = get_params("other", "Curve25519", "xz")
base = curve25519.generator
coords = curve25519.curve.coordinate_model
ladd = coords.formulas["ladd-1987-m"]
dadd = coords.formulas["dadd-1987-m"]
dbl = coords.formulas["dbl-1987-m"]
scale = coords.formulas["scale"]
ladd_mult = LadderMultiplier(ladd, dbl, scale)
with local(MultipleContext()) as ctx:
ladd_mult.init(curve25519, base)
ladd_mult.multiply(1339278426732672313)
muls = list(ctx.points.values())
self.assertEqual(muls[-2], 1339278426732672313)
dadd_mult = DifferentialLadderMultiplier(dadd, dbl, scale)
with local(MultipleContext()) as ctx:
dadd_mult.init(curve25519, base)
dadd_mult.multiply(1339278426732672313)
muls = list(ctx.points.values())
self.assertEqual(muls[-2], 1339278426732672313)
def test_basic_build(self):
platform = Platform.HOST
hash_type = HashType.SHA1
mod_rand = RandomMod.REDUCE
mult = Multiplication.BASE
sqr = Squaring.BASE
red = Reduction.BASE
inv = Inversion.GCD
params = get_params("secg", "secp128r1", "projective")
model = params.curve.model
coords = params.curve.coordinate_model
add = coords.formulas["add-1998-cmo"]
dbl = coords.formulas["dbl-1998-cmo"]
scl = coords.formulas["z"]
formulas = [add, dbl, scl]
scalarmult = LTRMultiplier(add, dbl, scl)
config = DeviceConfiguration(model, coords, formulas, scalarmult,
hash_type, mod_rand, mult, sqr, red, inv,
platform, True, True, True)
temp = tempfile.mkdtemp()
render_and_build(config, temp, True)
def setUp(self):
self.secp128r1 = get_params("secg", "secp128r1", "projective")
self.curve25519 = get_params("other", "Curve25519", "xz")
def test_unknown(self, name, coords):
with self.assertRaises(ValueError):
get_params(*name.split("/"), coords)
def setUp(self):
self.secp128r1 = get_params("secg", "secp128r1", "projective")
self.base = self.secp128r1.generator
self.affine_base = self.base.to_affine()
self.curve25519 = get_params("other", "Curve25519", "xz")
self.ed25519 = get_params("other", "Ed25519", "projective")
def setUp(self):
self.secp128r1 = get_params("secg", "secp128r1", "projective")
self.base = self.secp128r1.generator
self.coords = self.secp128r1.curve.coordinate_model
self.affine = AffineCoordinateModel(ShortWeierstrassModel())
def test_infty(self):
with self.assertRaises(ValueError):
get_params("other", "Ed25519", "modified", False)
self.assertIsNotNone(
get_params("secg", "secp128r1", "projective", False))
def test_no_binary(self):
with self.assertRaises(ValueError):
get_params("secg", "sect163r1", "something")
def test_no_extension(self):
with self.assertRaises(ValueError):
get_params("other", "Fp254n2BNa", "something")
def test_twistededwards(self):
ed25519 = get_params("other", "Ed25519", "affine")
m = TE2M(ed25519)
self.assertIsNotNone(m)
self.assertTrue(m.curve.is_on_curve(m.generator))
self.assertTrue(m.curve.is_neutral(m.curve.neutral))
def test_affine(self):
aff = get_params("secg", "secp128r1", "affine")
self.assertIsInstance(aff.curve.coordinate_model,
AffineCoordinateModel)
def setUp(self):
self.curve = get_params("secg", "secp128r1", "projective")
self.model = self.curve.curve.model
self.coords = self.curve.curve.coordinate_model
def test_get_params(self, name, coords):
params = get_params(*name.split("/"), coords)
try:
assert params.curve.is_on_curve(params.generator)
except NotImplementedError:
pass
