- Ed25519 inheritance

- Renamed Private/PublicKey to Signing/VerifyingKey

bigchaindb/core.py

@@ -96,7 +96,7 @@ class Bigchain(object):
 
         signature = data.pop('signature')
         public_key_base58 = signed_transaction['transaction']['current_owner']
-        public_key = asymmetric.PublicKey(public_key_base58)
+        public_key = asymmetric.VerifyingKey(public_key_base58)
         return public_key.verify(util.serialize(data), signature)
 
     @monitor.timer('write_transaction', rate=bigchaindb.config['statsd']['rate'])
@@ -330,7 +330,7 @@ class Bigchain(object):
         # Calculate the hash of the new block
         block_data = util.serialize(block)
         block_hash = asymmetric.hash_data(block_data)
-        block_signature = asymmetric.PrivateKey(self.me_private).sign(block_data)
+        block_signature = asymmetric.SigningKey(self.me_private).sign(block_data)
 
         block = {
             'id': block_hash,
@@ -450,7 +450,7 @@ class Bigchain(object):
         }
 
         vote_data = util.serialize(vote)
-        signature = asymmetric.PrivateKey(self.me_private).sign(vote_data)
+        signature = asymmetric.SigningKey(self.me_private).sign(vote_data)
 
         vote_signed = {
             'node_pubkey': self.me,

bigchaindb/crypto/asymmetric.py

@@ -4,7 +4,7 @@ from abc import ABCMeta, abstractmethod
 import sha3
 
 
-class PrivateKey(metaclass=ABCMeta):
+class SigningKey(metaclass=ABCMeta):
     """
     PrivateKey instance
     """
@@ -13,6 +13,9 @@ class PrivateKey(metaclass=ABCMeta):
     def sign(self, data):
         """
         Sign data with private key
+
+        Args:
+            data:
         """
         raise NotImplementedError
 
@@ -20,20 +23,26 @@ class PrivateKey(metaclass=ABCMeta):
     @abstractmethod
     def encode(private_value):
         """
-        Encode the decimal number private_value to base58
+        Encode the internal private_value to base58
+
+        Args:
+            private_value:
         """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
-    def decode(key):
+    def decode(private_base58):
         """
-        Decode the base58 private_value to decimale
+        Decode the base58 private value to internal value
+
+        Args:
+            private_base58 (base58):
         """
         raise NotImplementedError
 
 
-class PublicKey(metaclass=ABCMeta):
+class VerifyingKey(metaclass=ABCMeta):
 
     @abstractmethod
     def verify(self, data, signature):
@@ -41,17 +50,23 @@ class PublicKey(metaclass=ABCMeta):
 
     @staticmethod
     @abstractmethod
-    def encode(public_value_x, public_value_y):
+    def encode(public_value):
         """
-        Encode the public key represented by the decimal values x and y to base58
+        Encode the public key to base58 represented by the internal values
+
+        Args:
+            public_value
         """
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
-    def decode(public_value_compressed_base58):
+    def decode(public_base58):
         """
-        Decode the base58 public_value to the decimal x and y values
+        Decode the base58 public_value to internal value
+
+        Args:
+            public_base58 (base58):
         """
         raise NotImplementedError
 
@@ -62,8 +77,8 @@ def hash_data(data):
     return sha3.sha3_256(data.encode()).hexdigest()
 
 
-from bigchaindb.crypto.ecdsa import ECDSAPrivateKey, ECDSAPublicKey, ecdsa_generate_key_pair
+from bigchaindb.crypto.ecdsa import EcdsaSigningKey, EcdsaVerifyingKey, ecdsa_generate_key_pair
 
-PrivateKey = ECDSAPrivateKey
+SigningKey = EcdsaSigningKey
-PublicKey = ECDSAPublicKey
+VerifyingKey = EcdsaVerifyingKey
 generate_key_pair = ecdsa_generate_key_pair

bigchaindb/crypto/bitmark_registry.py

@@ -1,4 +1,4 @@
-from bigchaindb.crypto.iostream import MAX_SAFE_INTEGER
+from bigchaindb.crypto.buffer import MAX_SAFE_INTEGER
 
 
 class BitmaskRegistry:

bigchaindb/crypto/condition.py

@@ -4,7 +4,7 @@ from abc import ABCMeta
 
 from six import string_types
 
-from bigchaindb.crypto.iostream import base64_add_padding, base64_remove_padding, Writer, Reader
+from bigchaindb.crypto.buffer import base64_add_padding, base64_remove_padding, Writer, Reader
 
 CONDITION_REGEX = r'^cc:1:[1-9a-f][0-9a-f]{0,2}:[a-zA-Z0-9_-]{43}:[1-9][0-9]{0,50}$'
 
@@ -123,9 +123,6 @@ class Condition(metaclass=ABCMeta):
         Args:
             value (Buffer): Hash as binary.
         """
-        # TODO: value must be Buffer
-        # if not isinstance(value, Buffer):
-        #   raise ValueError
         self._hash = value
 
     @property

bigchaindb/crypto/ecdsa.py

@@ -9,10 +9,10 @@ from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.asymmetric import ec
 
-from bigchaindb.crypto.asymmetric import PrivateKey, PublicKey
+from bigchaindb.crypto.asymmetric import SigningKey, VerifyingKey
 
 
-class ECDSAPrivateKey(PrivateKey):
+class EcdsaSigningKey(SigningKey):
     """
     PrivateKey instance
     """
@@ -34,7 +34,6 @@ class ECDSAPrivateKey(PrivateKey):
         signature = signer.finalize()
         return binascii.hexlify(signature).decode('utf-8')
 
-
     @staticmethod
     def encode(private_value):
         """
@@ -65,7 +64,7 @@ class ECDSAPrivateKey(PrivateKey):
         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 = ECDSAPublicKey._public_values_to_cryptography_public_numbers(public_value_x, public_value_y)
+        public_numbers = EcdsaVerifyingKey._public_values_to_cryptography_public_numbers(public_value_x, public_value_y)
         private_numbers = ec.EllipticCurvePrivateNumbers(private_value, public_numbers)
         return private_numbers
 
@@ -77,11 +76,14 @@ class ECDSAPrivateKey(PrivateKey):
         return private_numbers.private_key(default_backend())
 
 
-class ECDSAPublicKey(PublicKey):
+class EcdsaVerifyingKey(VerifyingKey):
 
     def __init__(self, key):
         """
         Instantiate the public key with the compressed public value encoded in base58
+
+        Args:
+            key
         """
         public_value_x, public_value_y = self.decode(key)
         public_numbers = self._public_values_to_cryptography_public_numbers(public_value_x, public_value_y)
@@ -101,6 +103,10 @@ class ECDSAPublicKey(PublicKey):
     def encode(public_value_x, public_value_y):
         """
         Encode the public key represented by the decimal values x and y to base58
+
+        Args:
+            public_value_x:
+            public_value_y:
         """
         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))
