def fake_pre_prepare_with_bls_pool_ledger(fake_multi_sig):
params = create_pre_prepare_params(
state_root=fake_multi_sig.value.state_root_hash,
pool_state_root=fake_multi_sig.value.pool_state_root_hash,
bls_multi_sig=fake_multi_sig,
ledger_id=POOL_LEDGER_ID)
return PrePrepare(*params)
def pre_prepare_with_bls_pool_ledger(multi_signature):
params = create_pre_prepare_params(
state_root=multi_signature.value.state_root_hash,
pool_state_root=multi_signature.value.pool_state_root_hash,
bls_multi_sig=multi_signature,
ledger_id=POOL_LEDGER_ID)
return PrePrepare(*params)
def pre_prepare_with_incorrect_bls(multi_signature):
multi_signature.signature = base58.b58encode(
b"somefakesignaturesomefakesignaturesomefakesignature").decode("utf-8")
params = create_pre_prepare_params(
state_root=multi_signature.value.state_root_hash,
bls_multi_sig=multi_signature)
return PrePrepare(*params)
def test_accept_all_3PC_msgs(create_node_and_not_start, looper):
node = create_node_and_not_start
preprepare = PrePrepare(
0,
0,
1,
get_utc_epoch(),
['f99937241d4c891c08e92a3cc25966607315ca66b51827b170d492962d58a9be'],
'[]',
'f99937241d4c891c08e92a3cc25966607315ca66b51827b170d492962d58a9be',
DOMAIN_LEDGER_ID,
'CZecK1m7VYjSNCC7pGHj938DSW2tfbqoJp1bMJEtFqvG',
'7WrAMboPTcMaQCU1raoj28vnhu2bPMMd2Lr9tEcsXeCJ',
0,
True
)
prepare = Prepare(
0,
0,
1,
get_utc_epoch(),
'f99937241d4c891c08e92a3cc25966607315ca66b51827b170d492962d58a9be',
'CZecK1m7VYjSNCC7pGHj938DSW2tfbqoJp1bMJEtFqvG',
'7WrAMboPTcMaQCU1raoj28vnhu2bPMMd2Lr9tEcsXeCJ')
commit = Commit(
0,
0,
1
)
node.view_changer = node.newViewChanger()
node.master_replica._consensus_data.view_no = 0
node.master_replica.primaryName = 'Alpha'
"""Initiate view_change procedure"""
node.master_replica.internal_bus.send(NodeNeedViewChange(1))
# We don't use a view_change_strategy anymore
assert len(node.nodeInBox) == 0
"""
Imitate that nodestack.service was called and
those of next messages are put into nodeInBox queue
"""
node.nodeInBox.append((preprepare, 'some_node'))
node.nodeInBox.append((prepare, 'some_node'))
node.nodeInBox.append((commit, 'some_node'))
assert len(node.master_replica.inBox) == 0
"""Imitate looper's work"""
looper.run(node.serviceReplicas(None))
"""
Next looper's task must be processNodeInBox and
all of 3PC messages must be moved to replica's inBox queue
"""
looper.run(node.processNodeInBox())
"""3 3PC msgs"""
assert len(node.master_replica.inBox) == 3
"""Check the order of msgs"""
m = node.master_replica.inBox.popleft()
assert isinstance(m[0], PrePrepare)
m = node.master_replica.inBox.popleft()
assert isinstance(m[0], Prepare)
m = node.master_replica.inBox.popleft()
assert isinstance(m[0], Commit)
def _create_prepare_and_preprepare(inst_id, pp_sq_no, view_no, timestamp,
sdk_wallet_client):
time = int(timestamp)
req_idr = ["random request digest"]
preprepare = PrePrepare(inst_id,
pp_sq_no,
view_no,
time,
req_idr,
init_discarded(),
"123",
1,
None,
None,
0,
True)
prepare = Prepare(inst_id,
pp_sq_no,
view_no,
time,
"321",
None,
None
)
return preprepare, prepare
def nonPrimarySeesCorrectNumberOfPREPREPAREs():
"""
1. no of PRE-PREPARE as seen by processPrePrepare method for
non-primaries must be 1; whn zero faulty nodes in system.
2. no of PRE-PREPARE as seen by processPrePrepare method for
non-primaries must be greater than or equal to 0;
with faults in system.
"""
expectedPrePrepareRequest = PrePrepare(
instId, primary.viewNo, primary.lastPrePrepareSeqNo,
get_utc_epoch(), [propagated1.digest], init_discarded(),
Replica.batchDigest([
propagated1,
]), DOMAIN_LEDGER_ID, primary.stateRootHash(DOMAIN_LEDGER_ID),
primary.txnRootHash(DOMAIN_LEDGER_ID), 0, True)
passes = 0
for npr in nonPrimaryReplicas:
actualMsgs = len([
param for param in getAllArgs(npr, npr.processPrePrepare)
if (param['pre_prepare'][0:3] + param['pre_prepare'][4:],
param['sender']) == (expectedPrePrepareRequest[0:3] +
expectedPrePrepareRequest[4:],
primary.name)
])
numOfMsgsWithZFN = 1
numOfMsgsWithFaults = 0
passes += int(
msgCountOK(nodesSize, faultyNodes, actualMsgs,
numOfMsgsWithZFN, numOfMsgsWithFaults))
assert passes >= len(nonPrimaryReplicas) - faultyNodes, \
'Non-primary sees correct number pre-prepares - {}'.format(passes)
def fake_pre_prepare_with_bls(fake_multi_sig, ledger_id):
params = create_pre_prepare_params(
state_root=fake_multi_sig.value.state_root_hash,
ledger_id=ledger_id,
pool_state_root=fake_multi_sig.value.pool_state_root_hash,
bls_multi_sig=fake_multi_sig)
return PrePrepare(*params)
def pre_prepare_with_bls(multi_signature, ledger_id):
params = create_pre_prepare_params(
state_root=multi_signature.value.state_root_hash,
ledger_id=ledger_id,
pool_state_root=multi_signature.value.pool_state_root_hash,
bls_multi_sig=multi_signature)
return PrePrepare(*params)
def test_process_pre_prepare_with_incorrect_audit_txn_root(
orderer_with_requests, state_roots, txn_roots, multi_sig,
fake_requests):
expect_suspicious(orderer_with_requests,
Suspicions.PPR_AUDIT_TXN_ROOT_HASH_WRONG.code)
pre_prepare_params = create_pre_prepare_params(
state_root=state_roots[DOMAIN_LEDGER_ID],
ledger_id=DOMAIN_LEDGER_ID,
txn_root=txn_roots[DOMAIN_LEDGER_ID],
bls_multi_sig=multi_sig,
view_no=orderer_with_requests.view_no,
inst_id=0,
pool_state_root=state_roots[POOL_LEDGER_ID],
# INVALID!
audit_txn_root="HSai3sMHKeAva4gWMabDrm1yNhezvPHfXnGyHf2ex1L4",
reqs=fake_requests,
pp_seq_no=1)
pre_prepare = PrePrepare(*pre_prepare_params)
_register_pp_ts(orderer_with_requests, pre_prepare,
orderer_with_requests.primary_name)
with pytest.raises(SuspiciousNode):
orderer_with_requests.process_preprepare(
pre_prepare, orderer_with_requests.primary_name)
def pre_prepare(checkpoint_service):
params = create_pre_prepare_params(None,
ledger_id=DOMAIN_LEDGER_ID,
view_no=checkpoint_service.view_no,
pp_seq_no=1)
pp = PrePrepare(*params)
return pp
def test_process_pre_prepare_with_incorrect_audit_txn_root(
replica_with_requests, state_roots, txn_roots, multi_sig,
fake_requests):
def reportSuspiciousNodeEx(ex):
assert Suspicions.PPR_AUDIT_TXN_ROOT_HASH_WRONG.code == ex.code
raise ex
replica_with_requests.node.reportSuspiciousNodeEx = reportSuspiciousNodeEx
pre_prepare_params = create_pre_prepare_params(
state_root=state_roots[DOMAIN_LEDGER_ID],
ledger_id=DOMAIN_LEDGER_ID,
txn_root=txn_roots[DOMAIN_LEDGER_ID],
bls_multi_sig=multi_sig,
view_no=replica_with_requests.viewNo,
inst_id=replica_with_requests.instId,
pool_state_root=state_roots[POOL_LEDGER_ID],
# INVALID!
audit_txn_root="HSai3sMHKeAva4gWMabDrm1yNhezvPHfXnGyHf2ex1L4",
reqs=fake_requests)
pre_prepare = PrePrepare(*pre_prepare_params)
with pytest.raises(SuspiciousNode):
replica_with_requests.processPrePrepare(
pre_prepare, replica_with_requests.primaryName)
def test_process_pre_prepare_with_incorrect_audit_txn_root(orderer_with_requests,
state_roots, txn_roots, multi_sig, fake_requests):
if not orderer_with_requests.is_master:
return
handler = Mock()
orderer_with_requests._bus.subscribe(RaisedSuspicion, handler)
pre_prepare_params = create_pre_prepare_params(state_root=state_roots[DOMAIN_LEDGER_ID],
ledger_id=DOMAIN_LEDGER_ID,
txn_root=txn_roots[DOMAIN_LEDGER_ID],
bls_multi_sig=multi_sig,
view_no=orderer_with_requests.view_no,
inst_id=0,
pool_state_root=state_roots[POOL_LEDGER_ID],
# INVALID!
audit_txn_root="HSai3sMHKeAva4gWMabDrm1yNhezvPHfXnGyHf2ex1L4",
reqs=fake_requests,
pp_seq_no=1)
pre_prepare = PrePrepare(*pre_prepare_params)
_register_pp_ts(orderer_with_requests, pre_prepare, orderer_with_requests.primary_name)
orderer_with_requests.process_preprepare(pre_prepare, orderer_with_requests.primary_name)
check_suspicious(handler, RaisedSuspicion(inst_id=orderer_with_requests._data.inst_id,
ex=SuspiciousNode(orderer_with_requests.primary_name,
Suspicions.PPR_AUDIT_TXN_ROOT_HASH_WRONG,
pre_prepare)))
def testPrePrepareWithHighSeqNo(looper, txnPoolNodeSet, propagated1):
def chk():
for r in getNonPrimaryReplicas(txnPoolNodeSet, instId):
nodeSuspicions = len(
getNodeSuspicions(r.node, Suspicions.WRONG_PPSEQ_NO.code))
assert nodeSuspicions == 1
def checkPreprepare(replica, viewNo, ppSeqNo, req, numOfPrePrepares):
assert (replica._ordering_service.prePrepares[viewNo, ppSeqNo][0]) == \
(req.identifier, req.reqId, req.digest)
primary = getPrimaryReplica(txnPoolNodeSet, instId)
nonPrimaryReplicas = getNonPrimaryReplicas(txnPoolNodeSet, instId)
req = propagated1.reqDigest
primary.doPrePrepare(req)
timeout = waits.expectedPrePrepareTime(len(txnPoolNodeSet))
for np in nonPrimaryReplicas:
looper.run(
eventually(checkPreprepare,
np,
primary.viewNo,
primary.lastPrePrepareSeqNo - 1,
req,
1,
retryWait=.5,
timeout=timeout))
newReqDigest = (req.identifier, req.reqId + 1, req.digest)
incorrectPrePrepareReq = PrePrepare(instId, primary.viewNo,
primary.lastPrePrepareSeqNo + 2,
*newReqDigest, get_utc_epoch())
primary.send(incorrectPrePrepareReq, TPCStat.PrePrepareSent)
timeout = waits.expectedPrePrepareTime(len(txnPoolNodeSet))
looper.run(eventually(chk, retryWait=1, timeout=timeout))
def test_suspicious_on_wrong_list_of_primaries(orderer_with_requests,
state_roots, txn_roots, multi_sig, fake_requests):
if not orderer_with_requests.is_master:
return
handler = Mock()
orderer_with_requests._bus.subscribe(RaisedSuspicion, handler)
pre_prepare_params = create_pre_prepare_params(state_root=state_roots[DOMAIN_LEDGER_ID],
ledger_id=DOMAIN_LEDGER_ID,
txn_root=txn_roots[DOMAIN_LEDGER_ID],
bls_multi_sig=multi_sig,
view_no=orderer_with_requests.view_no,
inst_id=0,
pool_state_root=state_roots[POOL_LEDGER_ID],
audit_txn_root=state_roots[AUDIT_LEDGER_ID],
reqs=fake_requests,
pp_seq_no=1,
primaries=["Some", "Other", "Primaries"])
pre_prepare = PrePrepare(*pre_prepare_params)
_register_pp_ts(orderer_with_requests, pre_prepare, orderer_with_requests.primary_name)
orderer_with_requests.process_preprepare(pre_prepare, orderer_with_requests.primary_name)
check_suspicious(handler, RaisedSuspicion(inst_id=orderer_with_requests._data.inst_id,
ex=SuspiciousNode(orderer_with_requests.primary_name,
Suspicions.PPR_WITH_WRONG_PRIMARIES,
pre_prepare)))
def create_pre_prepare_bls_multisig_no_state(bls_multi_sig, state_root):
params = create_pre_prepare_params(state_root)
params.append([
bls_multi_sig.signature, bls_multi_sig.participants,
bls_multi_sig.pool_state_root
])
return PrePrepare(*params)
def create(self, msg: Dict, **kwargs) -> Optional[PrePrepare]:
pp = PrePrepare(**msg)
if pp.instId != kwargs['inst_id'] \
or pp.viewNo != kwargs['view_no'] \
or pp.ppSeqNo != kwargs['pp_seq_no']:
raise MismatchedMessageReplyException
return pp
def create_pre_prepare():
pre_prepare_args = [
# instIds
0,
# viewNo
0,
# ppSeqNo
2,
# ppTime
get_utc_epoch(),
# reqIdr
['B8fV7naUqLATYocqu7yZ8WM9BJDuS24bqbJNvBRsoGg3'],
# discarded
"",
# digest
'ccb7388bc43a1e4669a23863c2b8c43efa183dde25909541b06c0f5196ac4f3b',
# ledger id
CONFIG_LEDGER_ID,
# state root
'5BU5Rc3sRtTJB6tVprGiTSqiRaa9o6ei11MjH4Vu16ms',
# txn root
'EdxDR8GUeMXGMGtQ6u7pmrUgKfc2XdunZE79Z9REEHg6',
# sub_seq_no
0,
# final
True
]
return PrePrepare(*pre_prepare_args)
def patched_sender(msg, dst=None, stat=None):
if isinstance(msg, OldViewPrePrepareReply) and msg.preprepares:
pp_dict = msg.preprepares[0]._asdict()
pp_dict["digest"] = "incorrect_digest"
pp = PrePrepare(**pp_dict)
msg.preprepares[0] = pp
monkeypatch.undo()
old_sender(msg, dst, stat)
def create(self, msg: Dict, **kwargs) -> Optional[PrePrepare]:
pp = PrePrepare(**msg)
if pp.instId != kwargs['inst_id'] or pp.viewNo != kwargs['view_no']:
logger.warning(
'{}{} found PREPREPARE {} not satisfying query criteria' .format(
THREE_PC_PREFIX, self, pp))
return None
return pp
def _create_prepare_and_preprepare(inst_id, pp_sq_no, view_no, timestamp,
sdk_wallet_client):
time = int(timestamp)
req_idr = [[sdk_wallet_client[1], 1234]]
preprepare = PrePrepare(inst_id, pp_sq_no, view_no, time, req_idr, 1,
"123", 1, None, None)
prepare = Prepare(inst_id, pp_sq_no, view_no, time, "321", None, None)
return preprepare, prepare
def patched_sender(msg, dst=None, stat=None):
if isinstance(msg, PrePrepare) and msg:
old_sender(msg, [n.name for n in other_nodes], stat)
pp_dict = msg._asdict()
pp_dict["ppTime"] += 1
pp = PrePrepare(**pp_dict)
old_sender(pp, [slow_node.name], stat)
monkeypatch.undo()
def pp(primary_replica, ts_now):
params = create_pre_prepare_params(
generate_state_root(),
inst_id=primary_replica.instId,
view_no=primary_replica.viewNo,
pp_seq_no=(primary_replica.last_ordered_3pc[1] + 1),
timestamp=ts_now)
return PrePrepare(*params)
def pre_prepare():
return PrePrepare(
0, 0, 1, get_utc_epoch(),
['f99937241d4c891c08e92a3cc25966607315ca66b51827b170d492962d58a9be'],
'[]',
'f99937241d4c891c08e92a3cc25966607315ca66b51827b170d492962d58a9be',
DOMAIN_LEDGER_ID, 'CZecK1m7VYjSNCC7pGHj938DSW2tfbqoJp1bMJEtFqvG',
'7WrAMboPTcMaQCU1raoj28vnhu2bPMMd2Lr9tEcsXeCJ', 0, True)
def pre_prepare_with_incorrect_bls_pool_ledger(multi_signature):
multi_signature.signature = base58.b58encode(
b"somefakesignaturesomefakesignaturesomefakesignature")
params = create_pre_prepare_params(
state_root=multi_signature.value.state_root_hash,
bls_multi_sig=multi_signature,
ledger_id=POOL_LEDGER_ID)
return PrePrepare(*params)
def create_pre_prepare_no_bls(state_root, view_no=0, pool_state_root=None, pp_seq_no=0, inst_id=0, audit_txn_root=None):
params = create_pre_prepare_params(state_root=state_root,
view_no=view_no,
pool_state_root=pool_state_root,
pp_seq_no=pp_seq_no,
inst_id=inst_id,
audit_txn_root=audit_txn_root)
return PrePrepare(*params)
def test_process_pre_prepare_validation_old_schema_no_audit(
replica_with_requests, pre_prepare, mock_schema_audit_txn_root):
serialized_pp = ZStack.serializeMsg(pre_prepare)
deserialized_pp = ZStack.deserializeMsg(serialized_pp)
assert f.AUDIT_TXN_ROOT_HASH.nm not in PrePrepare.schema
pp = PrePrepare(**deserialized_pp)
replica_with_requests.processPrePrepare(pp,
replica_with_requests.primaryName)
def test_process_pre_prepare_validation_old_schema_no_pool(
replica_with_requests, pre_prepare, mock_schema_pool_state_root):
serialized_pp = ZStack.serializeMsg(pre_prepare)
deserialized_pp = ZStack.deserializeMsg(serialized_pp)
assert f.POOL_STATE_ROOT_HASH.nm not in PrePrepare.schema
pp = PrePrepare(**deserialized_pp)
replica_with_requests.processPrePrepare(pp,
replica_with_requests.primaryName)
def pre_prepare(replica, pool_state_root, fake_state_root_hash, fake_multi_sig,
request):
params = create_pre_prepare_params(state_root=fake_state_root_hash,
view_no=replica.viewNo,
pool_state_root=pool_state_root)
pp = PrePrepare(*params)
if request.param:
setattr(pre_prepare, f.BLS_MULTI_SIG.nm, fake_multi_sig)
return pp
def from_request(req, three_phase_handler):
replica = three_phase_handler.master_replica
args = [
replica.instId, replica.viewNo, replica.lastPrePrepareSeqNo + 1,
get_utc_epoch(), [req.digest],
init_discarded(), req.digest, DOMAIN_LEDGER_ID,
replica.stateRootHash(TOKEN_LEDGER_ID),
replica.txnRootHash(TOKEN_LEDGER_ID), 0, True
]
return PrePrepare(*args)
def pre_prepare(replica, state_roots, txn_roots, multi_sig, fake_requests):
params = create_pre_prepare_params(state_root=state_roots[DOMAIN_LEDGER_ID],
ledger_id=DOMAIN_LEDGER_ID,
txn_root=txn_roots[DOMAIN_LEDGER_ID],
bls_multi_sig=multi_sig,
view_no=replica.viewNo,
inst_id=replica.instId,
pool_state_root=state_roots[POOL_LEDGER_ID],
audit_txn_root=txn_roots[AUDIT_LEDGER_ID],
reqs=fake_requests)
pp = PrePrepare(*params)
return pp
