From f273e48c112e5d9370d37067574c50fe19129036 Mon Sep 17 00:00:00 2001 From: diminator Date: Fri, 18 Mar 2016 22:23:32 +0100 Subject: [PATCH] - Ed25519 inheritance - Renamed Private/PublicKey to Signing/VerifyingKey --- bigchaindb/core.py | 6 +- bigchaindb/crypto/asymmetric.py | 39 +++++++---- bigchaindb/crypto/bitmark_registry.py | 2 +- bigchaindb/crypto/{iostream.py => buffer.py} | 0 bigchaindb/crypto/condition.py | 5 +- bigchaindb/crypto/ecdsa.py | 26 ++++++-- bigchaindb/crypto/ed25519.py | 49 +++++++------- bigchaindb/crypto/fulfillment.py | 2 +- bigchaindb/crypto/fulfillments/base_sha256.py | 2 +- .../crypto/fulfillments/ed25519_sha256.py | 26 +++----- bigchaindb/crypto/fulfillments/sha256.py | 2 +- .../crypto/fulfillments/threshold_sha256.py | 2 +- bigchaindb/util.py | 6 +- tests/crypto/test_crypto.py | 64 +++++++++---------- tests/crypto/test_fulfillment.py | 36 +++++------ tests/db/test_bigchain_api.py | 14 ++-- tests/db/test_voter.py | 14 ++-- 17 files changed, 157 insertions(+), 138 deletions(-) rename bigchaindb/crypto/{iostream.py => buffer.py} (100%) diff --git a/bigchaindb/core.py b/bigchaindb/core.py index be66ecf2..610aae46 100644 --- a/bigchaindb/core.py +++ b/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, diff --git a/bigchaindb/crypto/asymmetric.py b/bigchaindb/crypto/asymmetric.py index 807021a6..05d3dcfd 100644 --- a/bigchaindb/crypto/asymmetric.py +++ b/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 -PublicKey = ECDSAPublicKey +SigningKey = EcdsaSigningKey +VerifyingKey = EcdsaVerifyingKey generate_key_pair = ecdsa_generate_key_pair diff --git a/bigchaindb/crypto/bitmark_registry.py b/bigchaindb/crypto/bitmark_registry.py index 686bf845..2f75b158 100644 --- a/bigchaindb/crypto/bitmark_registry.py +++ b/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: diff --git a/bigchaindb/crypto/iostream.py b/bigchaindb/crypto/buffer.py similarity index 100% rename from bigchaindb/crypto/iostream.py rename to bigchaindb/crypto/buffer.py diff --git a/bigchaindb/crypto/condition.py b/bigchaindb/crypto/condition.py index 9c1fd6f8..94ee4f89 100644 --- a/bigchaindb/crypto/condition.py +++ b/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 diff --git a/bigchaindb/crypto/ecdsa.py b/bigchaindb/crypto/ecdsa.py index 29bf6e45..864b8c86 100644 --- a/bigchaindb/crypto/ecdsa.py +++ b/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) diff --git a/bigchaindb/crypto/ed25519.py b/bigchaindb/crypto/ed25519.py index 66cec100..0dccc214 100644 --- a/bigchaindb/crypto/ed25519.py +++ b/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 ED25519PublicKey(PublicKey): +class Ed25519VerifyingKey(ed25519.VerifyingKey, VerifyingKey): 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 ed25519.VerifyingKey(public_base64, encoding='base64') + return Ed25519SigningKey.decode(public_base58) def ed25519_generate_key_pair(): diff --git a/bigchaindb/crypto/fulfillment.py b/bigchaindb/crypto/fulfillment.py index b2297a47..d43ade8c 100644 --- a/bigchaindb/crypto/fulfillment.py +++ b/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_-]+$' diff --git a/bigchaindb/crypto/fulfillments/base_sha256.py b/bigchaindb/crypto/fulfillments/base_sha256.py index 570b0d7f..4c4c590d 100644 --- a/bigchaindb/crypto/fulfillments/base_sha256.py +++ b/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): diff --git a/bigchaindb/crypto/fulfillments/ed25519_sha256.py b/bigchaindb/crypto/fulfillments/ed25519_sha256.py index c3fb4bfe..a9a0cf18 100644 --- a/bigchaindb/crypto/fulfillments/ed25519_sha256.py +++ b/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, Buffer): - # raise ValueError("public key must be a Buffer") - if not isinstance(value, ED25519PublicKey): + if not isinstance(value, Ed25519VerifyingKey): 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 diff --git a/bigchaindb/crypto/fulfillments/sha256.py b/bigchaindb/crypto/fulfillments/sha256.py index a24e4087..2c433ce3 100644 --- a/bigchaindb/crypto/fulfillments/sha256.py +++ b/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): diff --git a/bigchaindb/crypto/fulfillments/threshold_sha256.py b/bigchaindb/crypto/fulfillments/threshold_sha256.py index 037d58a8..cd291841 100644 --- a/bigchaindb/crypto/fulfillments/threshold_sha256.py +++ b/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): diff --git a/bigchaindb/util.py b/bigchaindb/util.py index 23d47bc8..90091ffe 100644 --- a/bigchaindb/util.py +++ b/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) diff --git a/tests/crypto/test_crypto.py b/tests/crypto/test_crypto.py index 3ac24046..ad015071 100644 --- a/tests/crypto/test_crypto.py +++ b/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.ed25519 import ED25519PrivateKey, ED25519PublicKey, ed25519_generate_key_pair +from bigchaindb.crypto.ecdsa import EcdsaSigningKey, EcdsaVerifyingKey, ecdsa_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) - assert sk.private_key.to_ascii(encoding='base64') == self.PRIVATE_B64[:-1] - assert sk.private_key.to_bytes() == self.PRIVATE_BYTES + sk = Ed25519SigningKey(self.PRIVATE_B58) + assert sk.to_ascii(encoding='base64') == self.PRIVATE_B64[:-1] + 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) - assert vk.public_key.to_ascii(encoding='base64') == self.PUBLIC_B64[:-1] - assert vk.public_key.to_bytes() == self.PUBLIC_BYTES + vk = Ed25519VerifyingKey(self.PUBLIC_B58) + assert vk.to_ascii(encoding='base64') == self.PUBLIC_B64[:-1] + 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) - vk = ED25519PublicKey(self.PUBLIC_B58) + sk = Ed25519SigningKey(self.PRIVATE_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 ED25519PublicKey.encode(ED25519PublicKey.decode(vk)) == vk + assert Ed25519SigningKey.encode(Ed25519SigningKey.decode(sk)) == sk + assert Ed25519VerifyingKey.encode(Ed25519VerifyingKey.decode(vk)) == vk def test_generate_sign_verify(self): sk, vk = ed25519_generate_key_pair() - sk = ED25519PrivateKey(sk) - vk = ED25519PublicKey(vk) + sk = Ed25519SigningKey(sk) + 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) - private_key = ECDSAPrivateKey(self.PRIVATE_VALUE_B58) + public_key = EcdsaVerifyingKey(self.PUBLIC_VALUE_COMPRESSED_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( - ECDSAPrivateKey.decode(private_value_base58)) == private_value_base58 - assert ECDSAPublicKey.encode( - *ECDSAPublicKey.decode(public_value_compressed_base58)) == public_value_compressed_base58 + assert EcdsaSigningKey.encode( + EcdsaSigningKey.decode(private_value_base58)) == private_value_base58 + assert EcdsaVerifyingKey.encode( + *EcdsaVerifyingKey.decode(public_value_compressed_base58)) == public_value_compressed_base58 diff --git a/tests/crypto/test_fulfillment.py b/tests/crypto/test_fulfillment.py index efea4925..0d59ffdc 100644 --- a/tests/crypto/test_fulfillment.py +++ b/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) - assert sk.private_key.to_ascii(encoding='base64') == self.PRIVATE_B64_ILP - assert binascii.hexlify(sk.private_key.to_bytes()[:32]) == self.PRIVATE_HEX_ILP + sk = Ed25519SigningKey(self.PRIVATE_B58_ILP) + assert sk.to_ascii(encoding='base64') == self.PRIVATE_B64_ILP + assert binascii.hexlify(sk.to_bytes()[:32]) == self.PRIVATE_HEX_ILP - vk = ED25519PublicKey(self.PUBLIC_B58_ILP) - assert vk.public_key.to_ascii(encoding='base64') == self.PUBLIC_B64_ILP - assert binascii.hexlify(vk.public_key.to_bytes()) == self.PUBLIC_HEX_ILP + vk = Ed25519VerifyingKey(self.PUBLIC_B58_ILP) + assert vk.to_ascii(encoding='base64') == self.PUBLIC_B64_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) - vk = ED25519PublicKey(self.PUBLIC_B58_ILP) + sk = Ed25519SigningKey(self.PRIVATE_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) - vk = ED25519PublicKey(self.PUBLIC_B58_ILP) + sk = Ed25519SigningKey(self.PRIVATE_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) - vk = ED25519PublicKey(self.PUBLIC_B58_ILP) + sk = Ed25519SigningKey(self.PRIVATE_B58_ILP) + vk = Ed25519VerifyingKey(self.PUBLIC_B58_ILP) fulfillment = Ed25519Sha256Fulfillment() fulfillment.public_key = vk diff --git a/tests/db/test_bigchain_api.py b/tests/db/test_bigchain_api.py index 0ed02a8b..2a7cb1da 100644 --- a/tests/db/test_bigchain_api.py +++ b/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): diff --git a/tests/db/test_voter.py b/tests/db/test_voter.py index e4ae8efa..2eeaf7f0 100644 --- a/tests/db/test_voter.py +++ b/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