@@ -110,6 +116,9 @@ class ECDSAPublicKey(PublicKey):
     def decode(public_value_compressed_base58):
         """
         Decode the base58 public_value to the decimal x and y values
+
+        Args:
+            public_value_compressed_base58:
         """
         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())
@@ -126,6 +135,9 @@ class ECDSAPublicKey(PublicKey):
     def _cryptography_public_key_from_public_numbers(self, public_numbers):
         """
         Return an instance of cryptography PublicKey from a cryptography instance of PublicNumbers
+
+        Args:
+            public_numbers
         """
         return public_numbers.public_key(default_backend())
 
@@ -137,11 +149,11 @@ def ecdsa_generate_key_pair():
     # Private key
     private_key = ec.generate_private_key(ec.SECP256K1, default_backend())
     private_value = private_key.private_numbers().private_value
-    private_value_base58 = ECDSAPrivateKey.encode(private_value)
+    private_value_base58 = EcdsaSigningKey.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 = ECDSAPublicKey.encode(public_value_x, public_value_y)
+    public_value_compressed_base58 = EcdsaVerifyingKey.encode(public_value_x, public_value_y)
 
     return (private_value_base58, public_value_compressed_base58)

bigchaindb/crypto/ed25519.py

@@ -5,10 +5,10 @@ import base64
 import base58
 import ed25519
 
-from bigchaindb.crypto.asymmetric import PrivateKey, PublicKey
+from bigchaindb.crypto.asymmetric import SigningKey, VerifyingKey
 
 
-class ED25519PrivateKey(PrivateKey):
+class Ed25519SigningKey(ed25519.SigningKey, SigningKey):
     """
     PrivateKey instance
     """
@@ -16,22 +16,31 @@ class ED25519PrivateKey(PrivateKey):
     def __init__(self, key):
         """
         Instantiate the private key with the private_value encoded in base58
+
+        Args:
+            key (base58): base58 encoded private key
         """
         private_base64 = self.decode(key)
