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