def get_key(self, fingerprint: bytes) -> Union[keypairs.EncryptingKeypair,
keypairs.SigningKeypair]:
"""
Returns a key from the KeyStore.
:param fingerprint: Fingerprint, in bytes, of key to return
:return: Keypair of the returned key.
"""
key = self.session.query(Key).filter_by(fingerprint=fingerprint).first()
if not key:
raise KeyNotFound(
"No key with fingerprint {} found.".format(fingerprint))
keypair_byte = key.key_data[0].to_bytes(1, 'big')
key_type_byte = key.key_data[1].to_bytes(1, 'big')
key = key.key_data[2:]
if keypair_byte == constants.ENC_KEYPAIR_BYTE:
if key_type_byte == constants.PUB_KEY_BYTE:
return keypairs.EncryptingKeypair(pubkey=key)
elif key_type_byte == constants.PRIV_KEY_BYTE:
return keypairs.EncryptingKeypair(privkey=key)
elif keypair_byte == constants.SIG_KEYPAIR_BYTE:
if key_type_byte == constants.PUB_KEY_BYTE:
return keypairs.SigningKeypair(pubkey=key)
elif key_type_byte == constants.PRIV_KEY_BYTE:
return keypairs.SigningKeypair(privkey=key)
def test_keypair_object(self):
# Test both keys
keypair = keypairs.SigningKeypair(self.ecdsa_keypair.privkey,
self.ecdsa_keypair.pubkey)
self.assertTrue(keypair.public_only is False)
self.assertEqual(bytes, type(keypair.privkey))
self.assertEqual(32, len(keypair.privkey))
self.assertEqual(PublicKey._EXPECTED_LENGTH, len(keypair.pubkey))
# Test no keys (key generation)
keypair = keypairs.SigningKeypair()
self.assertTrue(keypair.public_only is False)
self.assertEqual(bytes, type(keypair.privkey))
self.assertEqual(32, len(keypair.privkey))
self.assertEqual(PublicKey._EXPECTED_LENGTH, len(keypair.pubkey))
# Test privkey only
keypair = keypairs.SigningKeypair(privkey=self.ecdsa_keypair.privkey)
self.assertTrue(keypair.public_only is False)
self.assertEqual(bytes, type(keypair.privkey))
self.assertEqual(32, len(keypair.privkey))
self.assertEqual(PublicKey._EXPECTED_LENGTH, len(keypair.pubkey))
# Test pubkey only
keypair = keypairs.SigningKeypair(pubkey=self.ecdsa_keypair.pubkey)
self.assertTrue(keypair.public_only is True)
self.assertEqual(PublicKey._EXPECTED_LENGTH, len(keypair.pubkey))
def __init__(self, keypair: keypairs.SigningKeypair = None):
"""
Initializes a SigningPower object for CryptoPower.
"""
self.keypair = keypair or keypairs.SigningKeypair()
self.priv_key = self.keypair.privkey
self.pub_key = self.keypair.pubkey
def test_gen_keypair_if_needed():
new_enc_keypair = keypairs.EncryptingKeypair()
assert new_enc_keypair._privkey != None
assert new_enc_keypair.pubkey != None
new_sig_keypair = keypairs.SigningKeypair()
assert new_sig_keypair._privkey != None
assert new_sig_keypair.pubkey != None
def test_workorder_sqlite_keystore(test_keystore):
bob_keypair_sig1 = keypairs.SigningKeypair(generate_keys_if_needed=True)
bob_keypair_sig2 = keypairs.SigningKeypair(generate_keys_if_needed=True)
hrac = b'test'
# Test add workorder
new_workorder1 = test_keystore.add_workorder(bob_keypair_sig1.pubkey, b'test0', hrac)
new_workorder2 = test_keystore.add_workorder(bob_keypair_sig2.pubkey, b'test1', hrac)
# Test get workorder
query_workorders = test_keystore.get_workorders(hrac)
assert {new_workorder1, new_workorder2}.issubset(query_workorders)
# Test del workorder
deleted = test_keystore.del_workorders(hrac)
assert deleted > 0
assert test_keystore.get_workorders(hrac).count() == 0
def test_signing():
umbral_privkey = UmbralPrivateKey.gen_key()
sig_keypair = keypairs.SigningKeypair(umbral_privkey)
msg = b'attack at dawn'
signature = sig_keypair.sign(msg)
assert signature.verify(msg, sig_keypair.pubkey) == True
bad_msg = b'bad message'
assert signature.verify(bad_msg, sig_keypair.pubkey) == False
def test_policy_contract_sqlite_keystore(test_keystore):
alice_keypair_sig = keypairs.SigningKeypair(generate_keys_if_needed=True)
alice_keypair_enc = keypairs.EncryptingKeypair(generate_keys_if_needed=True)
bob_keypair_sig = keypairs.SigningKeypair(generate_keys_if_needed=True)
hrac = b'test'
# Test add PolicyContract
new_contract = test_keystore.add_policy_contract(
datetime.utcnow(), b'test', hrac, alice_pubkey_sig=alice_keypair_sig.pubkey,
alice_signature=b'test'
)
# Test get PolicyContract
query_contract = test_keystore.get_policy_contract(hrac)
assert new_contract == query_contract
# Test del PolicyContract
test_keystore.del_policy_contract(hrac)
with pytest.raises(keystore.NotFound):
del_key = test_keystore.get_policy_contract(hrac)
def gen_ecdsa_keypair(self, gen_priv=True) -> keypairs.SigningKeypair:
"""
Generates an ECDSA keypair.
TODO: Initalize keypair with provided data.
:param gen_priv: Generate private key or not?
:return ECDSA signing keypair
"""
ecdsa_keypair = keypairs.SigningKeypair()
if gen_priv:
ecdsa_keypair.gen_privkey()
return ecdsa_keypair
def setUp(self):
self.keypair = keypairs.SigningKeypair()
self.power = SigningPower(self.keypair)
def setUp(self):
self.ecies_keypair = keypairs.EncryptingKeypair()
self.ecdsa_keypair = keypairs.SigningKeypair()