-        self.private_key = self._private_key_from_private_base64(private_base64)
+        super().__init__(private_base64, encoding='base64')
 
     def sign(self, data, encoding="base64"):
         """
         Sign data with private key
+
+        Args:
+            data (str, bytes): data to sign
+            encoding (str): base64, hex
         """
         if not isinstance(data, bytes):
             data = data.encode('utf-8')
-        return self.private_key.sign(data, encoding=encoding)
+        return super().sign(data, encoding=encoding)
 
     @staticmethod
     def encode(private_base64):
         """
         Encode the base64 number private_base64 to base58
+        Args:
+            private_base64:
         """
         return base58.b58encode(base64.b64decode(private_base64))
 
@@ -39,31 +48,27 @@ class ED25519PrivateKey(PrivateKey):
     def decode(key):
         """
         Decode the base58 private_value to base64
+
+        Args:
+            key:
         """
         return base64.b64encode(base58.b58decode(key))
 
-    @staticmethod
-    def _private_key_from_private_base64(private_base64):
-        """
-        Return an instance of a ED25519 SignigKey from a base64 key
-        """
-        return ed25519.SigningKey(private_base64, encoding='base64')
 
-
+class Ed25519VerifyingKey(ed25519.VerifyingKey, VerifyingKey):
-class ED25519PublicKey(PublicKey):
 
     def __init__(self, key):
         """
         Instantiate the public key with the compressed public value encoded in base58
         """
         public_base64 = self.decode(key)
-        self.public_key = self._public_key_from_public_base64(public_base64)
+        super().__init__(public_base64, encoding='base64')
 
     def verify(self, data, signature, encoding='base64'):
         try:
             if encoding:
                 data = data.encode('utf-8')
-            self.public_key.verify(signature, data, encoding=encoding)
+            super().verify(signature, data, encoding=encoding)
         except ed25519.BadSignatureError:
             return False
 
@@ -73,21 +78,21 @@ class ED25519PublicKey(PublicKey):
     def encode(public_base64):
         """
         Encode the public key represented by base64 to base58
+
+        Args:
+            public_base64
         """
-        return ED25519PrivateKey.encode(public_base64)
+        return Ed25519SigningKey.encode(public_base64)
 
     @staticmethod
-    def decode(public_value_compressed_base58):
+    def decode(public_base58):
         """
         Decode the base58 public_value to base64
-        """
-        return ED25519PrivateKey.decode(public_value_compressed_base58)
 
-    def _public_key_from_public_base64(self, public_base64):
+        Args:
+            public_base58
         """
-        Return an instance of ED25519 VerifyingKey from a base64
+        return Ed25519SigningKey.decode(public_base58)
-        """
-        return ed25519.VerifyingKey(public_base64, encoding='base64')
 
 
 def ed25519_generate_key_pair():

bigchaindb/crypto/fulfillment.py

@@ -5,7 +5,7 @@ from abc import ABCMeta, abstractmethod
 from six import string_types
 
 from bigchaindb.crypto.condition import Condition
-from bigchaindb.crypto.iostream import Writer, base64_remove_padding, Reader, base64_add_padding, Predictor
+from bigchaindb.crypto.buffer import Writer, base64_remove_padding, Reader, base64_add_padding, Predictor
 
 FULFILLMENT_REGEX = r'^cf:1:[1-9a-f][0-9a-f]{0,2}:[a-zA-Z0-9_-]+$'
 

bigchaindb/crypto/fulfillments/base_sha256.py

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 
 from bigchaindb.crypto.fulfillment import Fulfillment
-from bigchaindb.crypto.iostream import Hasher
+from bigchaindb.crypto.buffer import Hasher
 
 
 class BaseSha256Fulfillment(Fulfillment):

bigchaindb/crypto/fulfillments/ed25519_sha256.py

@@ -1,8 +1,8 @@
 import base58
 
-from bigchaindb.crypto.ed25519 import ED25519PublicKey
+from bigchaindb.crypto.ed25519 import Ed25519VerifyingKey
 from bigchaindb.crypto.fulfillments.base_sha256 import BaseSha256Fulfillment
-from bigchaindb.crypto.iostream import Predictor
+from bigchaindb.crypto.buffer import Predictor
 
 
 class Ed25519Sha256Fulfillment(BaseSha256Fulfillment):
