def test_init_xy(self):
EccPoint(self.Gxy['x'], self.Gxy['y'], curve="Ed25519")
# Neutral point
pai = EccPoint(0, 1, curve="Ed25519")
self.assertEqual(pai.x, 0)
self.assertEqual(pai.y, 1)
self.assertEqual(pai.xy, (0, 1))
# G
bp = self.pointG.copy()
self.assertEqual(bp.x, 15112221349535400772501151409588531511454012693041857206046113283949847762202)
self.assertEqual(bp.y, 46316835694926478169428394003475163141307993866256225615783033603165251855960)
self.assertEqual(bp.xy, (bp.x, bp.y))
# 2G
bp2 = self.pointG2.copy()
self.assertEqual(bp2.x, 24727413235106541002554574571675588834622768167397638456726423682521233608206)
self.assertEqual(bp2.y, 15549675580280190176352668710449542251549572066445060580507079593062643049417)
self.assertEqual(bp2.xy, (bp2.x, bp2.y))
# 5G
EccPoint(x=33467004535436536005251147249499675200073690106659565782908757308821616914995,
y=43097193783671926753355113395909008640284023746042808659097434958891230611693,
curve="Ed25519")
# Catch if point is not on the curve
self.assertRaises(ValueError, EccPoint, 34, 35, curve="Ed25519")
def test_public_key(self):
point = EccPoint(_curves['ed448'].Gx,
_curves['ed448'].Gy,
curve='ed448')
key = EccKey(curve="ed448", point=point)
self.assertFalse(key.has_private())
self.assertEqual(key.pointQ, point)
def test_inplace_addition(self):
pointRx = 0x72b13dd4354b6b81745195e98cc5ba6970349191ac476bd4553cf35a545a067e
pointRy = 0x8d585cbb2e1327d75241a8a122d7620dc33b13315aa5c9d46d013011744ac264
pointR = self.pointS.copy()
pointR += self.pointT
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
pai = EccPoint.point_at_infinity()
# S + 0
pointR = self.pointS.copy()
pointR += pai
self.assertEqual(pointR, self.pointS)
# 0 + S
pointR = pai.copy()
pointR += self.pointS
self.assertEqual(pointR, self.pointS)
# 0 + 0
pointR = pai.copy()
pointR += pai
self.assertEqual(pointR, pai)
def test_public_key(self):
p384 = _curves['p384']
point = EccPoint(p384.Gx, p384.Gy, 'p384')
key = EccKey(curve="P-384", point=point)
self.assertFalse(key.has_private())
self.assertEqual(key.pointQ, point)
def test_private_key(self):
seed = unhexlify(
"4adf5d37ac6785e83e99a924f92676d366a78690af59c92b6bdf14f9cdbcf26fdad478109607583d633b60078d61d51d81b7509c5433b0d4c9"
)
Px = 0x72a01eea003a35f9ac44231dc4aae2a382f351d80bf32508175b0855edcf389aa2bbf308dd961ce361a6e7c2091bc78957f6ebcf3002a617
Py = 0x9e0d08d84586e9aeefecacb41d049b831f1a3ee0c3eada63e34557b30702b50ab59fb372feff7c30b8cbb7dd51afbe88444ec56238722ec1
key = EccKey(curve="Ed448", seed=seed)
self.assertEqual(key.seed, seed)
self.assertEqual(
key.d,
0xb07cf179604f83433186e5178760c759c15125ee54ff6f8dcde46e872b709ac82ed0bd0a4e036d774034dcb18a9fb11894657a1485895f80
)
self.assertTrue(key.has_private())
self.assertEqual(key.pointQ.x, Px)
self.assertEqual(key.pointQ.y, Py)
point = EccPoint(Px, Py, "ed448")
key = EccKey(curve="Ed448", seed=seed, point=point)
self.assertEqual(
key.d,
0xb07cf179604f83433186e5178760c759c15125ee54ff6f8dcde46e872b709ac82ed0bd0a4e036d774034dcb18a9fb11894657a1485895f80
)
self.assertTrue(key.has_private())
self.assertEqual(key.pointQ, point)
# Other names
key = EccKey(curve="ed448", seed=seed)
# Must not accept d parameter
self.assertRaises(ValueError, EccKey, curve="ed448", d=1)
def test_inplace_addition(self):
pointRx = 0x72b13dd4354b6b81745195e98cc5ba6970349191ac476bd4553cf35a545a067e
pointRy = 0x8d585cbb2e1327d75241a8a122d7620dc33b13315aa5c9d46d013011744ac264
pointR = self.pointS.copy()
pointR += self.pointT
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
pai = EccPoint.point_at_infinity()
# S + 0
pointR = self.pointS.copy()
pointR += pai
self.assertEqual(pointR, self.pointS)
# 0 + S
pointR = pai.copy()
pointR += self.pointS
self.assertEqual(pointR, self.pointS)
# 0 + 0
pointR = pai.copy()
pointR += pai
self.assertEqual(pointR, pai)
def test_public_key(self):
p521 = _curves['p521']
point = EccPoint(p521.Gx, p521.Gy, 'p521')
key = EccKey(curve="P-384", point=point)
self.failIf(key.has_private())
self.assertEqual(key.pointQ, point)
def test_construct(self):
seed = unhexlify(
"4adf5d37ac6785e83e99a924f92676d366a78690af59c92b6bdf14f9cdbcf26fdad478109607583d633b60078d61d51d81b7509c5433b0d4c9"
)
Px = 0x72a01eea003a35f9ac44231dc4aae2a382f351d80bf32508175b0855edcf389aa2bbf308dd961ce361a6e7c2091bc78957f6ebcf3002a617
Py = 0x9e0d08d84586e9aeefecacb41d049b831f1a3ee0c3eada63e34557b30702b50ab59fb372feff7c30b8cbb7dd51afbe88444ec56238722ec1
d = 0xb07cf179604f83433186e5178760c759c15125ee54ff6f8dcde46e872b709ac82ed0bd0a4e036d774034dcb18a9fb11894657a1485895f80
point = EccPoint(Px, Py, curve="Ed448")
# Private key only
key = ECC.construct(curve="Ed448", seed=seed)
self.assertEqual(key.pointQ, point)
self.assertTrue(key.has_private())
# Public key only
key = ECC.construct(curve="Ed448", point_x=Px, point_y=Py)
self.assertEqual(key.pointQ, point)
self.assertFalse(key.has_private())
# Private and public key
key = ECC.construct(curve="Ed448", seed=seed, point_x=Px, point_y=Py)
self.assertEqual(key.pointQ, point)
self.assertTrue(key.has_private())
# Other names
key = ECC.construct(curve="ed448", seed=seed)
def test_generate(self):
key = ECC.generate(curve="P-256")
self.failUnless(key.has_private())
self.assertEqual(key.pointQ, EccPoint(_curve.Gx, _curve.Gy) * key.d)
# Other names
ECC.generate(curve="secp256r1")
ECC.generate(curve="prime256v1")
def test_generate(self):
curve = _curves['p521']
key = ECC.generate(curve="P-521")
self.assertTrue(key.has_private())
self.assertEqual(key.pointQ, EccPoint(curve.Gx, curve.Gy, "p521") * key.d)
# Other names
ECC.generate(curve="secp521r1")
ECC.generate(curve="prime521v1")
def test_generate(self):
curve = _curves['p384']
key = ECC.generate(curve="P-384")
self.failUnless(key.has_private())
self.assertEqual(key.pointQ, EccPoint(curve.Gx, curve.Gy, "p384") * key.d)
# Other names
ECC.generate(curve="secp384r1")
ECC.generate(curve="prime384v1")
def test_init_xy(self):
EccPoint(self.Gxy['x'], self.Gxy['y'], curve="Ed448")
# Neutral point
pai = EccPoint(0, 1, curve="Ed448")
self.assertEqual(pai.x, 0)
self.assertEqual(pai.y, 1)
self.assertEqual(pai.xy, (0, 1))
# G
bp = self.pointG.copy()
self.assertEqual(
bp.x,
0x4f1970c66bed0ded221d15a622bf36da9e146570470f1767ea6de324a3d3a46412ae1af72ab66511433b80e18b00938e2626a82bc70cc05e
)
self.assertEqual(
bp.y,
0x693f46716eb6bc248876203756c9c7624bea73736ca3984087789c1e05a0c2d73ad3ff1ce67c39c4fdbd132c4ed7c8ad9808795bf230fa14
)
self.assertEqual(bp.xy, (bp.x, bp.y))
# 2G
bp2 = self.pointG2.copy()
self.assertEqual(
bp2.x,
0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa955555555555555555555555555555555555555555555555555555555
)
self.assertEqual(
bp2.y,
0xae05e9634ad7048db359d6205086c2b0036ed7a035884dd7b7e36d728ad8c4b80d6565833a2a3098bbbcb2bed1cda06bdaeafbcdea9386ed
)
self.assertEqual(bp2.xy, (bp2.x, bp2.y))
# 5G
EccPoint(
x=
0x7a9f9335a48dcb0e2ba7601eedb50def80cbcf728562ada756d761e8958812808bc0d57a920c3c96f07b2d8cefc6f950d0a99d1092030034,
y=
0xadfd751a2517edd3b9109ce4fd580ade260ca1823ab18fced86551f7b698017127d7a4ee59d2b33c58405512881f225443b4731472f435eb,
curve="Ed448")
# Catch if point is not on the curve
self.assertRaises(ValueError, EccPoint, 34, 35, curve="Ed448")
def test_generate(self):
key = ECC.generate(curve="P-256")
self.assertTrue(key.has_private())
self.assertEqual(key.pointQ, EccPoint(_curves['p256'].Gx,
_curves['p256'].Gy) * key.d,
"p256")
# Other names
ECC.generate(curve="secp256r1")
ECC.generate(curve="prime256v1")
def test_generate(self):
key = ECC.generate(curve="P-192")
self.assertTrue(key.has_private())
self.assertEqual(
key.pointQ,
EccPoint(_curves['p192'].Gx, _curves['p192'].Gy, "P-192") * key.d,
"p192")
# Other names
ECC.generate(curve="secp192r1")
ECC.generate(curve="prime192v1")
def test_private_key(self):
key = EccKey(curve="P-256", d=1)
self.assertEqual(key.d, 1)
self.failUnless(key.has_private())
self.assertEqual(key.pointQ.x, _curves['p256'].Gx)
self.assertEqual(key.pointQ.y, _curves['p256'].Gy)
point = EccPoint(_curves['p256'].Gx, _curves['p256'].Gy)
key = EccKey(curve="P-256", d=1, point=point)
self.assertEqual(key.d, 1)
self.failUnless(key.has_private())
self.assertEqual(key.pointQ, point)
# Other names
key = EccKey(curve="secp256r1", d=1)
key = EccKey(curve="prime256v1", d=1)
def test_private_key(self):
key = EccKey(curve="P-224", d=1)
self.assertEqual(key.d, 1)
self.assertTrue(key.has_private())
self.assertEqual(key.pointQ.x, _curves['p224'].Gx)
self.assertEqual(key.pointQ.y, _curves['p224'].Gy)
point = EccPoint(_curves['p224'].Gx, _curves['p224'].Gy, curve='P-224')
key = EccKey(curve="P-224", d=1, point=point)
self.assertEqual(key.d, 1)
self.assertTrue(key.has_private())
self.assertEqual(key.pointQ, point)
# Other names
key = EccKey(curve="secp224r1", d=1)
key = EccKey(curve="prime224v1", d=1)
def test_generate(self):
key = ECC.generate(curve="Ed25519")
self.assertTrue(key.has_private())
point = EccPoint(_curves['Ed25519'].Gx, _curves['Ed25519'].Gy, curve="Ed25519") * key.d
self.assertEqual(key.pointQ, point)
# Always random
key2 = ECC.generate(curve="Ed25519")
self.assertNotEqual(key, key2)
# Other names
ECC.generate(curve="Ed25519")
# Random source
key1 = ECC.generate(curve="Ed25519", randfunc=SHAKE128.new().read)
key2 = ECC.generate(curve="Ed25519", randfunc=SHAKE128.new().read)
self.assertEqual(key1, key2)
def test_private_key(self):
p384 = _curves['p384']
key = EccKey(curve="P-384", d=1)
self.assertEqual(key.d, 1)
self.failUnless(key.has_private())
self.assertEqual(key.pointQ.x, p384.Gx)
self.assertEqual(key.pointQ.y, p384.Gy)
point = EccPoint(p384.Gx, p384.Gy, "p384")
key = EccKey(curve="P-384", d=1, point=point)
self.assertEqual(key.d, 1)
self.failUnless(key.has_private())
self.assertEqual(key.pointQ, point)
# Other names
key = EccKey(curve="p384", d=1)
key = EccKey(curve="secp384r1", d=1)
key = EccKey(curve="prime384v1", d=1)
def test_private_key(self):
p521 = _curves['p521']
key = EccKey(curve="P-521", d=1)
self.assertEqual(key.d, 1)
self.failUnless(key.has_private())
self.assertEqual(key.pointQ.x, p521.Gx)
self.assertEqual(key.pointQ.y, p521.Gy)
point = EccPoint(p521.Gx, p521.Gy, "p521")
key = EccKey(curve="P-521", d=1, point=point)
self.assertEqual(key.d, 1)
self.failUnless(key.has_private())
self.assertEqual(key.pointQ, point)
# Other names
key = EccKey(curve="p521", d=1)
key = EccKey(curve="secp521r1", d=1)
key = EccKey(curve="prime521v1", d=1)
def test_private_key(self):
key = EccKey(curve="P-256", d=1)
self.assertEqual(key.d, 1)
self.assertTrue(key.has_private())
self.assertEqual(key.pointQ.x, _curves['p256'].Gx)
self.assertEqual(key.pointQ.y, _curves['p256'].Gy)
point = EccPoint(_curves['p256'].Gx, _curves['p256'].Gy)
key = EccKey(curve="P-256", d=1, point=point)
self.assertEqual(key.d, 1)
self.assertTrue(key.has_private())
self.assertEqual(key.pointQ, point)
# Other names
key = EccKey(curve="secp256r1", d=1)
key = EccKey(curve="prime256v1", d=1)
# Must not accept d parameter
self.assertRaises(ValueError, EccKey, curve="p256", seed=b'H' * 32)
def test_private_key(self):
seed = unhexlify("9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60")
Px = 38815646466658113194383306759739515082307681141926459231621296960732224964046
Py = 11903303657706407974989296177215005343713679411332034699907763981919547054807
key = EccKey(curve="Ed25519", seed=seed)
self.assertEqual(key.seed, seed)
self.assertEqual(key.d, 36144925721603087658594284515452164870581325872720374094707712194495455132720)
self.assertTrue(key.has_private())
self.assertEqual(key.pointQ.x, Px)
self.assertEqual(key.pointQ.y, Py)
point = EccPoint(Px, Py, "ed25519")
key = EccKey(curve="Ed25519", seed=seed, point=point)
self.assertEqual(key.d, 36144925721603087658594284515452164870581325872720374094707712194495455132720)
self.assertTrue(key.has_private())
self.assertEqual(key.pointQ, point)
# Other names
key = EccKey(curve="ed25519", seed=seed)
# Must not accept d parameter
self.assertRaises(ValueError, EccKey, curve="ed25519", d=1)
def test_construct(self):
seed = unhexlify("9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60")
Px = 38815646466658113194383306759739515082307681141926459231621296960732224964046
Py = 11903303657706407974989296177215005343713679411332034699907763981919547054807
d = 36144925721603087658594284515452164870581325872720374094707712194495455132720
point = EccPoint(Px, Py, curve="Ed25519")
# Private key only
key = ECC.construct(curve="Ed25519", seed=seed)
self.assertEqual(key.pointQ, point)
self.assertTrue(key.has_private())
# Public key only
key = ECC.construct(curve="Ed25519", point_x=Px, point_y=Py)
self.assertEqual(key.pointQ, point)
self.assertFalse(key.has_private())
# Private and public key
key = ECC.construct(curve="Ed25519", seed=seed, point_x=Px, point_y=Py)
self.assertEqual(key.pointQ, point)
self.assertTrue(key.has_private())
# Other names
key = ECC.construct(curve="ed25519", seed=seed)
def test_set(self):
pointW = EccPoint(0, 0)
pointW.set(self.pointS)
self.assertEqual(pointW, self.pointS)
def test_pai(self):
pai = EccPoint(0, 1, curve="Ed448")
self.failUnless(pai.is_point_at_infinity())
self.assertEqual(pai, pai.point_at_infinity())
class TestEccPoint_NIST(unittest.TestCase):
"""Tests defined in section 4.3 of https://www.nsa.gov/ia/_files/nist-routines.pdf"""
pointS = EccPoint(
0xde2444bebc8d36e682edd27e0f271508617519b3221a8fa0b77cab3989da97c9,
0xc093ae7ff36e5380fc01a5aad1e66659702de80f53cec576b6350b243042a256)
pointT = EccPoint(
0x55a8b00f8da1d44e62f6b3b25316212e39540dc861c89575bb8cf92e35e0986b,
0x5421c3209c2d6c704835d82ac4c3dd90f61a8a52598b9e7ab656e9d8c8b24316)
def test_set(self):
pointW = EccPoint(0, 0)
pointW.set(self.pointS)
self.assertEqual(pointW, self.pointS)
def test_copy(self):
pointW = self.pointS.copy()
self.assertEqual(pointW, self.pointS)
pointW.set(self.pointT)
self.assertEqual(pointW, self.pointT)
self.assertNotEqual(self.pointS, self.pointT)
def test_addition(self):
pointRx = 0x72b13dd4354b6b81745195e98cc5ba6970349191ac476bd4553cf35a545a067e
pointRy = 0x8d585cbb2e1327d75241a8a122d7620dc33b13315aa5c9d46d013011744ac264
pointR = self.pointS + self.pointT
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
pai = EccPoint.point_at_infinity()
# S + 0
pointR = self.pointS + pai
self.assertEqual(pointR, self.pointS)
# 0 + S
pointR = pai + self.pointS
self.assertEqual(pointR, self.pointS)
# 0 + 0
pointR = pai + pai
self.assertEqual(pointR, pai)
def test_inplace_addition(self):
pointRx = 0x72b13dd4354b6b81745195e98cc5ba6970349191ac476bd4553cf35a545a067e
pointRy = 0x8d585cbb2e1327d75241a8a122d7620dc33b13315aa5c9d46d013011744ac264
pointR = self.pointS.copy()
pointR += self.pointT
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
pai = EccPoint.point_at_infinity()
# S + 0
pointR = self.pointS.copy()
pointR += pai
self.assertEqual(pointR, self.pointS)
# 0 + S
pointR = pai.copy()
pointR += self.pointS
self.assertEqual(pointR, self.pointS)
# 0 + 0
pointR = pai.copy()
pointR += pai
self.assertEqual(pointR, pai)
def test_doubling(self):
pointRx = 0x7669e6901606ee3ba1a8eef1e0024c33df6c22f3b17481b82a860ffcdb6127b0
pointRy = 0xfa878162187a54f6c39f6ee0072f33de389ef3eecd03023de10ca2c1db61d0c7
pointR = self.pointS.copy()
pointR.double()
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
# 2*0
pai = self.pointS.point_at_infinity()
pointR = pai.copy()
pointR.double()
self.assertEqual(pointR, pai)
# S + S
pointR = self.pointS.copy()
pointR += pointR
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
def test_scalar_multiply(self):
d = 0xc51e4753afdec1e6b6c6a5b992f43f8dd0c7a8933072708b6522468b2ffb06fd
pointRx = 0x51d08d5f2d4278882946d88d83c97d11e62becc3cfc18bedacc89ba34eeca03f
pointRy = 0x75ee68eb8bf626aa5b673ab51f6e744e06f8fcf8a6c0cf3035beca956a7b41d5
pointR = self.pointS * d
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
# 0*S
pai = self.pointS.point_at_infinity()
pointR = self.pointS * 0
self.assertEqual(pointR, pai)
# -1*S
self.assertRaises(ValueError, lambda: self.pointS * -1)
def test_joing_scalar_multiply(self):
d = 0xc51e4753afdec1e6b6c6a5b992f43f8dd0c7a8933072708b6522468b2ffb06fd
e = 0xd37f628ece72a462f0145cbefe3f0b355ee8332d37acdd83a358016aea029db7
pointRx = 0xd867b4679221009234939221b8046245efcf58413daacbeff857b8588341f6b8
pointRy = 0xf2504055c03cede12d22720dad69c745106b6607ec7e50dd35d54bd80f615275
pointR = self.pointS * d + self.pointT * e
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
class TestEccPoint_PAI(unittest.TestCase):
"""Test vectors from http://point-at-infinity.org/ecc/nisttv"""
pointG = EccPoint(_curve.Gx, _curve.Gy)
def test_public_key(self):
point = EccPoint(_curve.Gx, _curve.Gy)
key = EccKey(curve="P-256", point=point)
self.failIf(key.has_private())
self.assertEqual(key.pointQ, point)
class TestEccPoint_Ed448(unittest.TestCase):
Gxy = {
"x":
0x4f1970c66bed0ded221d15a622bf36da9e146570470f1767ea6de324a3d3a46412ae1af72ab66511433b80e18b00938e2626a82bc70cc05e,
"y":
0x693f46716eb6bc248876203756c9c7624bea73736ca3984087789c1e05a0c2d73ad3ff1ce67c39c4fdbd132c4ed7c8ad9808795bf230fa14
}
G2xy = {
"x":
0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa955555555555555555555555555555555555555555555555555555555,
"y":
0xae05e9634ad7048db359d6205086c2b0036ed7a035884dd7b7e36d728ad8c4b80d6565833a2a3098bbbcb2bed1cda06bdaeafbcdea9386ed
}
G3xy = {
"x":
0x865886b9108af6455bd64316cb6943332241b8b8cda82c7e2ba077a4a3fcfe8daa9cbf7f6271fd6e862b769465da8575728173286ff2f8f,
"y":
0xe005a8dbd5125cf706cbda7ad43aa6449a4a8d952356c3b9fce43c82ec4e1d58bb3a331bdb6767f0bffa9a68fed02dafb822ac13588ed6fc
}
pointG = EccPoint(Gxy['x'], Gxy['y'], curve="Ed448")
pointG2 = EccPoint(G2xy['x'], G2xy['y'], curve="Ed448")
pointG3 = EccPoint(G3xy['x'], G3xy['y'], curve="Ed448")
def test_init_xy(self):
EccPoint(self.Gxy['x'], self.Gxy['y'], curve="Ed448")
# Neutral point
pai = EccPoint(0, 1, curve="Ed448")
self.assertEqual(pai.x, 0)
self.assertEqual(pai.y, 1)
self.assertEqual(pai.xy, (0, 1))
# G
bp = self.pointG.copy()
self.assertEqual(
bp.x,
0x4f1970c66bed0ded221d15a622bf36da9e146570470f1767ea6de324a3d3a46412ae1af72ab66511433b80e18b00938e2626a82bc70cc05e
)
self.assertEqual(
bp.y,
0x693f46716eb6bc248876203756c9c7624bea73736ca3984087789c1e05a0c2d73ad3ff1ce67c39c4fdbd132c4ed7c8ad9808795bf230fa14
)
self.assertEqual(bp.xy, (bp.x, bp.y))
# 2G
bp2 = self.pointG2.copy()
self.assertEqual(
bp2.x,
0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa955555555555555555555555555555555555555555555555555555555
)
self.assertEqual(
bp2.y,
0xae05e9634ad7048db359d6205086c2b0036ed7a035884dd7b7e36d728ad8c4b80d6565833a2a3098bbbcb2bed1cda06bdaeafbcdea9386ed
)
self.assertEqual(bp2.xy, (bp2.x, bp2.y))
# 5G
EccPoint(
x=
0x7a9f9335a48dcb0e2ba7601eedb50def80cbcf728562ada756d761e8958812808bc0d57a920c3c96f07b2d8cefc6f950d0a99d1092030034,
y=
0xadfd751a2517edd3b9109ce4fd580ade260ca1823ab18fced86551f7b698017127d7a4ee59d2b33c58405512881f225443b4731472f435eb,
curve="Ed448")
# Catch if point is not on the curve
self.assertRaises(ValueError, EccPoint, 34, 35, curve="Ed448")
def test_set(self):
pointW = EccPoint(0, 1, curve="Ed448")
pointW.set(self.pointG)
self.assertEqual(pointW.x, self.pointG.x)
self.assertEqual(pointW.y, self.pointG.y)
def test_copy(self):
pointW = self.pointG.copy()
self.assertEqual(pointW.x, self.pointG.x)
self.assertEqual(pointW.y, self.pointG.y)
def test_equal(self):
pointH = self.pointG.copy()
pointI = self.pointG2.copy()
self.assertEqual(self.pointG, pointH)
self.assertNotEqual(self.pointG, pointI)
def test_pai(self):
pai = EccPoint(0, 1, curve="Ed448")
self.failUnless(pai.is_point_at_infinity())
self.assertEqual(pai, pai.point_at_infinity())
def test_negate(self):
negG = -self.pointG
sum = self.pointG + negG
self.failUnless(sum.is_point_at_infinity())
def test_addition(self):
self.assertEqual(self.pointG + self.pointG2, self.pointG3)
self.assertEqual(self.pointG2 + self.pointG, self.pointG3)
self.assertEqual(self.pointG2 + self.pointG.point_at_infinity(),
self.pointG2)
self.assertEqual(self.pointG.point_at_infinity() + self.pointG2,
self.pointG2)
G5 = self.pointG2 + self.pointG3
self.assertEqual(
G5.x,
0x7a9f9335a48dcb0e2ba7601eedb50def80cbcf728562ada756d761e8958812808bc0d57a920c3c96f07b2d8cefc6f950d0a99d1092030034
)
self.assertEqual(
G5.y,
0xadfd751a2517edd3b9109ce4fd580ade260ca1823ab18fced86551f7b698017127d7a4ee59d2b33c58405512881f225443b4731472f435eb
)
def test_inplace_addition(self):
pointH = self.pointG.copy()
pointH += self.pointG
self.assertEqual(pointH, self.pointG2)
pointH += self.pointG
self.assertEqual(pointH, self.pointG3)
pointH += self.pointG.point_at_infinity()
self.assertEqual(pointH, self.pointG3)
def test_doubling(self):
pointH = self.pointG.copy()
pointH.double()
self.assertEqual(pointH.x, self.pointG2.x)
self.assertEqual(pointH.y, self.pointG2.y)
# 2*0
pai = self.pointG.point_at_infinity()
pointR = pai.copy()
pointR.double()
self.assertEqual(pointR, pai)
def test_scalar_multiply(self):
d = 0
pointH = d * self.pointG
self.assertEqual(pointH.x, 0)
self.assertEqual(pointH.y, 1)
d = 1
pointH = d * self.pointG
self.assertEqual(pointH.x, self.pointG.x)
self.assertEqual(pointH.y, self.pointG.y)
d = 2
pointH = d * self.pointG
self.assertEqual(pointH.x, self.pointG2.x)
self.assertEqual(pointH.y, self.pointG2.y)
d = 3
pointH = d * self.pointG
self.assertEqual(pointH.x, self.pointG3.x)
self.assertEqual(pointH.y, self.pointG3.y)
d = 4
pointH = d * self.pointG
self.assertEqual(
pointH.x,
0x49dcbc5c6c0cce2c1419a17226f929ea255a09cf4e0891c693fda4be70c74cc301b7bdf1515dd8ba21aee1798949e120e2ce42ac48ba7f30
)
self.assertEqual(
pointH.y,
0xd49077e4accde527164b33a5de021b979cb7c02f0457d845c90dc3227b8a5bc1c0d8f97ea1ca9472b5d444285d0d4f5b32e236f86de51839
)
d = 5
pointH = d * self.pointG
self.assertEqual(
pointH.x,
0x7a9f9335a48dcb0e2ba7601eedb50def80cbcf728562ada756d761e8958812808bc0d57a920c3c96f07b2d8cefc6f950d0a99d1092030034
)
self.assertEqual(
pointH.y,
0xadfd751a2517edd3b9109ce4fd580ade260ca1823ab18fced86551f7b698017127d7a4ee59d2b33c58405512881f225443b4731472f435eb
)
d = 10
pointH = d * self.pointG
self.assertEqual(
pointH.x,
0x77486f9d19f6411cdd35d30d1c3235f71936452c787e5c034134d3e8172278aca61622bc805761ce3dab65118a0122d73b403165d0ed303d
)
self.assertEqual(
pointH.y,
0x4d2fea0b026be11024f1f0fe7e94e618e8ac17381ada1d1bf7ee293a68ff5d0bf93c1997dc1aabdc0c7e6381428d85b6b1954a89e4cddf67
)
d = 20
pointH = d * self.pointG
self.assertEqual(
pointH.x,
0x3c236422354600fe6763defcc1503737e4ed89e262d0de3ec1e552020f2a56fe3b9e1e012d021072598c3c2821e18268bb8fb8339c0d1216
)
self.assertEqual(
pointH.y,
0xb555b9721f630ccb05fc466de4c74d3d2781e69eca88e1b040844f04cab39fd946f91c688fa42402bb38fb9c3e61231017020b219b4396e1
)
d = 255
pointH = d * self.pointG
self.assertEqual(
pointH.x,
0xbeb7f8388b05cd9c1aa2e3c0dcf31e2b563659361826225390e7748654f627d5c36cbe627e9019936b56d15d4dad7c337c09bac64ff4197f
)
self.assertEqual(
pointH.y,
0x1e37312b2dd4e9440c43c6e7725fc4fa3d11e582d4863f1d018e28f50c0efdb1f53f9b01ada7c87fa162b1f0d72401015d57613d25f1ad53
)
d = 256
pointH = d * self.pointG
self.assertEqual(
pointH.x,
0xf19c34feb56730e3e2be761ac0a2a2b24853b281dda019fc35a5ab58e3696beb39609ae756b0d20fb7ccf0d79aaf5f3bca2e4fdb25bfac1c
)
self.assertEqual(
pointH.y,
0x3beb69cc9111bffcaddc61d363ce6fe5dd44da4aadce78f52e92e985d5442344ced72c4611ed0daac9f4f5661eab73d7a12d25ce8a30241e
)
def test_sizes(self):
self.assertEqual(self.pointG.size_in_bits(), 448)
self.assertEqual(self.pointG.size_in_bytes(), 56)
def test_set(self):
pointW = EccPoint(0, 0)
pointW.set(self.pointS)
self.assertEqual(pointW, self.pointS)
class TestEccPoint_NIST_P384(unittest.TestCase):
"""Tests defined in section 4.4 of https://www.nsa.gov/ia/_files/nist-routines.pdf"""
pointS = EccPoint(
0xfba203b81bbd23f2b3be971cc23997e1ae4d89e69cb6f92385dda82768ada415ebab4167459da98e62b1332d1e73cb0e,
0x5ffedbaefdeba603e7923e06cdb5d0c65b22301429293376d5c6944e3fa6259f162b4788de6987fd59aed5e4b5285e45,
"p384")
pointT = EccPoint(
0xaacc05202e7fda6fc73d82f0a66220527da8117ee8f8330ead7d20ee6f255f582d8bd38c5a7f2b40bcdb68ba13d81051,
0x84009a263fefba7c2c57cffa5db3634d286131afc0fca8d25afa22a7b5dce0d9470da89233cee178592f49b6fecb5092,
"p384")
def test_set(self):
pointW = EccPoint(0, 0, "p384")
pointW.set(self.pointS)
self.assertEqual(pointW, self.pointS)
def test_copy(self):
pointW = self.pointS.copy()
self.assertEqual(pointW, self.pointS)
pointW.set(self.pointT)
self.assertEqual(pointW, self.pointT)
self.assertNotEqual(self.pointS, self.pointT)
def test_addition(self):
pointRx = 0x12dc5ce7acdfc5844d939f40b4df012e68f865b89c3213ba97090a247a2fc009075cf471cd2e85c489979b65ee0b5eed
pointRy = 0x167312e58fe0c0afa248f2854e3cddcb557f983b3189b67f21eee01341e7e9fe67f6ee81b36988efa406945c8804a4b0
pointR = self.pointS + self.pointT
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
pai = pointR.point_at_infinity()
# S + 0
pointR = self.pointS + pai
self.assertEqual(pointR, self.pointS)
# 0 + S
pointR = pai + self.pointS
self.assertEqual(pointR, self.pointS)
# 0 + 0
pointR = pai + pai
self.assertEqual(pointR, pai)
def _test_inplace_addition(self):
pointRx = 0x72b13dd4354b6b81745195e98cc5ba6970349191ac476bd4553cf35a545a067e
pointRy = 0x8d585cbb2e1327d75241a8a122d7620dc33b13315aa5c9d46d013011744ac264
pointR = self.pointS.copy()
pointR += self.pointT
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
pai = pointR.point_at_infinity()
# S + 0
pointR = self.pointS.copy()
pointR += pai
self.assertEqual(pointR, self.pointS)
# 0 + S
pointR = pai.copy()
pointR += self.pointS
self.assertEqual(pointR, self.pointS)
# 0 + 0
pointR = pai.copy()
pointR += pai
self.assertEqual(pointR, pai)
def test_doubling(self):
pointRx = 0x2a2111b1e0aa8b2fc5a1975516bc4d58017ff96b25e1bdff3c229d5fac3bacc319dcbec29f9478f42dee597b4641504c
pointRy = 0xfa2e3d9dc84db8954ce8085ef28d7184fddfd1344b4d4797343af9b5f9d837520b450f726443e4114bd4e5bdb2f65ddd
pointR = self.pointS.copy()
pointR.double()
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
# 2*0
pai = self.pointS.point_at_infinity()
pointR = pai.copy()
pointR.double()
self.assertEqual(pointR, pai)
# S + S
pointR = self.pointS.copy()
pointR += pointR
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
def test_scalar_multiply(self):
d = 0xa4ebcae5a665983493ab3e626085a24c104311a761b5a8fdac052ed1f111a5c44f76f45659d2d111a61b5fdd97583480
pointRx = 0xe4f77e7ffeb7f0958910e3a680d677a477191df166160ff7ef6bb5261f791aa7b45e3e653d151b95dad3d93ca0290ef2
pointRy = 0xac7dee41d8c5f4a7d5836960a773cfc1376289d3373f8cf7417b0c6207ac32e913856612fc9ff2e357eb2ee05cf9667f
pointR = self.pointS * d
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
# 0*S
pai = self.pointS.point_at_infinity()
pointR = self.pointS * 0
self.assertEqual(pointR, pai)
# -1*S
self.assertRaises(ValueError, lambda: self.pointS * -1)
def test_joing_scalar_multiply(self):
d = 0xa4ebcae5a665983493ab3e626085a24c104311a761b5a8fdac052ed1f111a5c44f76f45659d2d111a61b5fdd97583480
e = 0xafcf88119a3a76c87acbd6008e1349b29f4ba9aa0e12ce89bcfcae2180b38d81ab8cf15095301a182afbc6893e75385d
pointRx = 0x917ea28bcd641741ae5d18c2f1bd917ba68d34f0f0577387dc81260462aea60e2417b8bdc5d954fc729d211db23a02dc
pointRy = 0x1a29f7ce6d074654d77b40888c73e92546c8f16a5ff6bcbd307f758d4aee684beff26f6742f597e2585c86da908f7186
t = self.pointS * d
pointR = self.pointS * d + self.pointT * e
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
def test_sizes(self):
self.assertEqual(self.pointS.size_in_bits(), 384)
self.assertEqual(self.pointS.size_in_bytes(), 48)
class TestEccPoint_PAI_P521(unittest.TestCase):
"""Test vectors from http://point-at-infinity.org/ecc/nisttv"""
curve = _curves['p521']
pointG = EccPoint(curve.Gx, curve.Gy, "p521")
class TestEccPoint_NIST_P521(unittest.TestCase):
"""Tests defined in section 4.5 of https://www.nsa.gov/ia/_files/nist-routines.pdf"""
pointS = EccPoint(
0x000001d5c693f66c08ed03ad0f031f937443458f601fd098d3d0227b4bf62873af50740b0bb84aa157fc847bcf8dc16a8b2b8bfd8e2d0a7d39af04b089930ef6dad5c1b4,
0x00000144b7770963c63a39248865ff36b074151eac33549b224af5c8664c54012b818ed037b2b7c1a63ac89ebaa11e07db89fcee5b556e49764ee3fa66ea7ae61ac01823,
"p521")
pointT = EccPoint(
0x000000f411f2ac2eb971a267b80297ba67c322dba4bb21cec8b70073bf88fc1ca5fde3ba09e5df6d39acb2c0762c03d7bc224a3e197feaf760d6324006fe3be9a548c7d5,
0x000001fdf842769c707c93c630df6d02eff399a06f1b36fb9684f0b373ed064889629abb92b1ae328fdb45534268384943f0e9222afe03259b32274d35d1b9584c65e305,
"p521")
def test_set(self):
pointW = EccPoint(0, 0)
pointW.set(self.pointS)
self.assertEqual(pointW, self.pointS)
def test_copy(self):
pointW = self.pointS.copy()
self.assertEqual(pointW, self.pointS)
pointW.set(self.pointT)
self.assertEqual(pointW, self.pointT)
self.assertNotEqual(self.pointS, self.pointT)
def test_addition(self):
pointRx = 0x000001264ae115ba9cbc2ee56e6f0059e24b52c8046321602c59a339cfb757c89a59c358a9a8e1f86d384b3f3b255ea3f73670c6dc9f45d46b6a196dc37bbe0f6b2dd9e9
pointRy = 0x00000062a9c72b8f9f88a271690bfa017a6466c31b9cadc2fc544744aeb817072349cfddc5ad0e81b03f1897bd9c8c6efbdf68237dc3bb00445979fb373b20c9a967ac55
pointR = self.pointS + self.pointT
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
pai = pointR.point_at_infinity()
# S + 0
pointR = self.pointS + pai
self.assertEqual(pointR, self.pointS)
# 0 + S
pointR = pai + self.pointS
self.assertEqual(pointR, self.pointS)
# 0 + 0
pointR = pai + pai
self.assertEqual(pointR, pai)
def test_inplace_addition(self):
pointRx = 0x000001264ae115ba9cbc2ee56e6f0059e24b52c8046321602c59a339cfb757c89a59c358a9a8e1f86d384b3f3b255ea3f73670c6dc9f45d46b6a196dc37bbe0f6b2dd9e9
pointRy = 0x00000062a9c72b8f9f88a271690bfa017a6466c31b9cadc2fc544744aeb817072349cfddc5ad0e81b03f1897bd9c8c6efbdf68237dc3bb00445979fb373b20c9a967ac55
pointR = self.pointS.copy()
pointR += self.pointT
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
pai = pointR.point_at_infinity()
# S + 0
pointR = self.pointS.copy()
pointR += pai
self.assertEqual(pointR, self.pointS)
# 0 + S
pointR = pai.copy()
pointR += self.pointS
self.assertEqual(pointR, self.pointS)
# 0 + 0
pointR = pai.copy()
pointR += pai
self.assertEqual(pointR, pai)
def test_doubling(self):
pointRx = 0x0000012879442f2450c119e7119a5f738be1f1eba9e9d7c6cf41b325d9ce6d643106e9d61124a91a96bcf201305a9dee55fa79136dc700831e54c3ca4ff2646bd3c36bc6
pointRy = 0x0000019864a8b8855c2479cbefe375ae553e2393271ed36fadfc4494fc0583f6bd03598896f39854abeae5f9a6515a021e2c0eef139e71de610143f53382f4104dccb543
pointR = self.pointS.copy()
pointR.double()
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
# 2*0
pai = self.pointS.point_at_infinity()
pointR = pai.copy()
pointR.double()
self.assertEqual(pointR, pai)
# S + S
pointR = self.pointS.copy()
pointR += pointR
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
def test_scalar_multiply(self):
d = 0x000001eb7f81785c9629f136a7e8f8c674957109735554111a2a866fa5a166699419bfa9936c78b62653964df0d6da940a695c7294d41b2d6600de6dfcf0edcfc89fdcb1
pointRx = 0x00000091b15d09d0ca0353f8f96b93cdb13497b0a4bb582ae9ebefa35eee61bf7b7d041b8ec34c6c00c0c0671c4ae063318fb75be87af4fe859608c95f0ab4774f8c95bb
pointRy = 0x00000130f8f8b5e1abb4dd94f6baaf654a2d5810411e77b7423965e0c7fd79ec1ae563c207bd255ee9828eb7a03fed565240d2cc80ddd2cecbb2eb50f0951f75ad87977f
pointR = self.pointS * d
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
# 0*S
pai = self.pointS.point_at_infinity()
pointR = self.pointS * 0
self.assertEqual(pointR, pai)
# -1*S
self.assertRaises(ValueError, lambda: self.pointS * -1)
def test_joing_scalar_multiply(self):
d = 0x000001eb7f81785c9629f136a7e8f8c674957109735554111a2a866fa5a166699419bfa9936c78b62653964df0d6da940a695c7294d41b2d6600de6dfcf0edcfc89fdcb1
e = 0x00000137e6b73d38f153c3a7575615812608f2bab3229c92e21c0d1c83cfad9261dbb17bb77a63682000031b9122c2f0cdab2af72314be95254de4291a8f85f7c70412e3
pointRx = 0x0000009d3802642b3bea152beb9e05fba247790f7fc168072d363340133402f2585588dc1385d40ebcb8552f8db02b23d687cae46185b27528adb1bf9729716e4eba653d
pointRy = 0x0000000fe44344e79da6f49d87c1063744e5957d9ac0a505bafa8281c9ce9ff25ad53f8da084a2deb0923e46501de5797850c61b229023dd9cf7fc7f04cd35ebb026d89d
t = self.pointS * d
pointR = self.pointS * d
pointR += self.pointT * e
self.assertEqual(pointR.x, pointRx)
self.assertEqual(pointR.y, pointRy)
def test_sizes(self):
self.assertEqual(self.pointS.size_in_bits(), 521)
self.assertEqual(self.pointS.size_in_bytes(), 66)