Merge branch 'develop' into add-release_eips-script

bigchaindb/__init__.py

@@ -3,7 +3,7 @@ import copy
 
 
 def e(key, default=None, conv=None):
-    '''Get the environment variable `key`, fallback to `default`
+    """Get the environment variable `key`, fallback to `default`
     if nothing is found.
 
     Keyword arguments:
@@ -11,7 +11,7 @@ def e(key, default=None, conv=None):
     default -- the default value if nothing is found (default: None)
     conv -- a callable used to convert the value (default: use the type of the
             default value)
-    '''
+    """
 
     val = os.environ.get(key, default)
 

bigchaindb/client.py

@@ -27,8 +27,8 @@ class Client:
             3. Reading them from the `config.json` file.
 
         Args:
-            public_key (str): the base58 encoded public key for the ECDSA secp256k1 curve.
+            public_key (str): the base58 encoded public key for the ED25519 curve.
-            private_key (str): the base58 encoded private key for the ECDSA secp256k1 curve.
+            private_key (str): the base58 encoded private key for the ED25519 curve.
             api_endpoint (str): a URL where rethinkdb is running.
                 format: scheme://hostname:port
             consensus_plugin (str): the registered name of your installed

bigchaindb/consensus.py

@@ -2,7 +2,7 @@ from abc import ABCMeta, abstractmethod
 
 import bigchaindb.exceptions as exceptions
 from bigchaindb import util
-from bigchaindb.crypto import hash_data, PublicKey
+from bigchaindb import crypto
 
 
 class AbstractConsensusRules(metaclass=ABCMeta):
@@ -156,7 +156,7 @@ class BaseConsensusRules(AbstractConsensusRules):
                         transaction['transaction']['input']))
 
         # Check hash of the transaction
-        calculated_hash = hash_data(util.serialize(
+        calculated_hash = crypto.hash_data(util.serialize(
             transaction['transaction']))
         if calculated_hash != transaction['id']:
             raise exceptions.InvalidHash()
@@ -185,7 +185,7 @@ class BaseConsensusRules(AbstractConsensusRules):
         """
 
         # Check if current hash is correct
-        calculated_hash = hash_data(util.serialize(block['block']))
+        calculated_hash = crypto.hash_data(util.serialize(block['block']))
         if calculated_hash != block['id']:
             raise exceptions.InvalidHash()
 

bigchaindb/core.py

@@ -41,8 +41,8 @@ class Bigchain(object):
             host (str): hostname where the rethinkdb is running.
             port (int): port in which rethinkb is running (usually 28015).
             dbname (str): the name of the database to connect to (usually bigchain).
