Mirroristas/bigchaindb
2
0
Fork 0
mirror of https://github.com/bigchaindb/bigchaindb.git synced 2024-10-13 13:34:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

- Ed25519 inheritance

Browse Source 
- Renamed Private/PublicKey to Signing/VerifyingKey
This commit is contained in:
diminator 2016-03-18 22:23:32 +01:00
parent bdc2475bdd
commit f273e48c11
17 changed files with 157 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
bigchaindb/core.py
View File

@ -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,

39
bigchaindb/crypto/asymmetric.py
View File

@ -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

2
bigchaindb/crypto/bitmark_registry.py
View File

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

0
bigchaindb/crypto/iostream.py → bigchaindb/crypto/buffer.py
View File

5
bigchaindb/crypto/condition.py
View File

@ -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

26
bigchaindb/crypto/ecdsa.py
View File

@ -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)

49
bigchaindb/crypto/ed25519.py
View File

@ -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():

2
bigchaindb/crypto/fulfillment.py
View File

@ -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_-]+$'

2
bigchaindb/crypto/fulfillments/base_sha256.py
View File

@ -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):

26
bigchaindb/crypto/fulfillments/ed25519_sha256.py
View File

@ -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

2
bigchaindb/crypto/fulfillments/sha256.py
View File

@ -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):

2
bigchaindb/crypto/fulfillments/threshold_sha256.py
View File

@ -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):

6
bigchaindb/util.py
View File

@ -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)

64
tests/crypto/test_crypto.py
View File

@ -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

36
tests/crypto/test_fulfillment.py
View File

@ -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

14
tests/db/test_bigchain_api.py
View File

@ -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):

14
tests/db/test_voter.py
View File

@ -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