def test_invalid_serialized_points():
field_order = 2**256 - 0x1000003D1
# A point on secp256k1
x = 17004608369308732328368332205668001941491834793934321461466076545247324070015
y = 69725941631324401609944843130171147910924748427773762412028916504484868631573
# Check it
assert (y**2 - x**3 - 7) % field_order == 0
# Should load
point_data = b'\x03' + x.to_bytes(CURVE.field_element_size, 'big')
p = CurvePoint.from_bytes(point_data)
# Make it invalid
bad_x = x - 1
assert (y**2 - bad_x**3 - 7) % field_order != 0
bad_x_data = b'\x03' + bad_x.to_bytes(CURVE.field_element_size, 'big')
with pytest.raises(ErrorInvalidCompressedPoint):
CurvePoint.from_bytes(bad_x_data)
# Valid x, invalid prefix
bad_format = b'\xff' + x.to_bytes(CURVE.field_element_size, 'big')
with pytest.raises(ErrorInvalidPointEncoding):
CurvePoint.from_bytes(bad_format)
def test_generator_point():
"""http://www.secg.org/SEC2-Ver-1.0.pdf Section 2.7.1"""
g1 = CurvePoint.generator()
g_compressed = 0x0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
g_compressed_bytes = g_compressed.to_bytes(CURVE.field_element_size + 1,
byteorder='big')
g2 = CurvePoint.from_bytes(g_compressed_bytes)
assert g1 == g2
def test_serialize_point_at_infinity():
p = CurvePoint.random()
point_at_infinity = p - p
bytes_point_at_infinity = bytes(point_at_infinity)
assert bytes_point_at_infinity == b'\x00'
def test_cfrag_with_wrong_data(verification_keys, kfrags, capsule_and_ciphertext, message):
capsule, ciphertext = capsule_and_ciphertext
verifying_pk, delegating_pk, receiving_pk = verification_keys
cfrag = reencrypt(capsule, kfrags[0])
# Let's put random garbage in one of the cfrags
cfrag = CapsuleFrag.from_bytes(bytes(cfrag)) # de-verify
cfrag.point_e1 = CurvePoint.random()
cfrag.point_v1 = CurvePoint.random()
with pytest.raises(VerificationError):
cfrag.verify(capsule,
verifying_pk=verifying_pk,
delegating_pk=delegating_pk,
receiving_pk=receiving_pk,
)
def test_capsule_serialization(alices_keys):
delegating_sk, _signing_sk = alices_keys
delegating_pk = delegating_sk.public_key()
capsule, _key = Capsule.from_public_key(delegating_pk)
new_capsule = Capsule.from_bytes(bytes(capsule))
assert capsule == new_capsule
# Deserializing a bad capsule triggers verification error
capsule.point_e = CurvePoint.random()
capsule_bytes = bytes(capsule)
with pytest.raises(ValueError):
Capsule.from_bytes(capsule_bytes)
vector_suite = {
'name' : 'Test vectors for umbral.curvebn.CurveScalar.from_digest()',
'params' : 'default',
'vectors' : vectors
}
create_test_vector_file(vector_suite, 'vectors_scalar_from_digest.json', generate_again=generate_again)
#print(json.dumps(vector_suite, indent=2))
###############
# CurvePoints #
###############
point1 = CurvePoint.random()
point2 = CurvePoint.random()
# Expected results for some CurvePoint operations
expected = [('Addition', point1 + point2),
('Subtraction', point1 - point2),
('Multiplication', point1 * bn1),
('Inversion', -point1),
('To_affine.X', point1.to_affine()[0]),
('To_affine.Y', point1.to_affine()[1]),
('kdf', kdf(bytes(point1), DEM.KEY_SIZE)),
]
expected = [{'operation': op, 'result': hexlify(result)} for (op, result) in expected]
# Definition of test vector
def test_identity_to_affine():
p = CurvePoint.generator()
identity = p - p
with pytest.raises(ValueError):
identity.to_affine()
def test_random():
p1 = CurvePoint.random()
p2 = CurvePoint.random()
assert isinstance(p1, CurvePoint)
assert isinstance(p2, CurvePoint)
assert p1 != p2
def test_to_affine():
p = CurvePoint.generator()
x_ref = 0x79BE667E_F9DCBBAC_55A06295_CE870B07_029BFCDB_2DCE28D9_59F2815B_16F81798
y_ref = 0x483ADA77_26A3C465_5DA4FBFC_0E1108A8_FD17B448_A6855419_9C47D08F_FB10D4B8
assert p.to_affine() == (x_ref, y_ref)