-            public_key (str): the base58 encoded public key for the ECDSA secp256k1 curve.
+            public_key (str): the base58 encoded public key for the ED25519 curve.
-            private_key (str): the base58 encoded private key for the ECDSA secp256k1 curve.
+            private_key (str): the base58 encoded private key for the ED25519 curve.
             keyring (list[str]): list of base58 encoded public keys of the federation nodes.
         """
 
@@ -298,7 +298,7 @@ class Bigchain(object):
         # Calculate the hash of the new block
         block_data = util.serialize(block)
         block_hash = crypto.hash_data(block_data)
-        block_signature = crypto.PrivateKey(self.me_private).sign(block_data)
+        block_signature = crypto.SigningKey(self.me_private).sign(block_data).decode()
 
         block = {
             'id': block_hash,
@@ -419,7 +419,7 @@ class Bigchain(object):
         }
 
         vote_data = util.serialize(vote)
-        signature = crypto.PrivateKey(self.me_private).sign(vote_data)
+        signature = crypto.SigningKey(self.me_private).sign(vote_data).decode()
 
         vote_signed = {
             'node_pubkey': self.me,

bigchaindb/crypto.py

@@ -1,155 +1,17 @@
 # Separate all crypto code so that we can easily test several implementations
 
-import binascii
-import base58
-
 import sha3
-import bitcoin
+from cryptoconditions import ed25519
-
-from cryptography.hazmat.backends import default_backend
-from cryptography.hazmat.primitives.asymmetric import ec
-from cryptography.hazmat.primitives import hashes
-from cryptography.exceptions import InvalidSignature
-
-
-class PrivateKey(object):
-    """
-    PrivateKey instance
-    """
-
-    def __init__(self, key):
-        """
-        Instantiate the private key with the private_value encoded in base58
-        """
-        private_value = self.decode(key)
-        private_numbers = self._private_value_to_cryptography_private_numbers(private_value)
-        self.private_key = self._cryptography_private_key_from_private_numbers(private_numbers)
-
-    def sign(self, data):
-        """
-        Sign data with private key
-        """
-        signer = self.private_key.signer(ec.ECDSA(hashes.SHA256()))
-        signer.update(data.encode('utf-8'))
-        signature = signer.finalize()
-        return binascii.hexlify(signature).decode('utf-8')
-
-
-    @staticmethod
-    def encode(private_value):
-        """
-        Encode the decimal number private_value to base58
-        """
-        private_value_hex = bitcoin.encode_privkey(private_value, 'hex')
-        private_value_base58 = base58.b58encode(bytes.fromhex(private_value_hex))
-        return private_value_base58
-
-    @staticmethod
-    def decode(key):
-        """
-        Decode the base58 private_value to decimale
-        """
-        private_value_hex = binascii.hexlify(base58.b58decode(key))
-        private_value = bitcoin.decode_privkey(private_value_hex)
-        return private_value
-
-    def _private_value_to_public_values(self, private_value):
-        """
-        Return the public values from the private value
-        """
-        public_value_x, public_value_y = bitcoin.privkey_to_pubkey(private_value)
-        return (public_value_x, public_value_y)
-
-    def _private_value_to_cryptography_private_numbers(self, private_value):
-        """
-        Return an instance of cryptography PrivateNumbers from the decimal private_value
-        """
-        public_value_x, public_value_y = self._private_value_to_public_values(private_value)
-        public_numbers = PublicKey._public_values_to_cryptography_public_numbers(public_value_x, public_value_y)
-        private_numbers = ec.EllipticCurvePrivateNumbers(private_value, public_numbers)
-        return private_numbers
-
-    @staticmethod
-    def _cryptography_private_key_from_private_numbers(private_numbers):
-        """
-        Return an instace of cryptography PrivateKey from a cryptography instance of PrivateNumbers
-        """
-        return private_numbers.private_key(default_backend())
-
-
-class PublicKey(object):
-
-    def __init__(self, key):
-        """
-        Instantiate the public key with the compressed public value encoded in base58
-        """
-        public_value_x, public_value_y = self.decode(key)
-        public_numbers = self._public_values_to_cryptography_public_numbers(public_value_x, public_value_y)
-        self.public_key = self._criptography_public_key_from_public_numbers(public_numbers)
-
-    def verify(self, data, signature):
-        verifier = self.public_key.verifier(binascii.unhexlify(signature), ec.ECDSA(hashes.SHA256()))
-        verifier.update(data.encode('utf-8'))
-        try:
-            verifier.verify()
-        except InvalidSignature:
-            return False
-
-        return True
-
-    @staticmethod
-    def encode(public_value_x, public_value_y):
-        """
-        Encode the public key represented by the decimal values x and y to base58
-        """
-        public_value_compressed_hex = bitcoin.encode_pubkey([public_value_x, public_value_y], 'hex_compressed')
-        public_value_compressed_base58 = base58.b58encode(bytes.fromhex(public_value_compressed_hex))
-        return public_value_compressed_base58
-
-    @staticmethod
-    def decode(public_value_compressed_base58):
-        """
-        Decode the base58 public_value to the decimal x and y values
-        """
-        public_value_compressed_hex = binascii.hexlify(base58.b58decode(public_value_compressed_base58))
-        public_value_x, public_value_y = bitcoin.decode_pubkey(public_value_compressed_hex.decode())
-        return (public_value_x, public_value_y)
-
-    @staticmethod
-    def _public_values_to_cryptography_public_numbers(public_value_x, public_value_y):
-        """
-        Return an instance of cryptography PublicNumbers from the decimal x and y values
-        """
-        public_numbers = ec.EllipticCurvePublicNumbers(public_value_x, public_value_y, ec.SECP256K1())
-        return public_numbers
-
-    def _criptography_public_key_from_public_numbers(self, public_numbers):
-        """
-        Return an instance of cryptography PublicKey from a cryptography instance of PublicNumbers
-        """
-        return public_numbers.public_key(default_backend())
-
-
-def generate_key_pair():
-    """
-    Generate a new key pair and return the pair encoded in base58
-    """
-    # Private key
-    private_key = ec.generate_private_key(ec.SECP256K1, default_backend())
-    private_value = private_key.private_numbers().private_value
-    private_value_base58 = PrivateKey.encode(private_value)
-
-    # Public key
-    public_key = private_key.public_key()
-    public_value_x, public_value_y = public_key.public_numbers().x, public_key.public_numbers().y
-    public_value_compressed_base58 = PublicKey.encode(public_value_x, public_value_y)
-
-    return (private_value_base58, public_value_compressed_base58)
 
 
 def hash_data(data):
     """Hash the provided data using SHA3-256"""
-
     return sha3.sha3_256(data.encode()).hexdigest()
 
 
+def generate_key_pair():
+    sk, pk = ed25519.ed25519_generate_key_pair()
+    return sk.decode(), pk.decode()
+
+SigningKey = ed25519.Ed25519SigningKey
+VerifyingKey = ed25519.Ed25519VerifyingKey

bigchaindb/util.py

@@ -6,7 +6,7 @@ from datetime import datetime
 
 import bigchaindb
 from bigchaindb import exceptions
-from bigchaindb.crypto import PrivateKey, PublicKey, hash_data
+from bigchaindb import crypto
 
 
 class ProcessGroup(object):
@@ -109,7 +109,7 @@ def create_tx(current_owner, new_owner, tx_input, operation, payload=None):
     data = None
     if payload is not None:
         if isinstance(payload, dict):
-            hash_payload = hash_data(serialize(payload))
+            hash_payload = crypto.hash_data(serialize(payload))
             data = {
                 'hash': hash_payload,
                 'payload': payload
@@ -117,7 +117,7 @@ def create_tx(current_owner, new_owner, tx_input, operation, payload=None):
         else:
             raise TypeError('`payload` must be an dict instance')
 
-    hash_payload = hash_data(serialize(payload))
+    hash_payload = crypto.hash_data(serialize(payload))
     data = {
         'hash': hash_payload,
         'payload': payload
@@ -134,7 +134,7 @@ def create_tx(current_owner, new_owner, tx_input, operation, payload=None):
 
     # serialize and convert to bytes
     tx_serialized = serialize(tx)
-    tx_hash = hash_data(tx_serialized)
+    tx_hash = crypto.hash_data(tx_serialized)
 
     # create the transaction
     transaction = {
@@ -158,10 +158,10 @@ def sign_tx(transaction, private_key):
         dict: transaction with the `signature` field included.
 
     """