@@ -70,10 +70,7 @@ class Ed25519Sha256Fulfillment(BaseSha256Fulfillment):
         Args:
             value (Buffer): publicKey Public Ed25519 publicKey
         """
-        # TODO: Buffer
+        if not isinstance(value, Ed25519VerifyingKey):
-        # if not isinstance(value, Buffer):
-        #     raise ValueError("public key must be a Buffer")
-        if not isinstance(value, ED25519PublicKey):
             raise TypeError
         self._public_key = value
 
@@ -93,9 +90,6 @@ class Ed25519Sha256Fulfillment(BaseSha256Fulfillment):
         Args:
             value (Buffer): Binary form of dynamic message.
         """
-        # TODO: Buffer
-        # if not isinstance(value, Buffer):
-        #     raise ValueError("message must be a Buffer")
         if not isinstance(value, bytes):
             value = value.encode()
         self._message = value
@@ -115,9 +109,6 @@ class Ed25519Sha256Fulfillment(BaseSha256Fulfillment):
         Args:
             value (Buffer): 64-byte signature.
         """
-        # TODO: Buffer
-        # if not isinstance(value, Buffer):
-        #     raise ValueError("signature must be a Buffer")
         self._signature = value
 
     def write_common_header(self, writer):
@@ -135,7 +126,7 @@ class Ed25519Sha256Fulfillment(BaseSha256Fulfillment):
         if not self.public_key:
             raise ValueError
 
-        writer.write_var_bytes(bytearray(self.public_key.public_key.to_bytes()))
+        writer.write_var_bytes(bytearray(self.public_key.to_bytes()))
         writer.write_var_bytes(self.message_prefix)
         writer.write_var_uint(self.max_dynamic_message_length)
         return writer
@@ -150,7 +141,7 @@ class Ed25519Sha256Fulfillment(BaseSha256Fulfillment):
             reader (Reader): Source to read the fulfillment payload from.
         """
         self.public_key = \
