def test_invalid_participants():
with pytest.raises(AssertionError):
MultiSignature(signature=signature,
participants=[],
value=multi_sig_value)
with pytest.raises(AssertionError):
MultiSignature(signature=signature,
participants=None,
value=multi_sig_value)
def test_invalid_participants():
with pytest.raises(AssertionError):
MultiSignature(signature=signature,
participants=[],
pool_state_root=root_hash)
with pytest.raises(AssertionError):
MultiSignature(signature=signature,
participants=None,
pool_state_root=root_hash)
def test_invalid_participants():
with pytest.raises(ValueError):
MultiSignature(signature=signature,
participants=[],
value=multi_sig_value)
with pytest.raises(PlenumTypeError):
MultiSignature(signature=signature,
participants=None,
value=multi_sig_value)
def save_multi_sig(request_handler):
multi_sig_value = MultiSignatureValue(ledger_id=DOMAIN_LEDGER_ID,
state_root_hash=state_roots_serializer.serialize(
bytes(request_handler.state.committedHeadHash)),
txn_root_hash='2' * 32,
pool_state_root_hash='1' * 32,
timestamp=get_utc_epoch())
multi_sig = MultiSignature('0' * 32, ['Alpha', 'Beta', 'Gamma'], multi_sig_value)
request_handler.bls_store.put(multi_sig)
return multi_sig.as_dict()
def validate_pre_prepare(self, pre_prepare: PrePrepare, sender):
if f.BLS_MULTI_SIGS.nm in pre_prepare and pre_prepare.blsMultiSigs:
multi_sigs = pre_prepare.blsMultiSigs
for sig in multi_sigs:
multi_sig = MultiSignature.from_list(*sig)
if not self._validate_multi_sig(multi_sig):
return BlsBftReplica.PPR_BLS_MULTISIG_WRONG
if f.BLS_MULTI_SIG.nm not in pre_prepare or \
pre_prepare.blsMultiSig is None:
return
multi_sig = MultiSignature.from_list(*pre_prepare.blsMultiSig)
if not self._validate_multi_sig(multi_sig):
return BlsBftReplica.PPR_BLS_MULTISIG_WRONG
def get_last_ordered_state_root_hash(node):
last_pre_prepare = \
node.master_replica._ordering_service.prePrepares[node.master_replica.last_ordered_3pc]
multi_sig = MultiSignature.from_list(*last_pre_prepare.blsMultiSig)
state_root_hash = serializer.deserialize(
multi_sig.value.pool_state_root_hash)
return state_root_hash
def validate_pre_prepare(self, pre_prepare: PrePrepare, sender):
if f.BLS_MULTI_SIG.nm not in pre_prepare or \
pre_prepare.blsMultiSig is None:
return
multi_sig = MultiSignature.from_list(*pre_prepare.blsMultiSig)
if not self._validate_multi_sig(multi_sig):
return BlsBftReplica.PPR_BLS_MULTISIG_WRONG
def get(self, state_root_hash: str) -> Optional[MultiSignature]:
try:
ser_data = self._kvs.get(state_root_hash)
except KeyError:
return None
data = self._serializer.deserialize(ser_data)
multi_sig = MultiSignature.from_dict(**data)
return multi_sig
def get(self, state_root_hash: str) -> Optional[MultiSignature]:
try:
ser_data = self._kvs.get(state_root_hash)
except KeyError:
return None
data = self._serializer.deserialize(ser_data)
multi_sig = MultiSignature.from_dict(**data)
return multi_sig
def _calculate_multi_sig(self, key_3PC) -> Optional[MultiSignature]:
sigs_for_request = self._signatures[key_3PC]
bls_signatures = list(sigs_for_request.values())
participants = list(sigs_for_request.keys())
sig = self._bls_bft.bls_crypto_verifier.create_multi_sig(bls_signatures)
pool_root_hash_ser = self.state_root_serializer.serialize(
bytes(self._bls_bft.bls_key_register.get_pool_root_hash_committed()))
return MultiSignature(sig,
participants,
pool_root_hash_ser)
def _save_multi_sig_shared(self, pre_prepare: PrePrepare):
if f.BLS_MULTI_SIG.nm not in pre_prepare:
return
if pre_prepare.blsMultiSig is None:
return
multi_sig = MultiSignature.from_list(*pre_prepare.blsMultiSig)
self._bls_bft.bls_store.put(multi_sig)
logger.debug("{}{} saved multi signature {} for root {} (calculated by Primary)"
.format(BLS_PREFIX, self, multi_sig,
multi_sig.value.state_root_hash))
def _save_multi_sig_shared(self, pre_prepare: PrePrepare):
if f.BLS_MULTI_SIGS.nm not in pre_prepare or pre_prepare.blsMultiSigs is None:
return
multi_sigs = pre_prepare.blsMultiSigs
for sig in multi_sigs:
multi_sig = MultiSignature.from_list(*sig)
self._bls_bft.bls_store.put(multi_sig)
logger.debug(
"{}{} saved multi signature {} for root {} (calculated by Primary)"
.format(BLS_PREFIX, self, multi_sig,
multi_sig.value.state_root_hash))
def test_change_in_store(bls_store):
bls_store.put(root_hash, multi_sig)
newsig = MultiSignature(
signature="x" * 15,
participants=['9' * 5, '8' * 4],
pool_state_root=multi_sig.pool_state_root
)
bls_store.put(root_hash, newsig)
vsig = bls_store.get(root_hash)
assert vsig == newsig
def _calculate_single_multi_sig(self, sigs_for_request,
pre_prepare) -> Optional[MultiSignature]:
bls_signatures = list(sigs_for_request.values())
participants = list(sigs_for_request.keys())
sig = self._bls_bft.bls_crypto_verifier.create_multi_sig(
bls_signatures)
pool_root_hash_ser = self._get_pool_root_hash(pre_prepare)
multi_sig_value = self._create_multi_sig_value_for_pre_prepare(
pre_prepare, pool_root_hash_ser)
return MultiSignature(signature=sig,
participants=participants,
value=multi_sig_value)
def validate_pre_prepare(self, pre_prepare: PrePrepare, sender):
if f.BLS_MULTI_SIG.nm not in pre_prepare or \
pre_prepare.blsMultiSig is None:
return
# if we have multi-sig, then we must have the corresponded state root as well
if f.BLS_MULTI_SIG_STATE_ROOT.nm not in pre_prepare or \
pre_prepare.blsMultiSigStateRoot is None:
return BlsBftReplica.PPR_NO_BLS_MULTISIG_STATE
multi_sig = MultiSignature(*pre_prepare.blsMultiSig)
state_root = pre_prepare.blsMultiSigStateRoot
if not self._validate_multi_sig(multi_sig, state_root):
return BlsBftReplica.PPR_BLS_MULTISIG_WRONG
def multi_signature(bls_bft_replicas, multi_sig_value):
sigs = []
participants = []
message = multi_sig_value.as_single_value()
for bls_bft_replica in bls_bft_replicas:
sigs.append(bls_bft_replica._bls_bft.bls_crypto_signer.sign(message))
participants.append(bls_bft_replica.node_id)
multi_sig = bls_bft_replicas[
0]._bls_bft.bls_crypto_verifier.create_multi_sig(sigs)
return MultiSignature(signature=multi_sig,
participants=participants,
value=multi_sig_value)
def create_bls_multi_sig(encoded_root_hash):
pool_state_root_hash = base58.b58encode(b"somefakepoolroothashsomefakepoolroothash").decode("utf-8")
txn_root_hash = base58.b58encode(b"somefaketxnroothashsomefaketxnroothash").decode("utf-8")
ledger_id = 1
timestamp = get_utc_epoch()
value = MultiSignatureValue(ledger_id=ledger_id,
state_root_hash=encoded_root_hash,
pool_state_root_hash=pool_state_root_hash,
txn_root_hash=txn_root_hash,
timestamp=timestamp)
sign = "1q" * 16
participants = ["q" * 32, "w" * 32, "e" * 32, "r" * 32]
return MultiSignature(sign, participants, value)
def _save_multi_sig_shared(self, pre_prepare: PrePrepare):
if f.BLS_MULTI_SIG.nm not in pre_prepare:
return
if pre_prepare.blsMultiSig is None:
return
if f.BLS_MULTI_SIG_STATE_ROOT.nm not in pre_prepare:
return
if pre_prepare.blsMultiSigStateRoot is None:
return
state_root = pre_prepare.blsMultiSigStateRoot
multi_sig = MultiSignature(*pre_prepare.blsMultiSig)
self._bls_store_add(state_root, multi_sig)
logger.debug("{}{} saved multi signature {} for root {} (calculated by Primary)"
.format(BLS_PREFIX, self, multi_sig, state_root))
def put(self, multi_sig: MultiSignature):
if multi_sig is None:
raise ValueUndefinedError('multi_sig')
state_root_hash = multi_sig.value.state_root_hash
serialized_multi_sign = self._serializer.serialize(multi_sig.as_dict())
self._kvs.put(state_root_hash, serialized_multi_sign)
def fake_multi_sig(fake_multi_sig_value):
return MultiSignature(
signature=signature,
participants=participants,
value=fake_multi_sig_value)
def get_last_ordered_state_root_hash(node):
last_pre_prepare = \
node.master_replica.prePrepares[node.master_replica.last_ordered_3pc]
multi_sig = MultiSignature.from_list(*last_pre_prepare.blsMultiSig)
state_root_hash = serializer.deserialize(multi_sig.value.pool_state_root_hash)
return state_root_hash
pool_state_root_hash = base58.b58encode(
b"somefakepoolroothashsomefakepoolroothash")
txn_root_hash = base58.b58encode(b"somefaketxnroothashsomefaketxnroothash")
ledger_id = 1
timestamp = get_utc_epoch()
value = MultiSignatureValue(ledger_id=ledger_id,
state_root_hash=state_root_hash,
pool_state_root_hash=pool_state_root_hash,
txn_root_hash=txn_root_hash,
timestamp=timestamp)
sign = "1q" * 16
participants = ["q" * 32, "w" * 32, "e" * 32, "r" * 32]
multi_sig = MultiSignature(sign, participants, value)
@pytest.fixture()
def bls_store(tempdir):
bls_str = BlsStore(config.stateSignatureStorage, tempdir,
config.stateSignatureDbName)
yield bls_str
bls_str.close()
def test_create_store(bls_store):
pass
def test_put_to_store(bls_store, fake_multi_sig):
def put(self, root_hash: str, sign: MultiSignature):
assert root_hash is not None
assert sign is not None
serialized_multi_sign = self._serializer.serialize(sign.as_dict())
self._kvs.put(root_hash, serialized_multi_sign)
def fake_multi_sig(fake_multi_sig_value):
return MultiSignature(
signature="somefakesignaturesomefakesignaturesomefakesignature",
participants=["Node1", "Node2", "Node3"],
value=fake_multi_sig_value)
def multi_sig(multi_sig_value):
return MultiSignature(signature=signature,
participants=participants,
value=multi_sig_value)
def test_invalid_root():
with pytest.raises(AssertionError):
MultiSignature(signature=signature,
participants=participants,
pool_state_root=None)
import pytest
from crypto.bls.bls_multi_signature import MultiSignature
from plenum.bls.bls_store import BlsStore
from plenum.common.config_util import getConfig
from common.serializers.serialization import multi_sig_store_serializer
config = getConfig()
sign = "1q" * 16
root_hash = "2w" * 16
participants = ["q" * 32, "w" * 32, "e" * 32, "r" * 32]
pool_root_hash = "3w" * 16
multi_sig = MultiSignature(sign, participants, pool_root_hash)
@pytest.fixture()
def bls_store(tempdir):
bls_str = BlsStore(config.stateSignatureStorage,
tempdir,
config.stateSignatureDbName,
multi_sig_store_serializer)
yield bls_str
bls_str.close()
def test_create_store(bls_store):
pass
def put(self, multi_sig: MultiSignature):
assert multi_sig is not None
state_root_hash = multi_sig.value.state_root_hash
serialized_multi_sign = self._serializer.serialize(multi_sig.as_dict())
self._kvs.put(state_root_hash, serialized_multi_sign)
def test_valid():
assert MultiSignature(signature=signature,
participants=participants,
pool_state_root=root_hash)
def test_invalid_value():
with pytest.raises(PlenumTypeError):
MultiSignature(signature=signature,
participants=participants,
value=None)
def save_multi_sig(request_handler):
multi_sig = MultiSignature('0' * 32, ['Alpha', 'Beta', 'Gamma'], '1' * 32)
key = state_roots_serializer.serialize(
bytes(request_handler.state.committedHeadHash))
request_handler.bls_store.put(key, multi_sig)
return multi_sig
def put(self, multi_sig: MultiSignature):
if multi_sig is None:
raise ValueUndefinedError('multi_sig')
state_root_hash = multi_sig.value.state_root_hash
serialized_multi_sign = self._serializer.serialize(multi_sig.as_dict())
self._kvs.put(state_root_hash, serialized_multi_sign)
