def test_ImportSplitRestoreKey():
for x in range(10):
thresholdList = []
# Randomly generate two digit number that ranges from 3 to 100
threshold = randint(3, 100)
# Generate pair of keys in pem format
pubKey, privKey = PyAsymKey.GenerateKeyPairPEM()
assert privKeyPEMHeader in privKey, "Test failed"
# Imports a key from a PEM format
pubValue, priValue = PyAsymKey.ImportFromPem(privKey)
assert priValue == privKey, "Test failed"
assert pubValue == pubKey, "Test failed"
# Split a private key into a given number of shares
splitKeyList = PyAsymKey.SplitKey(privKey, threshold, maxshares)
assert len(splitKeyList) == maxshares, "Test failed"
for i in range(threshold):
thresholdList.append(splitKeyList[i])
assert len(thresholdList) == threshold, "Test failed"
# convert list to String
thresholdString = ';'.join(thresholdList)
# Restore a private key from a given number of shares
restorePubKey, restorePrivKey = PyAsymKey.RestoreKey(thresholdString)
assert restorePrivKey == privKey, "Test failed"
def test_ThresholdEqualMaxShareTestcase():
thresholdList = []
#Randomly generate two digit number that ranges from 3 to 100
threshold = 100
# Generate pair of keys in pem format
pubKey, privKey = PyAsymKey.GenerateKeyPairPEM()
assert privKeyPEMHeader in privKey, "Test failed"
# Split a private key into a given number of shares
splitKeyList = PyAsymKey.SplitKey(privKey, threshold, maxshares)
assert len(splitKeyList) == maxshares, "Test failed"
for i in range(threshold):
thresholdList.append(splitKeyList[i])
assert len(thresholdList) == threshold, "Test failed"
# convert list to String
thresholdString = ';'.join(thresholdList)
# Restore a private key from a given number of shares
restorePubKey, restorePrivKey = PyAsymKey.RestoreKey(thresholdString)
assert restorePrivKey == privKey, "Test failed"
def test_ExportPublicKeyPEM():
for x in range(100):
# Generate pair of keys in pem format
pubKeyPEM, privKeyPEM = PyAsymKey.GenerateKeyPairPEM()
test_pubKeyPEM = PyAsymKey.ExportPublicPEM(privKeyPEM)
# Calculated public key should match the generated one
assert pubKeyPEM == test_pubKeyPEM, "Test failed"
def test_ExportKeyPairHEX():
for x in range(100):
# Generate pair of keys in pem format
pubKeyPEM, privKeyPEM = PyAsymKey.GenerateKeyPairPEM()
pubKeyHEX, privKeyHEX = PyAsymKey.ExportKeyPairHEX(privKeyPEM)
# Keys hex are generated
assert len(pubKeyHEX) > 0, "Test failed"
assert len(privKeyHEX) > 0, "Test failed"
def test_ImportKeyFromPEM():
for x in range(10):
# Generate pair of keys in pem format
pubKey, privKey = PyAsymKey.GenerateKeyPairPEM()
assert privKeyPEMHeader in privKey, "Test failed"
# Imports a key from a PEM format
pubValue, priValue = PyAsymKey.ImportFromPem(privKey)
assert priValue == privKey, "Test failed"
assert pubValue == pubKey, "Test failed"
def test_ShareSecret():
for x in range(100):
# Generate keys for alice and bob
alice_pubKeyPEM, alice_privKeyPEM = PyAsymKey.GenerateKeyPairPEM()
bob_pubKeyPEM, bob_privKeyPEM = PyAsymKey.GenerateKeyPairPEM()
#Calculate shared secret from my private key and their public key
secret_share_from_alice = PyAsymKey.ShareSecret(
alice_privKeyPEM, bob_pubKeyPEM)
secret_share_from_bob = PyAsymKey.ShareSecret(bob_privKeyPEM,
alice_pubKeyPEM)
assert secret_share_from_alice == secret_share_from_bob, "Test failed"
def test_Sign_Verification():
msg = 'Hello, I am a message, sign me'
for x in range(100):
# Generate pair of keys in PEM format
pubKey, priKey = PyAsymKey.GenerateKeyPairPEM()
# Sign message with private Key
rSig, sSig = PyAsymKey.Sign(msg, priKey)
# Verify message's signature with public key
verify_ok = PyAsymKey.Verify(msg, pubKey, rSig, sSig)
assert verify_ok, "Test failed"
def test_KeySplit():
for x in range(10):
#Randomly generate two digit number that ranges from 3 to 100
threshold = randint(3, 100)
# Generate pair of keys in pem format
pubKey, privKey = PyAsymKey.GenerateKeyPairPEM()
assert privKeyPEMHeader in privKey, "Test failed"
# Split a private key into a given number of shares
splitKeyList = PyAsymKey.SplitKey(privKey, threshold, maxshares)
assert len(splitKeyList) == maxshares, "Test failed"
def test_KeyDerive():
additive_msg = 'I am a random message used for key derivation'
for x in range(100):
# Generate keys for alice and bob
alice_pubKeyPEM, alice_privKeyPEM = PyAsymKey.GenerateKeyPairPEM()
bob_pubKeyPEM, bob_privKeyPEM = PyAsymKey.GenerateKeyPairPEM()
# Derive public key from a given public key and a additive message
alice_derived_pub = PyAsymKey.DerivePublic(alice_pubKeyPEM,
additive_msg)
bob_derived_pub = PyAsymKey.DerivePublic(bob_pubKeyPEM, additive_msg)
# Derive pirvate key from a given private key and a additive message
alice_derived_private = PyAsymKey.DerivePrivate(
alice_privKeyPEM, additive_msg)
bob_derived_private = PyAsymKey.DerivePrivate(bob_privKeyPEM,
additive_msg)
# Export public key PEM given the private key PEM
calc_alice_derived_pub = PyAsymKey.ExportPublicPEM(
alice_derived_private)
calc_bob_derived_pub = PyAsymKey.ExportPublicPEM(bob_derived_private)
assert calc_alice_derived_pub == alice_derived_pub, "Test failed"
assert calc_bob_derived_pub == bob_derived_pub, "Test failed"
def test_SetKeyFromPem():
for x in range(100):
# Generate pair of keys in pem format
pubKeyPEM, privKeyPEM = PyAsymKey.GenerateKeyPairPEM()
test_pubKeyPEM = PyAsymKey.ExportPublicPEM(privKeyPEM)
# Calculated public key should match the generated one
assert pubKeyPEM == test_pubKeyPEM, "Test failed"
#Sets a key from a PEM format
pub, pri = PyAsymKey.ImportFromPem(privKeyPEM)
# Calculated private key should match the generated one
assert privKeyPEM == pri, "Test failed"
assert pubKeyPEM == pub, "Test failed"
def test_GenerateKeyPairHex():
for x in range(100):
# Generate pair of keys in hex format
privKey, pubKey = PyAsymKey.GenerateKeyPairHEX()
# Verifying the the length of actual value as 66
assert len(privKey) == 66, "Test failed"
def test_GenerateKeyPairPEM():
privKeyPEMHeader = "BEGIN EC PRIVATE KEY"
for x in range(100):
# Generate pair of keys in pem format
pubKey, privKey = PyAsymKey.GenerateKeyPairPEM()
# Verifying the the length of actual value as 66
assert privKeyPEMHeader in privKey, "Test failed"
def SplitKey(self, threshold=10, shares=100):
return PyAsymKey.SplitKey(self.priKey, threshold, shares)
def FromPEMStr(self, keyPemForm):
self.pubKey, self.priKey = PyAsymKey.ImportFromPem(keyPemForm)
pass
def __init__(self, asHex=False):
if (asHex):
self.pubKey, self.priKey = PyAsymKey.GenerateKeyPairHEX()
else:
self.pubKey, self.priKey = PyAsymKey.GenerateKeyPairPEM()
def pubKeyHexPtasPem(xPt, yPt, nid=714):
return PyAsymKey.PubKeyHexPtToPEM(xPt, yPt, nid)
def FromEncryptedPEMStr(self, keyPemForm, passPhrase):
self.pubKey, self.priKey = PyAsymKey.ImportFromEncryptedPEM(
keyPemForm, passPhrase)
pass
def createDERFormat(rValue, sValue):
assert (rValue.isDec == sValue.isDec)
hexSig = PyAsymKey.DERSignature(rValue.value, sValue.value, rValue.isDec)
hexSigBN = BigNum(hexSig, rValue.mod, rValue.isDec)
return hexSigBN
def pubKeyPEMasHex(pubkey, compressed=False):
return PyAsymKey.PubKeyPEMToHexPt(pubkey, compressed)
def verifyPubKeyHex(msg, pubkey, rval, sval):
pt = ECPoint()
pt.value = pubkey
coords = pt.GetAffineCoOrdinates()
pempubkey = pubKeyHexPtasPem(coords[0], coords[1])
return PyAsymKey.Verify(msg, pempubkey, rval, sval)
def verifyDER(msg, pubkey, DERSig, isDec=False):
return PyAsymKey.VerifyDER(msg, pubkey, DERSig, isDec)
def CalculateSharedSecret(self, pubkey):
return PyAsymKey.ShareSecret(self.priKey, pubkey)
def verify(msg, pubkey, rval, sval):
return PyAsymKey.Verify(msg, pubkey, rval, sval)
def sign(self, msg):
return PyAsymKey.Sign(msg, self.priKey)
def RecoverKey(self, shares):
if (len(shares) < 2):
return
ListAsStr = ";".join(str(x) for x in shares)
self.pubKey, self.priKey = PyAsymKey.RestoreKey(ListAsStr)
pass
def ToEncryptedPEMStr(self, passPhrase):
return PyAsymKey.ExportFromEncryptedPEM(passPhrase)
def derivePublicKey(self, msg):
return PyAsymKey.DerivePublic(self.pubKey, msg)
def derivePrivateKey(self, msg):
return PyAsymKey.DerivePrivate(self.priKey, msg)