Nucypher
/
nucypher
mirror of https://github.com/nucypher/nucypher.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

PublicKey used for metadata instead of int literals throughout tests. Also some PEP8 cleanups and removal of type checks per #105.

pull/124/head
jMyles 2017-11-18 13:19:07 -08:00
parent 5a36280788
commit ad0eb40a4d
5 changed files with 23 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/characters/test_crypto_characters_and_their_powers.py
View File

@ -47,7 +47,7 @@ def test_actor_with_signing_power_can_sign():
# ...or to get the signer's public key for verification purposes.
sig = api.ecdsa_load_sig(bytes(signature))
verification = api.ecdsa_verify(*sig, api.keccak_digest(message), seal_of_the_signer)
verification = api.ecdsa_verify(*sig, api.keccak_digest(message), seal_of_the_signer.without_metabytes())
assert verification is True

23
tests/crypto/test_api.py
View File

@ -1,10 +1,13 @@
import unittest
import random
import unittest
import sha3
from nacl.utils import EncryptedMessage
from npre import umbral
from npre import elliptic_curve as ec
from nkms.crypto import api
from nkms.keystore.keypairs import PublicKey
from npre import elliptic_curve as ec
from npre import umbral
class TestCrypto(unittest.TestCase):
@ -85,7 +88,7 @@ class TestCrypto(unittest.TestCase):
pubkey_bytes = api.ecdsa_priv2pub(privkey)
self.assertEqual(bytes, type(pubkey_bytes))
pubkey = api.ecdsa_bytes2pub(pubkey_bytes)
pubkey = api.ecdsa_bytes2pub(pubkey_bytes[PublicKey._METABYTES_LENGTH::])
self.assertEqual(tuple, type(pubkey))
self.assertEqual(2, len(pubkey))
self.assertEqual(int, type(pubkey[0]))
@ -106,7 +109,7 @@ class TestCrypto(unittest.TestCase):
# Test Serialization
pubkey = api.ecdsa_priv2pub(privkey)
self.assertEqual(bytes, type(pubkey))
self.assertEqual(64, len(pubkey))
self.assertEqual(PublicKey._EXPECTED_LENGTH, len(pubkey))
# Test no serialization
pubkey = api.ecdsa_priv2pub(privkey, to_bytes=False)
@ -271,7 +274,7 @@ class TestCrypto(unittest.TestCase):
# Check no serialization
rekey = api.ecies_rekey(self.privkey_a_bytes, self.privkey_b_bytes,
to_bytes=False)
to_bytes=False)
self.assertEqual(umbral.RekeyFrag, type(rekey))
self.assertEqual(ec.ec_element, type(rekey.key))
@ -283,7 +286,7 @@ class TestCrypto(unittest.TestCase):
# Check with conversion
frags = api.ecies_split_rekey(self.privkey_a_bytes,
self.privkey_b_bytes, 3, 4)
self.privkey_b_bytes, 3, 4)
self.assertEqual(list, type(frags))
self.assertEqual(4, len(frags))
@ -338,14 +341,10 @@ class TestCrypto(unittest.TestCase):
self.assertEqual(32, len(plain_key))
rk_eb = api.ecies_rekey(eph_priv, self.privkey_b,
to_bytes=False)
to_bytes=False)
self.assertEqual(umbral.RekeyFrag, type(rk_eb))
self.assertEqual(ec.ec_element, type(rk_eb.key))
reenc_key = api.ecies_reencrypt(rk_eb, enc_key)
dec_key = api.ecies_decapsulate(self.privkey_b, reenc_key)
self.assertEqual(plain_key, dec_key)
def test_alpha_is_resolved(self):
with self.assertRaises(ImportError):
from nkms.crypto import _alpha

17
tests/keystore/test_keypairs.py
View File

