def test_key_encoding(vectors):
priv = EccPrivate()
pub = EccPublic()
priv.decode_key(vectors[EccPrivate].key)
pub.decode_key(vectors[EccPublic].key)
assert priv.encode_key() == vectors[EccPrivate].key
assert pub.encode_key() == vectors[EccPublic].key
def test_new_ecc_raises(vectors):
with pytest.raises(WolfCryptError):
EccPrivate(vectors[EccPrivate].key[:-1]) # invalid key length
with pytest.raises(WolfCryptError):
EccPublic(vectors[EccPublic].key[:-1]) # invalid key length
with pytest.raises(WolfCryptError):
EccPrivate(vectors[EccPublic].key) # invalid key type
with pytest.raises(WolfCryptError):
EccPublic(vectors[EccPrivate].key) # invalid key type
with pytest.raises(WolfCryptError): # invalid key size
EccPrivate.make_key(1024)
def test_ecc_make_shared_secret():
a = EccPrivate.make_key(32)
a_pub = EccPublic()
a_pub.import_x963(a.export_x963())
b = EccPrivate.make_key(32)
b_pub = EccPublic()
b_pub.import_x963(b.export_x963())
assert a.shared_secret(b) \
== b.shared_secret(a) \
== a.shared_secret(b_pub) \
== b.shared_secret(a_pub)
def test_ecc_make_shared_secret():
a = EccPrivate.make_key(32)
a_pub = EccPublic()
a_pub.import_x963(a.export_x963())
b = EccPrivate.make_key(32)
b_pub = EccPublic()
b_pub.import_x963(b.export_x963())
assert a.shared_secret(b) \
== b.shared_secret(a) \
== a.shared_secret(b_pub) \
== b.shared_secret(a_pub)
def test_key_encoding(vectors):
priv = EccPrivate()
pub = EccPublic()
raw_priv = EccPrivate()
raw_pub = EccPublic()
# Test default encode/decode key
priv.decode_key(vectors[EccPrivate].key)
pub.decode_key(vectors[EccPublic].key)
assert priv.encode_key() == vectors[EccPrivate].key
assert pub.encode_key() == vectors[EccPublic].key
# Test EccPrivate.encode_key_raw/decode_key_raw
key = vectors[EccPrivate].raw_key
raw_priv.decode_key_raw(key[0:31], key[32:63], key[64:-1])
qx, qy, d = raw_priv.encode_key_raw()
assert qx[0:31] == vectors[EccPrivate].raw_key[0:31]
assert qy[0:31] == vectors[EccPrivate].raw_key[32:63]
assert d[0:31] == vectors[EccPrivate].raw_key[64:-1]
# Verify ECC key is the same as the raw key
qx, qy, d = priv.encode_key_raw()
assert qx[0:31] == vectors[EccPrivate].raw_key[0:31]
assert qy[0:31] == vectors[EccPrivate].raw_key[32:63]
assert d[0:31] == vectors[EccPrivate].raw_key[64:-1]
# Test EccPublic.encode_key_raw/decode_key_raw
key = vectors[EccPublic].raw_key
raw_pub.decode_key_raw(key[0:31], key[32:-1])
qx, qy = raw_pub.encode_key_raw()
assert qx[0:31] == vectors[EccPublic].raw_key[0:31]
assert qy[0:31] == vectors[EccPublic].raw_key[32:63]
# Verify ECC public key is the same as the raw key
qx, qy = pub.encode_key_raw()
assert qx[0:31] == vectors[EccPublic].raw_key[0:31]
assert qy[0:31] == vectors[EccPublic].raw_key[32:63]
def test_ecc_sign_verify(ecc_private, ecc_public):
plaintext = "Everyone gets Friday off."
# normal usage, sign with private, verify with public
signature = ecc_private.sign(plaintext)
assert len(signature) <= ecc_private.max_signature_size
assert ecc_public.verify(signature, plaintext)
# invalid signature
with pytest.raises(WolfCryptError):
ecc_public.verify(signature[:-1], plaintext)
# private object holds both private and public info, so it can also verify
# using the known public key.
assert ecc_private.verify(signature, plaintext)
ecc_x963 = EccPublic()
ecc_x963.import_x963(ecc_public.export_x963())
assert ecc_x963.verify(signature, plaintext)
ecc_x963 = EccPublic()
ecc_x963.import_x963(ecc_private.export_x963())
assert ecc_x963.verify(signature, plaintext)
ecc_x963 = EccPublic()
with pytest.raises(WolfCryptError):
ecc_x963.import_x963(ecc_public.export_x963()[:-1])
def test_ecc_sign_verify(ecc_private, ecc_public):
plaintext = "Everyone gets Friday off."
# normal usage, sign with private, verify with public
signature = ecc_private.sign(plaintext)
assert len(signature) <= ecc_private.max_signature_size
assert ecc_public.verify(signature, plaintext)
# invalid signature
with pytest.raises(WolfCryptError):
ecc_public.verify(signature[:-1], plaintext)
# private object holds both private and public info, so it can also verify
# using the known public key.
assert ecc_private.verify(signature, plaintext)
ecc_x963 = EccPublic()
ecc_x963.import_x963(ecc_public.export_x963())
assert ecc_x963.verify(signature, plaintext)
ecc_x963 = EccPublic()
ecc_x963.import_x963(ecc_private.export_x963())
assert ecc_x963.verify(signature, plaintext)
ecc_x963 = EccPublic()
with pytest.raises(WolfCryptError):
ecc_x963.import_x963(ecc_public.export_x963()[:-1])
def test_key_encoding(vectors):
priv = EccPrivate()
pub = EccPublic()
raw_priv = EccPrivate()
raw_pub = EccPublic()
# Test default encode/decode key
priv.decode_key(vectors[EccPrivate].key)
pub.decode_key(vectors[EccPublic].key)
assert priv.encode_key() == vectors[EccPrivate].key
assert pub.encode_key() == vectors[EccPublic].key
# Test EccPrivate.encode_key_raw/decode_key_raw
key = vectors[EccPrivate].raw_key
raw_priv.decode_key_raw(key[0:32], key[32:64], key[64:96])
qx, qy, d = raw_priv.encode_key_raw()
assert qx[0:32] == vectors[EccPrivate].raw_key[0:32]
assert qy[0:32] == vectors[EccPrivate].raw_key[32:64]
assert d[0:32] == vectors[EccPrivate].raw_key[64:96]
# Verify ECC key is the same as the raw key
qx, qy, d = priv.encode_key_raw()
assert qx[0:32] == vectors[EccPrivate].raw_key[0:32]
assert qy[0:32] == vectors[EccPrivate].raw_key[32:64]
assert d[0:32] == vectors[EccPrivate].raw_key[64:96]
# Test EccPublic.encode_key_raw/decode_key_raw
key = vectors[EccPublic].raw_key
raw_pub.decode_key_raw(key[0:32], key[32:64])
qx, qy = raw_pub.encode_key_raw()
assert qx[0:32] == vectors[EccPublic].raw_key[0:32]
assert qy[0:32] == vectors[EccPublic].raw_key[32:64]
# Verify ECC public key is the same as the raw key
qx, qy = pub.encode_key_raw()
assert qx[0:32] == vectors[EccPublic].raw_key[0:32]
assert qy[0:32] == vectors[EccPublic].raw_key[32:64]
def ecc_public(vectors):
return EccPublic(vectors[EccPublic].key)