-            ED25519PublicKey(
+            Ed25519VerifyingKey(
                 base58.b58encode(
                     reader.read_var_bytes()))
         self.message_prefix = reader.read_var_bytes()
@@ -229,7 +220,7 @@ class Ed25519Sha256Fulfillment(BaseSha256Fulfillment):
         predictor.skip(self.max_dynamic_message_length)
 
         # Signature
-        predictor.write_var_bytes(self.public_key.public_key.to_bytes())
+        predictor.write_var_bytes(self.public_key.to_bytes())
 
         return predictor.size
 
@@ -243,11 +234,10 @@ class Ed25519Sha256Fulfillment(BaseSha256Fulfillment):
         Args:
             private_key (string) Ed25519 private key
         """
-        # TODO: Buffer
         sk = private_key
-        vk = ED25519PublicKey(
+        vk = Ed25519VerifyingKey(
             base58.b58encode(
-                sk.private_key.get_verifying_key().to_bytes()))
+                sk.get_verifying_key().to_bytes()))
 
         self.public_key = vk
 

bigchaindb/crypto/fulfillments/sha256.py

@@ -1,5 +1,5 @@
 from bigchaindb.crypto.fulfillments.base_sha256 import BaseSha256Fulfillment
-from bigchaindb.crypto.iostream import Hasher, Reader, Writer, Predictor
+from bigchaindb.crypto.buffer import Hasher, Reader, Writer, Predictor
 
 
 class Sha256Fulfillment(BaseSha256Fulfillment):

bigchaindb/crypto/fulfillments/threshold_sha256.py

@@ -1,7 +1,7 @@
 from bigchaindb.crypto.condition import Condition
 from bigchaindb.crypto.fulfillment import Fulfillment
 from bigchaindb.crypto.fulfillments.base_sha256 import BaseSha256Fulfillment
-from bigchaindb.crypto.iostream import Predictor, Reader, Writer
+from bigchaindb.crypto.buffer import Predictor, Reader, Writer
 
 
 class ThresholdSha256Fulfillment(BaseSha256Fulfillment):

bigchaindb/util.py

@@ -5,7 +5,7 @@ from datetime import datetime
 
 import bigchaindb
 from bigchaindb import exceptions
-from bigchaindb.crypto.asymmetric import PrivateKey, PublicKey, hash_data
+from bigchaindb.crypto.asymmetric import SigningKey, VerifyingKey, hash_data
 
 
 class ProcessGroup(object):
@@ -157,7 +157,7 @@ def sign_tx(transaction, private_key):
         dict: transaction with the `signature` field included.
 
     """
-    private_key = PrivateKey(private_key)
+    private_key = SigningKey(private_key)
     signature = private_key.sign(serialize(transaction))
     signed_transaction = transaction.copy()
     signed_transaction.update({'signature': signature})
@@ -200,7 +200,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 = VerifyingKey(public_key_base58)
     return public_key.verify(serialize(data), signature)
 
 

tests/crypto/test_crypto.py

@@ -1,7 +1,7 @@
 import base64
 
-from bigchaindb.crypto.ecdsa import ECDSAPrivateKey, ECDSAPublicKey, ecdsa_generate_key_pair
+from bigchaindb.crypto.ecdsa import EcdsaSigningKey, EcdsaVerifyingKey, ecdsa_generate_key_pair
-from bigchaindb.crypto.ed25519 import ED25519PrivateKey, ED25519PublicKey, ed25519_generate_key_pair
+from bigchaindb.crypto.ed25519 import Ed25519SigningKey, Ed25519VerifyingKey, ed25519_generate_key_pair
 
 
 class TestBigchainCryptoED25519(object):
@@ -18,67 +18,67 @@ class TestBigchainCryptoED25519(object):
     SIG_B64_ILP = 'sd0RahwuJJgeNfg8HvWHtYf4uqNgCOqIbseERacqs8G0kXNQQnhfV6gWAnMb+0RIlY3e0mqbrQiUwbRYJvRBAw=='
 
     def test_private_key_encode(self):
-        private_value_base58 = ED25519PrivateKey.encode(self.PRIVATE_B64)
+        private_value_base58 = Ed25519SigningKey.encode(self.PRIVATE_B64)
         assert private_value_base58 == self.PRIVATE_B58
 
     def test_private_key_init(self):
-        sk = ED25519PrivateKey(self.PRIVATE_B58)
+        sk = Ed25519SigningKey(self.PRIVATE_B58)
-        assert sk.private_key.to_ascii(encoding='base64') == self.PRIVATE_B64[:-1]
+        assert sk.to_ascii(encoding='base64') == self.PRIVATE_B64[:-1]
-        assert sk.private_key.to_bytes() == self.PRIVATE_BYTES
+        assert sk.to_bytes() == self.PRIVATE_BYTES
 
     def test_private_key_decode(self):
-        private_value = ED25519PrivateKey.decode(self.PRIVATE_B58)
+        private_value = Ed25519SigningKey.decode(self.PRIVATE_B58)
         assert private_value == self.PRIVATE_B64
 
     def test_public_key_encode(self):
-        public_value_base58 = ED25519PublicKey.encode(self.PUBLIC_B64)
+        public_value_base58 = Ed25519VerifyingKey.encode(self.PUBLIC_B64)
         assert public_value_base58 == self.PUBLIC_B58
 
     def test_public_key_init(self):
-        vk = ED25519PublicKey(self.PUBLIC_B58)
+        vk = Ed25519VerifyingKey(self.PUBLIC_B58)
-        assert vk.public_key.to_ascii(encoding='base64') == self.PUBLIC_B64[:-1]
+        assert vk.to_ascii(encoding='base64') == self.PUBLIC_B64[:-1]
-        assert vk.public_key.to_bytes() == self.PUBLIC_BYTES
+        assert vk.to_bytes() == self.PUBLIC_BYTES
 
     def test_public_key_decode(self):
-        public_value = ED25519PublicKey.decode(self.PUBLIC_B58)
+        public_value = Ed25519VerifyingKey.decode(self.PUBLIC_B58)
         assert public_value == self.PUBLIC_B64
 
     def test_sign_verify(self):
         message = 'Hello World!'
-        sk = ED25519PrivateKey(self.PRIVATE_B58)
+        sk = Ed25519SigningKey(self.PRIVATE_B58)
-        vk = ED25519PublicKey(self.PUBLIC_B58)
+        vk = Ed25519VerifyingKey(self.PUBLIC_B58)
         assert vk.verify(message, sk.sign(message)) is True
         assert vk.verify(message, sk.sign(message + 'dummy')) is False
         assert vk.verify(message + 'dummy', sk.sign(message)) is False
-        vk = ED25519PublicKey(ED25519PublicKey.encode(self.PUBLIC_B64_ILP))
+        vk = Ed25519VerifyingKey(Ed25519VerifyingKey.encode(self.PUBLIC_B64_ILP))
         assert vk.verify(message, sk.sign(message)) is False
 
     def test_valid_condition_valid_signature_ilp(self):
-        vk = ED25519PublicKey(ED25519PublicKey.encode(self.PUBLIC_B64_ILP))
+        vk = Ed25519VerifyingKey(Ed25519VerifyingKey.encode(self.PUBLIC_B64_ILP))
         msg = self.MSG_SHA512_ILP
         sig = self.SIG_B64_ILP
         assert vk.verify(base64.b64decode(msg), base64.b64decode(sig), encoding=None) is True
 
     def test_valid_condition_invalid_signature_ilp(self):
-        vk = ED25519PublicKey(ED25519PublicKey.encode(self.PUBLIC_B64_ILP))
+        vk = Ed25519VerifyingKey(Ed25519VerifyingKey.encode(self.PUBLIC_B64_ILP))
         msg = self.MSG_SHA512_ILP
         sig = self.MSG_SHA512_ILP
         assert vk.verify(base64.b64decode(msg), base64.b64decode(sig), encoding=None) is False
 
     def test_generate_key_pair(self):
         sk, vk = ed25519_generate_key_pair()
-        assert ED25519PrivateKey.encode(ED25519PrivateKey.decode(sk)) == sk
+        assert Ed25519SigningKey.encode(Ed25519SigningKey.decode(sk)) == sk
-        assert ED25519PublicKey.encode(ED25519PublicKey.decode(vk)) == vk
+        assert Ed25519VerifyingKey.encode(Ed25519VerifyingKey.decode(vk)) == vk
 
     def test_generate_sign_verify(self):
         sk, vk = ed25519_generate_key_pair()
-        sk = ED25519PrivateKey(sk)
+        sk = Ed25519SigningKey(sk)
-        vk = ED25519PublicKey(vk)
+        vk = Ed25519VerifyingKey(vk)
         message = 'Hello World!'
         assert vk.verify(message, sk.sign(message)) is True
         assert vk.verify(message, sk.sign(message + 'dummy')) is False
         assert vk.verify(message + 'dummy', sk.sign(message)) is False
-        vk = ED25519PublicKey(ED25519PublicKey.encode(self.PUBLIC_B64_ILP))
+        vk = Ed25519VerifyingKey(Ed25519VerifyingKey.encode(self.PUBLIC_B64_ILP))
         assert vk.verify(message, sk.sign(message)) is False
 
 
@@ -91,31 +91,31 @@ class TestBigchainCryptoECDSA(object):
     PUBLIC_VALUE_COMPRESSED_B58 = 'ifEi3UuTDT4CqUUKiS5omgeDodhu2aRFHVp6LoahbEVe'
 
     def test_private_key_encode(self):
-        private_value_base58 = ECDSAPrivateKey.encode(self.PRIVATE_VALUE)
+        private_value_base58 = EcdsaSigningKey.encode(self.PRIVATE_VALUE)
         assert private_value_base58 == self.PRIVATE_VALUE_B58
 
     def test_private_key_decode(self):
-        private_value = ECDSAPrivateKey.decode(self.PRIVATE_VALUE_B58)
+        private_value = EcdsaSigningKey.decode(self.PRIVATE_VALUE_B58)
         assert private_value == self.PRIVATE_VALUE
 
     def test_public_key_encode(self):
-        public_value_compressed_base58 = ECDSAPublicKey.encode(self.PUBLIC_VALUE_X, self.PUBLIC_VALUE_Y)
+        public_value_compressed_base58 = EcdsaVerifyingKey.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 = ECDSAPublicKey.decode(self.PUBLIC_VALUE_COMPRESSED_B58)
+        public_value_x, public_value_y = EcdsaVerifyingKey.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 = ECDSAPublicKey(self.PUBLIC_VALUE_COMPRESSED_B58)
+        public_key = EcdsaVerifyingKey(self.PUBLIC_VALUE_COMPRESSED_B58)
-        private_key = ECDSAPrivateKey(self.PRIVATE_VALUE_B58)
+        private_key = EcdsaSigningKey(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 = ecdsa_generate_key_pair()
-        assert ECDSAPrivateKey.encode(
+        assert EcdsaSigningKey.encode(
-            ECDSAPrivateKey.decode(private_value_base58)) == private_value_base58
+            EcdsaSigningKey.decode(private_value_base58)) == private_value_base58
-        assert ECDSAPublicKey.encode(
+        assert EcdsaVerifyingKey.encode(
-            *ECDSAPublicKey.decode(public_value_compressed_base58)) == public_value_compressed_base58
+            *EcdsaVerifyingKey.decode(public_value_compressed_base58)) == public_value_compressed_base58

tests/crypto/test_fulfillment.py

@@ -5,7 +5,7 @@ from math import ceil
 import pytest
 
 from bigchaindb.crypto.condition import Condition
-from bigchaindb.crypto.ed25519 import ED25519PrivateKey, ED25519PublicKey
+from bigchaindb.crypto.ed25519 import Ed25519SigningKey, Ed25519VerifyingKey
 from bigchaindb.crypto.fulfillment import Fulfillment
 from bigchaindb.crypto.fulfillments.ed25519_sha256 import Ed25519Sha256Fulfillment
 from bigchaindb.crypto.fulfillments.sha256 import Sha256Fulfillment
@@ -56,11 +56,11 @@ class TestBigchainILPSha256Fulfillment:
 class TestBigchainILPEd25519Sha256Fulfillment:
     PUBLIC_HEX_ILP = b'ec172b93ad5e563bf4932c70e1245034c35467ef2efd4d64ebf819683467e2bf'
     PUBLIC_B64_ILP = b'7Bcrk61eVjv0kyxw4SRQNMNUZ+8u/U1k6/gZaDRn4r8'
-    PUBLIC_B58_ILP = 'Gtbi6WQDB6wUePiZm8aYs5XZ5pUqx9jMMLvRVHPESTjU'
+    PUBLIC_B58_ILP = b'Gtbi6WQDB6wUePiZm8aYs5XZ5pUqx9jMMLvRVHPESTjU'
 
     PRIVATE_HEX_ILP = b'833fe62409237b9d62ec77587520911e9a759cec1d19755b7da901b96dca3d42'
     PRIVATE_B64_ILP = b'gz/mJAkje51i7HdYdSCRHpp1nOwdGXVbfakBuW3KPUI'
-    PRIVATE_B58_ILP = '9qLvREC54mhKYivr88VpckyVWdAFmifJpGjbvV5AiTRs'
+    PRIVATE_B58_ILP = b'9qLvREC54mhKYivr88VpckyVWdAFmifJpGjbvV5AiTRs'
 
     CONDITION_ED25519_ILP = 'cc:1:8:qQINW2um59C4DB9JSVXH1igqAmaYGGqryllHUgCpfPU:113'
     FULFILLMENT_ED25519_ILP = \
@@ -69,17 +69,17 @@ class TestBigchainILPEd25519Sha256Fulfillment:
     HASH_ED25519_HEX_ILP = b'a9020d5b6ba6e7d0b80c1f494955c7d6282a026698186aabca59475200a97cf5'
 
     def test_ilp_keys(self):
-        sk = ED25519PrivateKey(self.PRIVATE_B58_ILP)
+        sk = Ed25519SigningKey(self.PRIVATE_B58_ILP)
-        assert sk.private_key.to_ascii(encoding='base64') == self.PRIVATE_B64_ILP
+        assert sk.to_ascii(encoding='base64') == self.PRIVATE_B64_ILP
-        assert binascii.hexlify(sk.private_key.to_bytes()[:32]) == self.PRIVATE_HEX_ILP
+        assert binascii.hexlify(sk.to_bytes()[:32]) == self.PRIVATE_HEX_ILP
 
-        vk = ED25519PublicKey(self.PUBLIC_B58_ILP)
+        vk = Ed25519VerifyingKey(self.PUBLIC_B58_ILP)
-        assert vk.public_key.to_ascii(encoding='base64') == self.PUBLIC_B64_ILP
+        assert vk.to_ascii(encoding='base64') == self.PUBLIC_B64_ILP
-        assert binascii.hexlify(vk.public_key.to_bytes()) == self.PUBLIC_HEX_ILP
+        assert binascii.hexlify(vk.to_bytes()) == self.PUBLIC_HEX_ILP
 
     def test_serialize_condition_and_validate_fulfillment(self):
-        sk = ED25519PrivateKey(self.PRIVATE_B58_ILP)
+        sk = Ed25519SigningKey(self.PRIVATE_B58_ILP)
-        vk = ED25519PublicKey(self.PUBLIC_B58_ILP)
+        vk = Ed25519VerifyingKey(self.PUBLIC_B58_ILP)
 
         fulfillment = Ed25519Sha256Fulfillment()
         fulfillment.public_key = vk
@@ -107,7 +107,7 @@ class TestBigchainILPEd25519Sha256Fulfillment:
         assert binascii.hexlify(deserialized_condition.hash) == self.HASH_ED25519_HEX_ILP
 
     def test_serialize_deserialize_condition(self):
-        vk = ED25519PublicKey(self.PUBLIC_B58_ILP)
+        vk = Ed25519VerifyingKey(self.PUBLIC_B58_ILP)
 
         fulfillment = Ed25519Sha256Fulfillment()
         fulfillment.public_key = vk
@@ -129,12 +129,12 @@ class TestBigchainILPEd25519Sha256Fulfillment:
         assert fulfillment.serialize_uri() == self.FULFILLMENT_ED25519_ILP
         assert fulfillment.condition.serialize_uri() == self.CONDITION_ED25519_ILP
         assert binascii.hexlify(fulfillment.condition.hash) == self.HASH_ED25519_HEX_ILP
-        assert fulfillment.public_key.public_key.to_ascii(encoding='hex') == self.PUBLIC_HEX_ILP
+        assert fulfillment.public_key.to_ascii(encoding='hex') == self.PUBLIC_HEX_ILP
         assert fulfillment.validate()
 
     def test_serialize_deserialize_fulfillment(self):
-        sk = ED25519PrivateKey(self.PRIVATE_B58_ILP)
+        sk = Ed25519SigningKey(self.PRIVATE_B58_ILP)
-        vk = ED25519PublicKey(self.PUBLIC_B58_ILP)
+        vk = Ed25519VerifyingKey(self.PUBLIC_B58_ILP)
 
         fulfillment = Ed25519Sha256Fulfillment()
         fulfillment.public_key = vk
@@ -149,7 +149,7 @@ class TestBigchainILPEd25519Sha256Fulfillment:
         assert isinstance(deserialized_fulfillment, Ed25519Sha256Fulfillment)
         assert deserialized_fulfillment.serialize_uri() == fulfillment.serialize_uri()
         assert deserialized_fulfillment.condition.serialize_uri() == fulfillment.condition.serialize_uri()
-        assert deserialized_fulfillment.public_key.public_key.to_bytes() == fulfillment.public_key.public_key.to_bytes()
+        assert deserialized_fulfillment.public_key.to_bytes() == fulfillment.public_key.to_bytes()
         assert deserialized_fulfillment.validate()
 
 
@@ -178,8 +178,8 @@ class TestBigchainILPThresholdSha256Fulfillment:
         'AClmekN4N2NA7t2ltNZyLGgLIqPdA'
 
     def create_fulfillment_ed25519sha256(self):
-        sk = ED25519PrivateKey(self.PRIVATE_B58_ILP)
+        sk = Ed25519SigningKey(self.PRIVATE_B58_ILP)
-        vk = ED25519PublicKey(self.PUBLIC_B58_ILP)
+        vk = Ed25519VerifyingKey(self.PUBLIC_B58_ILP)
 
         fulfillment = Ed25519Sha256Fulfillment()
         fulfillment.public_key = vk

tests/db/test_bigchain_api.py

@@ -9,7 +9,7 @@ import bigchaindb
 from bigchaindb import exceptions
 from bigchaindb import util
 from bigchaindb.block import Block
-from bigchaindb.crypto.asymmetric import PrivateKey, PublicKey, generate_key_pair, hash_data
+from bigchaindb.crypto.asymmetric import SigningKey, VerifyingKey, generate_key_pair, hash_data
 from bigchaindb.voter import Voter
 
 
@@ -188,7 +188,7 @@ class TestBigchainApi(object):
 
         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 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,7 +371,7 @@ class TestBlockValidation(object):
 
         block_data = util.serialize(block)
         block_hash = hash_data(block_data)
-        block_signature = PrivateKey(b.me_private).sign(block_data)
+        block_signature = SigningKey(b.me_private).sign(block_data)
 
         block = {
             'id': block_hash,
@@ -443,7 +443,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 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
@@ -484,7 +484,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 VerifyingKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
 
     def test_vote_creation_valid(self, b):
         # create valid block
@@ -498,7 +498,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 VerifyingKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
 
     def test_vote_creation_invalid(self, b):
         # create valid block
@@ -512,7 +512,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 VerifyingKey(b.me).verify(util.serialize(vote['vote']), vote['signature']) is True
 
 
 class TestBigchainBlock(object):

tests/db/test_voter.py

@@ -5,7 +5,7 @@ import pytest
 import rethinkdb as r
 
 from bigchaindb import util
-from bigchaindb.crypto.asymmetric import PublicKey, generate_key_pair
+from bigchaindb.crypto.asymmetric import VerifyingKey, generate_key_pair
 from bigchaindb.voter import Voter, BlockStream
 
 
@@ -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 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()
@@ -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 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()
@@ -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 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 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 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 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