@ -1,6 +1,7 @@
import unittest
from nkms.crypto import api as API
from nkms.keystore import keypairs
from nkms.keystore.keypairs import PublicKey
class TestKeypairs(unittest.TestCase):
@ -27,8 +28,7 @@ class TestKeypairs(unittest.TestCase):
self.assertEqual(32, len(self.ecdsa_keypair.privkey))
self.assertTrue(self.ecdsa_keypair.pubkey is not None)
self.assertEqual(bytes, type(self.ecdsa_keypair.pubkey))
self.assertEqual(64, len(self.ecdsa_keypair.pubkey))
self.assertEqual(PublicKey._EXPECTED_LENGTH, len(self.ecdsa_keypair.pubkey))
def test_ecdsa_keypair_signing(self):
msghash = API.keccak_digest(b'hello world!')
@ -64,8 +64,7 @@ class TestKeypairs(unittest.TestCase):
self.assertEqual(bytes, type(keypair.privkey))
self.assertEqual(32, len(keypair.privkey))
self.assertEqual(bytes, type(keypair.pubkey))
self.assertEqual(64, len(keypair.pubkey))
self.assertEqual(PublicKey._EXPECTED_LENGTH, len(keypair.pubkey))
# Test no keys (key generation)
keypair = keypairs.SigningKeypair()
@ -74,8 +73,7 @@ class TestKeypairs(unittest.TestCase):
self.assertEqual(bytes, type(keypair.privkey))
self.assertEqual(32, len(keypair.privkey))
self.assertEqual(bytes, type(keypair.pubkey))
self.assertEqual(64, len(keypair.pubkey))
self.assertEqual(PublicKey._EXPECTED_LENGTH, len(keypair.pubkey))
# Test privkey only
keypair = keypairs.SigningKeypair(privkey=self.ecdsa_keypair.privkey)
@ -83,13 +81,10 @@ class TestKeypairs(unittest.TestCase):
self.assertEqual(bytes, type(keypair.privkey))
self.assertEqual(32, len(keypair.privkey))
self.assertEqual(bytes, type(keypair.pubkey))
self.assertEqual(64, len(keypair.pubkey))
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(bytes, type(keypair.pubkey))
self.assertEqual(64, len(keypair.pubkey))
self.assertEqual(PublicKey._EXPECTED_LENGTH, len(keypair.pubkey))

1
tests/keystore/test_keystore.py
View File

@ -24,7 +24,6 @@ class TestKeyStore(unittest.TestCase):
keypair = self.ks.generate_signing_keypair()
self.assertEqual(keypairs.SigningKeypair, type(keypair))
self.assertEqual(bytes, type(keypair.privkey))
self.assertEqual(bytes, type(keypair.pubkey))
def test_key_sqlite_keystore(self):
keypair = self.ks.generate_encrypting_keypair()

11
tests/network/test_network_actors.py
View File

@ -6,9 +6,6 @@ import pytest
from kademlia.utils import digest
from nkms.characters import Ursula, Alice, Character, Bob, congregate
from nkms.crypto.constants import PUBKEY_SIG_LENGTH, HASH_DIGEST_LENGTH
from nkms.crypto.signature import Signature
from nkms.crypto.utils import BytestringSplitter
from nkms.network.blockchain_client import list_all_ursulas
from nkms.network.protocols import dht_value_splitter
from nkms.policy.constants import NON_PAYMENT
@ -113,7 +110,8 @@ def test_alice_finds_ursula():
getter = ALICE.server.get(all_ursulas[ursula_index])
loop = asyncio.get_event_loop()
value = loop.run_until_complete(getter)
_signature, _ursula_pubkey_sig, _hrac, interface_info = dht_value_splitter(value.lstrip(b"uaddr-"), return_remainder=True)
_signature, _ursula_pubkey_sig, _hrac, interface_info = dht_value_splitter(value.lstrip(b"uaddr-"),
return_remainder=True)
port = msgpack.loads(interface_info)[0]
assert port == URSULA_PORT + ursula_index
@ -174,7 +172,7 @@ def test_treasure_map_with_bad_id_does_not_propagate():
treasure_map = policy_group.treasure_map
encrypted_treasure_map, signature = ALICE.encrypt_for(BOB, treasure_map.packed_payload())
packed_encrypted_treasure_map = msgpack.dumps(encrypted_treasure_map) #TODO: #114? Do we even need to pack here?
packed_encrypted_treasure_map = msgpack.dumps(encrypted_treasure_map) # TODO: #114? Do we even need to pack here?
setter = ALICE.server.set(illegal_policygroup_id, packed_encrypted_treasure_map)
_set_event = EVENT_LOOP.run_until_complete(setter)
@ -226,6 +224,7 @@ def test_treaure_map_is_legit():
getter = ALICE.server.get(ursula_interface_id)
loop = asyncio.get_event_loop()
value = loop.run_until_complete(getter)
signature, ursula_pubkey_sig, hrac, interface_info = dht_value_splitter(value.lstrip(b"uaddr-"), return_remainder=True)
signature, ursula_pubkey_sig, hrac, interface_info = dht_value_splitter(value.lstrip(b"uaddr-"),
return_remainder=True)
port = msgpack.loads(interface_info)[0]
assert port in URSULA_PORTS