-    private_key = PrivateKey(private_key)
+    private_key = crypto.SigningKey(private_key)
     signature = private_key.sign(serialize(transaction))
     signed_transaction = transaction.copy()
-    signed_transaction.update({'signature': signature})
+    signed_transaction.update({'signature': signature.decode()})
     return signed_transaction
 
 
@@ -172,7 +172,7 @@ def create_and_sign_tx(private_key, current_owner, new_owner, tx_input, operatio
 
 def check_hash_and_signature(transaction):
     # Check hash of the transaction
-    calculated_hash = hash_data(serialize(transaction['transaction']))
+    calculated_hash = crypto.hash_data(serialize(transaction['transaction']))
     if calculated_hash != transaction['id']:
         raise exceptions.InvalidHash()
 
@@ -201,7 +201,7 @@ def verify_signature(signed_transaction):
 
     signature = data.pop('signature')
     public_key_base58 = signed_transaction['transaction']['current_owner']
-    public_key = PublicKey(public_key_base58)
+    public_key = crypto.VerifyingKey(public_key_base58)
     return public_key.verify(serialize(data), signature)
 
 

docs/source/cryptography.md

@@ -19,8 +19,8 @@ tx_hash = hashlib.sha3_256(data).hexdigest()
 
 ## Signature algorithm and keys
 
-The signature algorithm used by BigchainDB is ECDSA with the secp256k1 curve
+The signature algorithm used by BigchainDB is [ED25519](https://tools.ietf.org/html/draft-irtf-cfrg-eddsa-04)
-using the python [cryptography](https://cryptography.io/en/latest/) module.
+using the python [ed25519](https://github.com/warner/python-ed25519) module, overloaded by the [cryptoconditions library](https://github.com/bigchaindb/cryptoconditions).
 
 The private key is the base58 encoded hexadecimal representation of private number.
 The public key is the base58 encoded hexadecimal representation of the

setup.py

@@ -71,7 +71,7 @@ setup(
         'rethinkdb==2.2.0.post4',
         'pysha3==0.3',
         'pytz==2015.7',
-        'cryptography==1.2.3',
+        'cryptoconditions==0.1.1',
         'statsd==3.2.1',
         'python-rapidjson==0.0.6',
         'logstats==0.2.1',

tests/conftest.py

@@ -19,14 +19,14 @@ CONFIG = {
         'name': DB_NAME
     },
     'keypair': {
-        'private': '3i2FDXp87N9ExXSvWxqBAw9EgzoxxGTQNKbtxmWBpTyL',
+        'private': '31Lb1ZGKTyHnmVK3LUMrAUrPNfd4sE2YyBt3UA4A25aA',
-        'public': '29Tw3ozmSRtN8XNofvsu5RdoQRk9gAonfpkFvRZDmhTPo'
+        'public': '4XYfCbabAWVUCbjTmRTFEu2sc3dFEdkse4r6X498B1s8'
     }
 }
 
 # Test user. inputs will be created for this user. Cryptography Keys
-USER_PRIVATE_KEY = 'GmRZxQdQv7tooMijXytQkexKuFN6mJocciJarAmMwTX2'
+USER_PRIVATE_KEY = '8eJ8q9ZQpReWyQT5aFCiwtZ5wDZC4eDnCen88p3tQ6ie'
-USER_PUBLIC_KEY = 'r3cEu8GNoz8rYpNJ61k7GqfR8VEvdUbtyHce8u1kaYwh'
+USER_PUBLIC_KEY = 'JEAkEJqLbbgDRAtMm8YAjGp759Aq2qTn9eaEHUj2XePE'
 
 
 @pytest.fixture

tests/db/test_bigchain_api.py

@@ -8,7 +8,7 @@ import rethinkdb as r
 import bigchaindb
 from bigchaindb import util
 from bigchaindb import exceptions
-from bigchaindb.crypto import PrivateKey, PublicKey, generate_key_pair, hash_data
+from bigchaindb import crypto
 from bigchaindb.voter import Voter
 from bigchaindb.block import Block
 
@@ -44,7 +44,7 @@ class TestBigchainApi(object):
             'operation': 'd',
             'timestamp': tx['transaction']['timestamp'],
             'data': {
-                'hash': hash_data(util.serialize(payload)),
+                'hash': crypto.hash_data(util.serialize(payload)),
                 'payload': payload
             }
         }
@@ -52,7 +52,7 @@ class TestBigchainApi(object):
         # assert tx_hash == tx_calculated_hash
 
     def test_transaction_signature(self, b):
-        sk, vk = generate_key_pair()
+        sk, vk = crypto.generate_key_pair()
         tx = b.create_transaction(vk, 'b', 'c', 'd')
         tx_signed = b.sign_transaction(tx, sk)
 
@@ -108,7 +108,7 @@ class TestBigchainApi(object):
     def test_assign_transaction_multiple_nodes(self, b, user_public_key, user_private_key):
         # create 5 federation nodes
         for _ in range(5):
-            b.federation_nodes.append(generate_key_pair()[1])
+            b.federation_nodes.append(crypto.generate_key_pair()[1])
 
         # test assignee for several transactions
         for _ in range(20):
@@ -185,11 +185,11 @@ class TestBigchainApi(object):
 
     def test_create_new_block(self, b):
         new_block = b.create_block([])
-        block_hash = hash_data(util.serialize(new_block['block']))
+        block_hash = crypto.hash_data(util.serialize(new_block['block']))
 
         assert new_block['block']['voters'] == [b.me]
         assert new_block['block']['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(util.serialize(new_block['block']), new_block['signature']) is True
+        assert crypto.VerifyingKey(b.me).verify(util.serialize(new_block['block']), new_block['signature']) is True
         assert new_block['id'] == block_hash
         assert new_block['votes'] == []
 
@@ -371,8 +371,8 @@ class TestBlockValidation(object):
         }
 
         block_data = util.serialize(block)
-        block_hash = hash_data(block_data)
+        block_hash = crypto.hash_data(block_data)
-        block_signature = PrivateKey(b.me_private).sign(block_data)
+        block_signature = crypto.SigningKey(b.me_private).sign(block_data)
 
         block = {
             'id': block_hash,
@@ -408,45 +408,6 @@ class TestBlockValidation(object):
         assert b.is_valid_block(block)
 
 
-class TestBigchainCrypto(object):
-    PRIVATE_VALUE = 64328150571824492670917070117568709277186368319388887463636481841106388379832
-    PUBLIC_VALUE_X = 48388170575736684074633245566225141536152842355597159440179742847497614196929
-    PUBLIC_VALUE_Y = 65233479152484407841598798165960909560839872511163322973341535484598825150846
-
-    PRIVATE_VALUE_B58 = 'AaAp4xBavbe6VGeQF2mWdSKNM1r6HfR2Z1tAY6aUkwdq'
-    PUBLIC_VALUE_COMPRESSED_B58 = 'ifEi3UuTDT4CqUUKiS5omgeDodhu2aRFHVp6LoahbEVe'
-
-    def test_private_key_encode(self):
-        private_value_base58 = PrivateKey.encode(self.PRIVATE_VALUE)
-        assert private_value_base58 == self.PRIVATE_VALUE_B58
-
-    def test_private_key_decode(self):
-        private_value = PrivateKey.decode(self.PRIVATE_VALUE_B58)
-        assert private_value == self.PRIVATE_VALUE
-
-    def test_public_key_encode(self):
-        public_value_compressed_base58 = PublicKey.encode(self.PUBLIC_VALUE_X, self.PUBLIC_VALUE_Y)
-        assert public_value_compressed_base58 == self.PUBLIC_VALUE_COMPRESSED_B58
-
-    def test_public_key_decode(self):
-        public_value_x, public_value_y = PublicKey.decode(self.PUBLIC_VALUE_COMPRESSED_B58)
-        assert public_value_x == self.PUBLIC_VALUE_X
-        assert public_value_y == self.PUBLIC_VALUE_Y
-
-    def test_sign_verify(self):
-        message = 'Hello World!'
-        public_key = PublicKey(self.PUBLIC_VALUE_COMPRESSED_B58)
-        private_key = PrivateKey(self.PRIVATE_VALUE_B58)
-        assert public_key.verify(message, private_key.sign(message)) is True
-
-    def test_generate_key_pair(self):
-        private_value_base58, public_value_compressed_base58 = generate_key_pair()
-        assert PrivateKey.encode(
-            PrivateKey.decode(private_value_base58)) == private_value_base58
-        assert PublicKey.encode(
-            *PublicKey.decode(public_value_compressed_base58)) == public_value_compressed_base58
-
-
 class TestBigchainVoter(object):
 
     def test_valid_block_voting(self, b):
@@ -483,7 +444,7 @@ class TestBigchainVoter(object):
         assert vote['vote']['is_block_valid'] is True
         assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
+        assert crypto.VerifyingKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
 
     def test_invalid_block_voting(self, b, user_public_key):
         # create queue and voter
@@ -524,7 +485,7 @@ class TestBigchainVoter(object):
         assert vote['vote']['is_block_valid'] is False
         assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
+        assert crypto.VerifyingKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
 
     def test_vote_creation_valid(self, b):
         # create valid block
@@ -538,7 +499,7 @@ class TestBigchainVoter(object):
         assert vote['vote']['is_block_valid'] is True
         assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
+        assert crypto.VerifyingKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
 
     def test_vote_creation_invalid(self, b):
         # create valid block
@@ -552,7 +513,7 @@ class TestBigchainVoter(object):
         assert vote['vote']['is_block_valid'] is False
         assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
+        assert crypto.VerifyingKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
 
 
 class TestBigchainBlock(object):

tests/db/test_voter.py

@@ -6,7 +6,7 @@ import multiprocessing as mp
 from bigchaindb import util
 
 from bigchaindb.voter import Voter, BlockStream
-from bigchaindb.crypto import PublicKey, generate_key_pair
+from bigchaindb import crypto
 
 
 class TestBigchainVoter(object):
@@ -45,7 +45,7 @@ class TestBigchainVoter(object):
         assert vote['vote']['is_block_valid'] is True
         assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
+        assert crypto.VerifyingKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
 
     def test_valid_block_voting_with_create_transaction(self, b):
         q_new_block = mp.Queue()
@@ -53,7 +53,7 @@ class TestBigchainVoter(object):
         genesis = b.create_genesis_block()
 
         # create a `CREATE` transaction
-        test_user_priv, test_user_pub = generate_key_pair()
+        test_user_priv, test_user_pub = crypto.generate_key_pair()
         tx = b.create_transaction(b.me, test_user_pub, None, 'CREATE')
         tx_signed = b.sign_transaction(tx, b.me_private)
         assert b.is_valid_transaction(tx_signed)
@@ -87,7 +87,7 @@ class TestBigchainVoter(object):
         assert vote['vote']['is_block_valid'] is True
         assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
+        assert crypto.VerifyingKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
 
     def test_valid_block_voting_with_transfer_transactions(self, b):
         q_new_block = mp.Queue()
@@ -95,7 +95,7 @@ class TestBigchainVoter(object):
         b.create_genesis_block()
 
         # create a `CREATE` transaction
-        test_user_priv, test_user_pub = generate_key_pair()
+        test_user_priv, test_user_pub = crypto.generate_key_pair()
         tx = b.create_transaction(b.me, test_user_pub, None, 'CREATE')
         tx_signed = b.sign_transaction(tx, b.me_private)
         assert b.is_valid_transaction(tx_signed)
@@ -124,7 +124,7 @@ class TestBigchainVoter(object):
         assert len(blocks[1]['votes']) == 1
 
         # create a `TRANSFER` transaction
-        test_user2_priv, test_user2_pub = generate_key_pair()
+        test_user2_priv, test_user2_pub = crypto.generate_key_pair()
         tx2 = b.create_transaction(test_user_pub, test_user2_pub, tx['id'], 'TRANSFER')
         tx2_signed = b.sign_transaction(tx2, test_user_priv)
         assert b.is_valid_transaction(tx2_signed)
@@ -158,7 +158,7 @@ class TestBigchainVoter(object):
         assert vote['vote']['is_block_valid'] is True
         assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
+        assert crypto.VerifyingKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
 
     def test_invalid_block_voting(self, b, user_public_key):
         # create queue and voter
@@ -197,7 +197,7 @@ class TestBigchainVoter(object):
         assert vote['vote']['is_block_valid'] is False
         assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
+        assert crypto.VerifyingKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
 
     def test_vote_creation_valid(self, b):
         # create valid block
@@ -211,7 +211,7 @@ class TestBigchainVoter(object):
         assert vote['vote']['is_block_valid'] is True
         assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
+        assert crypto.VerifyingKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
 
     def test_vote_creation_invalid(self, b):
         # create valid block
@@ -225,7 +225,7 @@ class TestBigchainVoter(object):
         assert vote['vote']['is_block_valid'] is False
         assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
+        assert crypto.VerifyingKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
 
     def test_voter_considers_unvoted_blocks_when_single_node(self, b):
         # simulate a voter going donw in a single node environment
@@ -301,7 +301,7 @@ class TestBlockStream(object):
 
     def test_if_federation_size_is_greater_than_one_ignore_past_blocks(self, b):
         for _ in range(5):
-            b.federation_nodes.append(generate_key_pair()[1])
+            b.federation_nodes.append(crypto.generate_key_pair()[1])
         new_blocks = mp.Queue()
         bs = BlockStream(new_blocks)
         block_1 = b.create_block([])