def test_keypair(self):
sk, vk = ed25519.create_keypair()
self.assertTrue(isinstance(sk, ed25519.SigningKey), sk)
self.assertTrue(isinstance(vk, ed25519.VerifyingKey), vk)
sk2, vk2 = ed25519.create_keypair()
self.assertNotEqual(hexlify(sk.to_bytes()), hexlify(sk2.to_bytes()))
# you can control the entropy source
def not_so_random(length):
return b"4" * length
sk1, vk1 = ed25519.create_keypair(entropy=not_so_random)
self.assertEqual(
sk1.to_ascii(encoding="base64"),
b"NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ",
)
self.assertEqual(
vk1.to_ascii(encoding="base64"),
b"6yzxO/euOl9hQWih+wknLTl3HsS4UjcngV5GbK+O4WM",
)
sk2, vk2 = ed25519.create_keypair(entropy=not_so_random)
self.assertEqual(sk1.to_ascii(encoding="base64"),
sk2.to_ascii(encoding="base64"))
self.assertEqual(vk1.to_ascii(encoding="base64"),
vk2.to_ascii(encoding="base64"))
def test_keypair(self):
sk, vk = ed25519.create_keypair()
self.assertTrue(isinstance(sk, ed25519.SigningKey), sk)
self.assertTrue(isinstance(vk, ed25519.VerifyingKey), vk)
sk2, vk2 = ed25519.create_keypair()
self.assertNotEqual(hexlify(sk.to_bytes()), hexlify(sk2.to_bytes()))
# you can control the entropy source
def not_so_random(length):
return b"4"*length
sk1, vk1 = ed25519.create_keypair(entropy=not_so_random)
self.assertEqual(sk1.to_ascii(encoding="base64"),
b"NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ")
self.assertEqual(vk1.to_ascii(encoding="base64"),
b"6yzxO/euOl9hQWih+wknLTl3HsS4UjcngV5GbK+O4WM")
sk2, vk2 = ed25519.create_keypair(entropy=not_so_random)
self.assertEqual(sk1.to_ascii(encoding="base64"),
sk2.to_ascii(encoding="base64"))
self.assertEqual(vk1.to_ascii(encoding="base64"),
vk2.to_ascii(encoding="base64"))
def test_prefix(self):
sk1, vk1 = ed25519.create_keypair()
PREFIX = b"private0-"
p = sk1.to_bytes(PREFIX)
# that gives us a binary string with a prefix
self.assertTrue(p[:len(PREFIX)] == PREFIX, repr(p))
sk2 = ed25519.SigningKey(p, prefix=PREFIX)
self.assertEqual(sk1, sk2)
self.assertEqual(repr(sk1.to_bytes()), repr(sk2.to_bytes()))
self.assertRaises(ed25519.BadPrefixError,
ed25519.SigningKey,
p,
prefix=b"WRONG-")
# SigningKey.to_seed() can do a prefix too
p = sk1.to_seed(PREFIX)
self.assertTrue(p[:len(PREFIX)] == PREFIX, repr(p))
sk3 = ed25519.SigningKey(p, prefix=PREFIX)
self.assertEqual(sk1, sk3)
self.assertEqual(repr(sk1.to_bytes()), repr(sk3.to_bytes()))
self.assertRaises(ed25519.BadPrefixError,
ed25519.SigningKey,
p,
prefix=b"WRONG-")
# verifying keys can do this too
PREFIX = b"public0-"
p = vk1.to_bytes(PREFIX)
self.assertTrue(p.startswith(PREFIX), repr(p))
vk2 = ed25519.VerifyingKey(p, prefix=PREFIX)
self.assertEqual(vk1, vk2)
self.assertEqual(repr(vk1.to_bytes()), repr(vk2.to_bytes()))
self.assertRaises(ed25519.BadPrefixError,
ed25519.VerifyingKey,
p,
prefix=b"WRONG-")
# and signatures
PREFIX = b"sig0-"
p = sk1.sign(b"msg", PREFIX)
self.assertTrue(p.startswith(PREFIX), repr(p))
vk1.verify(p, b"msg", PREFIX)
self.assertRaises(ed25519.BadPrefixError,
vk1.verify,
p,
b"msg",
prefix=b"WRONG-")
def test_prefix(self):
sk1,vk1 = ed25519.create_keypair()
PREFIX = b"private0-"
p = sk1.to_bytes(PREFIX)
# that gives us a binary string with a prefix
self.assertTrue(p[:len(PREFIX)] == PREFIX, repr(p))
sk2 = ed25519.SigningKey(p, prefix=PREFIX)
self.assertEqual(sk1, sk2)
self.assertEqual(repr(sk1.to_bytes()), repr(sk2.to_bytes()))
self.assertRaises(ed25519.BadPrefixError,
ed25519.SigningKey, p, prefix=b"WRONG-")
# SigningKey.to_seed() can do a prefix too
p = sk1.to_seed(PREFIX)
self.assertTrue(p[:len(PREFIX)] == PREFIX, repr(p))
sk3 = ed25519.SigningKey(p, prefix=PREFIX)
self.assertEqual(sk1, sk3)
self.assertEqual(repr(sk1.to_bytes()), repr(sk3.to_bytes()))
self.assertRaises(ed25519.BadPrefixError,
ed25519.SigningKey, p, prefix=b"WRONG-")
# verifying keys can do this too
PREFIX = b"public0-"
p = vk1.to_bytes(PREFIX)
self.assertTrue(p.startswith(PREFIX), repr(p))
vk2 = ed25519.VerifyingKey(p, prefix=PREFIX)
self.assertEqual(vk1, vk2)
self.assertEqual(repr(vk1.to_bytes()), repr(vk2.to_bytes()))
self.assertRaises(ed25519.BadPrefixError,
ed25519.VerifyingKey, p, prefix=b"WRONG-")
# and signatures
PREFIX = b"sig0-"
p = sk1.sign(b"msg", PREFIX)
self.assertTrue(p.startswith(PREFIX), repr(p))
vk1.verify(p, b"msg", PREFIX)
self.assertRaises(ed25519.BadPrefixError,
vk1.verify, p, b"msg", prefix=b"WRONG-")
def _make_keys(self):
# Makes a set of private and public keys
privkey, pubkey = ed25519.create_keypair()
pri = privkey.to_ascii(encoding=self.key_encoding)
pub = pubkey.to_ascii(encoding=self.key_encoding)
return pri, pub
from pure25519 import ed25519_oop
privKey, pubKey = ed25519_oop.create_keypair()
print("Private key (32 bytes):", privKey.to_ascii(encoding='hex'))
print("Public key (32 bytes): ", pubKey.to_ascii(encoding='hex'))
msg = b'Message for signing'
signature = privKey.sign(msg, encoding='hex')
print("Signature (64 bytes):", signature)
try:
pubKey.verify(signature, msg, encoding='hex')
print("The signature is valid.")
except:
print("Invalid signature!")
def _make_keys(self):
# Makes a set of private and public keys
privkey, pubkey = ed25519.create_keypair()
pri = privkey.to_ascii(encoding=self.key_encoding)
pub = pubkey.to_ascii(encoding=self.key_encoding)
return pri, pub
def gen_keypair(): return create_keypair()