def two_requests(looper, helpers,
nodeSetWithIntegratedTokenPlugin,
sdk_pool_handle,
fees_set, address_main, mint_tokens, sdk_wallet_steward):
amount = get_amount_from_token_txn(mint_tokens)
init_seq_no = 1
seed = randomString(32)
alias = randomString(5)
wh, _ = sdk_wallet_steward
nym_request, new_did = looper.loop.run_until_complete(
prepare_nym_request(sdk_wallet_steward, seed,
alias, None))
nym_request = \
sdk_sign_request_objects(looper, sdk_wallet_steward, [sdk_json_to_request_object(json.loads(nym_request))])[0]
req_obj = sdk_json_to_request_object(json.loads(nym_request))
helpers.request.nym = lambda: copy.deepcopy(req_obj)
req1, req2 = nyms_with_fees(2,
helpers,
fees_set,
address_main,
amount,
init_seq_no=init_seq_no)
assert req1.payload_digest == req2.payload_digest
assert req1.digest != req2.digest
return req1, req2
def test_requests_collection_debugging(looper,
nodeSet,
sdk_wallet_trustee):
primary = nodeSet[0]
seed = randomString(32)
alias = randomString(5)
wh, _ = sdk_wallet_trustee
nym_request, new_did = looper.loop.run_until_complete(
prepare_nym_request(sdk_wallet_trustee, seed,
alias, STEWARD_STRING))
nym_request = json.loads(nym_request)
a = sys.getsizeof(primary.requests)
mas = []
for _ in range(50000):
req = sdk_json_to_request_object(nym_request)
req.reqId = randomString(32)
mas.append(req)
primary.requests.add_propagate(req, 'asd')
primary.requests.mark_as_forwarded(req, 2)
primary.requests.set_finalised(req)
b = sys.getsizeof(primary.requests)
lb = len(primary.requests)
for req in mas:
primary.requests.mark_as_executed(req)
primary.requests.free(req.key)
primary.requests.free(req.key)
c = sys.getsizeof(primary.requests)
lc = len(primary.requests)
for _ in range(100000):
req = sdk_json_to_request_object(nym_request)
req.reqId = randomString(32)
mas.append(req)
primary.requests.add_propagate(req, 'asd')
primary.requests.mark_as_forwarded(req, 2)
primary.requests.set_finalised(req)
d = sys.getsizeof(primary.requests)
ld = len(primary.requests)
print(a)
print(b, lb)
print(c, lc)
print(d, ld)
def sdk_sign_and_send_prepared_request(looper, sdk_wallet, sdk_pool_handle,
string_req):
signed_reqs = sdk_sign_request_objects(
looper, sdk_wallet,
[sdk_json_to_request_object(json.loads(string_req))])
request_couple = sdk_send_signed_requests(sdk_pool_handle, signed_reqs)[0]
return request_couple
def test_6_nodes_pool_cannot_reach_quorum_with_2_disconnected(
txnPoolNodeSet, looper, sdk_pool_handle,
sdk_wallet_client):
'''
Check that we can not reach consensus when more than n-f nodes
are disconnected: disconnect 2 of 6 nodes
'''
faulties = nodes_by_rank(txnPoolNodeSet)[-faultyNodes:]
current_node_set = set(txnPoolNodeSet)
for node in faulties:
for r in node.replicas:
assert not r.isPrimary
disconnect_node_and_ensure_disconnected(
looper, current_node_set, node, stopNode=False)
current_node_set.remove(node)
reqs = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
with pytest.raises(TimeoutError):
sdk_send_and_check(reqs, looper, txnPoolNodeSet, sdk_pool_handle)
check_request_is_not_returned_to_nodes(
txnPoolNodeSet, sdk_json_to_request_object(json.loads(reqs[0])))
# The following reconnection of nodes is needed in this test to avoid
# pytest process hangup
for node in faulties:
current_node_set.add(node)
reconnect_node_and_ensure_connected(looper, current_node_set, node)
def add_new_nym(looper,
sdk_pool_handle,
creators_wallets,
alias=None,
role=None,
seed=None,
dest=None,
verkey=None,
skipverkey=False,
no_wait=False):
seed = seed or randomString(32)
alias = alias or randomString(5)
wh, _ = creators_wallets[0]
# filling nym request and getting steward did
# if role == None, we are adding client
nym_request, new_did = looper.loop.run_until_complete(
prepare_nym_request(creators_wallets[0], seed, alias, role, dest,
verkey, skipverkey))
# sending request using 'sdk_' functions
signed_reqs = sdk_multi_sign_request_objects(
looper, creators_wallets,
[sdk_json_to_request_object(json.loads(nym_request))])
request_couple = sdk_send_signed_requests(sdk_pool_handle, signed_reqs)[0]
if no_wait:
return request_couple
# waitng for replies
sdk_get_and_check_replies(looper, [request_couple])
def testOneNodeAltersAClientRequest(looper, txnPoolNodeSet, setup, evilAlpha,
sent1):
sent1 = sdk_json_to_request_object(sent1[0][0])
checkPropagated(looper, txnPoolNodeSet, sent1, faultyNodes)
goodNodes = setup.goodNodes
def check():
for node in goodNodes:
# ensure the nodes are suspicious of Alpha
params = node.spylog.getLastParams(TestNode.reportSuspiciousNode)
frm = params["nodeName"]
reason = params["reason"]
assert frm == 'Alpha'
assert reason == InsufficientCorrectSignatures.reason.format(0, 1)
# ensure Alpha's propagates were ignored by the other nodes
key = sent1.identifier, sent1.reqId
props = node.requests[key].propagates
assert 'Alpha' not in props
for good in goodNodes:
assert good.name in props
timeout = waits.expectedClientRequestPropagationTime(len(txnPoolNodeSet))
looper.run(eventually(check, retryWait=1, timeout=timeout))
def testPropagateRecvdAfterRequest(setup, looper, txnPoolNodeSet):
A, B, C, D = txnPoolNodeSet # type: TestNode
sent1 = sdk_json_to_request_object(setup[0][0])
def x():
# A should have received a request from the client
assert len(recvdRequest(A)) == 1
# A should not have received a PROPAGATE
assert len(recvdPropagate(A)) == 0
# A should have sent a PROPAGATE
assert len(sentPropagate(A)) == 1
timeout = howlong - 2
looper.run(eventually(x, retryWait=.5, timeout=timeout))
for n in txnPoolNodeSet:
n.nodeIbStasher.resetDelays()
def y():
# A should have received 3 PROPAGATEs
assert len(recvdPropagate(A)) == 3
# A should have total of 4 PROPAGATEs (3 from other nodes and 1 from
# itself)
key = sent1.digest
assert key in A.requests
assert len(A.requests[key].propagates) == 4
# A should still have sent only one PROPAGATE
assert len(sentPropagate(A)) == 1
timeout = howlong + 2
looper.run(eventually(y, retryWait=.5, timeout=timeout))
def testPropagateRecvdAfterRequest(setup, looper, txnPoolNodeSet):
A, B, C, D = txnPoolNodeSet # type: TestNode
sent1 = sdk_json_to_request_object(setup[0][0])
def x():
# A should have received a request from the client
assert len(recvdRequest(A)) == 1
# A should not have received a PROPAGATE
assert len(recvdPropagate(A)) == 0
# A should have sent a PROPAGATE
assert len(sentPropagate(A)) == 1
timeout = howlong - 2
looper.run(eventually(x, retryWait=.5, timeout=timeout))
for n in txnPoolNodeSet:
n.nodeIbStasher.resetDelays()
def y():
# A should have received 3 PROPAGATEs
assert len(recvdPropagate(A)) == 3
# A should have total of 4 PROPAGATEs (3 from other nodes and 1 from
# itself)
key = sent1.digest
assert key in A.requests
assert len(A.requests[key].propagates) == 4
# A should still have sent only one PROPAGATE
assert len(sentPropagate(A)) == 1
timeout = howlong + 2
looper.run(eventually(y, retryWait=.5, timeout=timeout))
auth_obj = A.authNr(0).core_authenticator
auth_calling_count = get_count(auth_obj, auth_obj.authenticate)
assert auth_calling_count == reqCount
def test_6_nodes_pool_cannot_reach_quorum_with_2_disconnected(
txnPoolNodeSet, looper, sdk_pool_handle,
sdk_wallet_client):
'''
Check that we can not reach consensus when more than n-f nodes
are disconnected: disconnect 2 of 6 nodes
'''
faulties = nodes_by_rank(txnPoolNodeSet)[-faultyNodes:]
current_node_set = set(txnPoolNodeSet)
for node in faulties:
for r in node.replicas.values():
assert not r.isPrimary
disconnect_node_and_ensure_disconnected(
looper, current_node_set, node, stopNode=False)
current_node_set.remove(node)
reqs = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
with pytest.raises(PoolLedgerTimeoutException):
sdk_send_and_check(reqs, looper, txnPoolNodeSet, sdk_pool_handle)
check_request_is_not_returned_to_nodes(
txnPoolNodeSet, sdk_json_to_request_object(json.loads(reqs[0])))
# The following reconnection of nodes is needed in this test to avoid
# pytest process hangup
for node in faulties:
current_node_set.add(node)
reconnect_node_and_ensure_connected(looper, current_node_set, node)
def sdk_get_frozen_ledgers(looper, sdk_pool_handle, sdk_wallet):
req = looper.loop.run_until_complete(
build_get_frozen_ledgers_request(sdk_wallet[1]))
rep = sdk_sign_and_submit_req_obj(
looper, sdk_pool_handle, sdk_wallet,
sdk_json_to_request_object(json.loads(req)))
return sdk_get_and_check_replies(looper, [rep])[0]
def test_req_drop_on_propagate_phase_on_non_primary_and_then_ordered(
tconf, setup, looper, txnPoolNodeSet,
sdk_wallet_client, sdk_pool_handle):
global initial_ledger_size
A, B, C, D = txnPoolNodeSet # type: TestNode
sent1 = sdk_json_to_request_object(setup[0][0])
lagged_node = C
def check_propagates_and_3pc_delayed():
# Node should have received a request from the client
assert len(recvdRequest(lagged_node)) == 1
# Node should not have received a PROPAGATE
assert len(recvdPropagate(lagged_node)) == 0
# Node should have sent a PROPAGATE
assert len(sentPropagate(lagged_node)) == 1
# Node should have not received PrePrepares for master instance
assert len(recvdPrePrepareForInstId(lagged_node, 0)) == 0
# Node should have not received Prepares for master instance
assert len(recvdPrepareForInstId(lagged_node, 0)) == 0
# Node should have not received Commits for master instance
assert len(recvdCommitForInstId(lagged_node, 0)) == 0
# Node should have 1 request in requests queue
assert len(lagged_node.requests) == 1
timeout = howlong - 2
looper.run(eventually(check_propagates_and_3pc_delayed, retryWait=.5, timeout=timeout))
def check_drop():
assert len(lagged_node.requests) == 0
timeout = tconf.PROPAGATES_PHASE_REQ_TIMEOUT + tconf.OUTDATED_REQS_CHECK_INTERVAL + 1
looper.run(eventually(check_drop, retryWait=.5, timeout=timeout))
for n in txnPoolNodeSet:
n.nodeIbStasher.resetDelays()
def check_propagates_received():
# Node should have received 3 PROPAGATEs
assert len(recvdPropagate(lagged_node)) == 3
# Node should have total of 4 PROPAGATEs (3 from other nodes and 1 from
# itself)
key = sent1.digest
assert key in lagged_node.requests
assert len(lagged_node.requests[key].propagates) == 4
# Node should still have sent two PROPAGATEs since request
# was dropped and re-received over propagate
assert len(sentPropagate(lagged_node)) == 2
timeout = howlong + 2
looper.run(eventually(check_propagates_received, retryWait=.5, timeout=timeout))
def check_ledger_size():
# The request should be eventually ordered
for n in txnPoolNodeSet:
assert n.domainLedger.size - initial_ledger_size == 1
looper.run(eventually(check_ledger_size, retryWait=.5, timeout=timeout))
sdk_ensure_pool_functional(looper, txnPoolNodeSet, sdk_wallet_client, sdk_pool_handle)
def sdk_send_freeze_ledgers(looper, sdk_pool_handle, sdk_wallets,
ledgers_ids: [int]):
req = looper.loop.run_until_complete(
build_ledgers_freeze_request(sdk_wallets[0][1], ledgers_ids))
signed_reqs = sdk_multi_sign_request_objects(
looper, sdk_wallets, [sdk_json_to_request_object(json.loads(req))])
reps = sdk_send_signed_requests(sdk_pool_handle, signed_reqs)
return sdk_get_and_check_replies(looper, reps)[0]
def invalid_amount_xfer_request_utxo_does_not_exist(libsovtoken, payment_address, payment_address_2, wallet, looper):
input = make_utxo(payment_address, 2)
output = payment_address_2
xfer_request_future = build_payment_req(wallet, None, json.dumps([input]),
json.dumps([{"recipient": output, "amount": 9}]), None)
xfer_request, _ = looper.loop.run_until_complete(xfer_request_future)
xfer_request = sdk_json_to_request_object(json.loads(xfer_request))
return xfer_request
def test_6_nodes_pool_cannot_reach_quorum_with_2_faulty(
afterElection, looper, txnPoolNodeSet, prepared1, sdk_wallet_client,
sdk_pool_handle):
reqs = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
with pytest.raises(TimeoutError):
sdk_send_and_check(reqs, looper, txnPoolNodeSet, sdk_pool_handle)
check_request_is_not_returned_to_nodes(
txnPoolNodeSet, sdk_json_to_request_object(json.loads(reqs[0])))
def get_utxo_request(looper, payment_address, wallet):
get_utxo_request_future = build_get_payment_sources_request(
wallet, None, payment_address)
get_utxo_request, _ = looper.loop.run_until_complete(
get_utxo_request_future)
get_utxo_request = json.loads(get_utxo_request)
get_utxo_request = sdk_json_to_request_object(get_utxo_request)
return get_utxo_request
def test_6_nodes_pool_cannot_reach_quorum_with_2_faulty(afterElection, looper,
txnPoolNodeSet, prepared1,
sdk_wallet_client, sdk_pool_handle):
reqs = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
with pytest.raises(PoolLedgerTimeoutException):
sdk_send_and_check(reqs, looper, txnPoolNodeSet, sdk_pool_handle)
check_request_is_not_returned_to_nodes(
txnPoolNodeSet, sdk_json_to_request_object(json.loads(reqs[0])))
def test_make_result_bls_enabled(looper, txnPoolNodeSet,
sdk_pool_handle, sdk_wallet_client):
req_dict, _ = sdk_send_random_requests(looper, sdk_pool_handle, sdk_wallet_client, 1)[0]
req = sdk_json_to_request_object(req_dict)
wait_for_requests_ordered(looper, txnPoolNodeSet, [req])
assert req.protocolVersion
assert req.protocolVersion >= PlenumProtocolVersion.STATE_PROOF_SUPPORT.value
check_result(txnPoolNodeSet, req, True)
def test_make_result_bls_enabled(looper, txnPoolNodeSet,
sdk_pool_handle, sdk_wallet_client):
req_dict, _ = sdk_send_random_requests(looper, sdk_pool_handle, sdk_wallet_client, 1)[0]
req = sdk_json_to_request_object(req_dict)
wait_for_requests_ordered(looper, txnPoolNodeSet, [req])
assert req.protocolVersion
assert req.protocolVersion >= PlenumProtocolVersion.STATE_PROOF_SUPPORT.value
check_result(txnPoolNodeSet, req, True)
def reqAcked1(looper, txnPoolNodeSet, sent1, faultyNodes):
numerOfNodes = len(txnPoolNodeSet)
request = sdk_json_to_request_object(sent1[0][0])
# Wait until request received by all nodes
propTimeout = waits.expectedClientToPoolRequestDeliveryTime(numerOfNodes)
coros = [partial(checkLastClientReqForNode, node, request)
for node in txnPoolNodeSet]
chk_all_funcs(looper, coros, acceptable_fails=faultyNodes,
timeout=propTimeout)
return request
def _build_nym(self, creator_wallet, role_string, did, verkey=None, skipverkey=True):
seed = randomString(32)
alias = randomString(5)
nym_request, new_did = self.looper.loop.run_until_complete(
prepare_nym_request(creator_wallet,
seed,
alias,
role_string,
dest=did,
verkey=verkey,
skipverkey=skipverkey))
return sdk_json_to_request_object(json.loads(nym_request))
def reqAcked1(looper, txnPoolNodeSet, sent1, faultyNodes):
numerOfNodes = len(txnPoolNodeSet)
request = sdk_json_to_request_object(sent1[0][0])
# Wait until request received by all nodes
propTimeout = waits.expectedClientToPoolRequestDeliveryTime(numerOfNodes)
coros = [partial(checkLastClientReqForNode, node, request)
for node in txnPoolNodeSet]
chk_all_funcs(looper, coros, acceptable_fails=faultyNodes,
timeout=propTimeout)
return request
def test_make_proof_committed_head_used(looper, txnPoolNodeSet,
sdk_pool_handle, sdk_wallet_client):
req_dict, _ = sdk_send_random_requests(looper, sdk_pool_handle,
sdk_wallet_client, 1)[0]
req = sdk_json_to_request_object(req_dict)
wait_for_requests_ordered(looper, txnPoolNodeSet, [req])
key = BuyHandler.prepare_buy_key(req.identifier, req.reqId)
for node in txnPoolNodeSet:
node.states[DOMAIN_LEDGER_ID].set(key, b'somevalue')
check_result(txnPoolNodeSet, req, True)
def test_make_result_bls_disabled(looper, txnPoolNodeSet, sdk_wallet_client):
req = json.loads(
sdk_signed_random_requests(looper, sdk_wallet_client, 1)[0])
for node in txnPoolNodeSet:
req_handler = node.read_manager.request_handlers[GET_BUY]
key = BuyHandler.prepare_buy_key(req['identifier'], req['reqId'])
_, _, _, proof = req_handler.lookup(key, with_proof=True)
result = req_handler.make_result(sdk_json_to_request_object(req),
{TXN_TYPE: "buy"}, 2, get_utc_epoch(),
proof)
assert STATE_PROOF not in result
def test_6_nodes_pool_cannot_reach_quorum_with_2_disconnected(
txnPoolNodeSet, looper, sdk_pool_handle, sdk_wallet_client):
'''
Check that we can not reach consensus when more than n-f nodes are disconnected:
disconnect 2 of 6 nodes
'''
stop_nodes(looper, txnPoolNodeSet)
reqs = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
with pytest.raises(AssertionError):
sdk_send_and_check(reqs, looper, txnPoolNodeSet, sdk_pool_handle)
check_request_is_not_returned_to_nodes(
txnPoolNodeSet, sdk_json_to_request_object(json.loads(reqs[0])))
def test_make_result_bls_disabled(looper, txnPoolNodeSet, sdk_wallet_client):
req = json.loads(
sdk_signed_random_requests(looper, sdk_wallet_client, 1)[0])
for node in txnPoolNodeSet:
req_handler = node.get_req_handler(DOMAIN_LEDGER_ID)
key = req_handler.prepare_buy_key(req['identifier'], req['reqId'])
_, proof = req_handler.get_value_from_state(key, with_proof=True)
result = req_handler.make_result(sdk_json_to_request_object(req),
{TXN_TYPE: "buy"}, 2, get_utc_epoch(),
proof)
assert STATE_PROOF not in result
def test_make_proof_committed_head_used(looper, txnPoolNodeSet,
sdk_pool_handle, sdk_wallet_client):
req_dict, _ = sdk_send_random_requests(looper, sdk_pool_handle, sdk_wallet_client, 1)[0]
req = sdk_json_to_request_object(req_dict)
wait_for_requests_ordered(looper, txnPoolNodeSet, [req])
req_handler = txnPoolNodeSet[0].get_req_handler(DOMAIN_LEDGER_ID)
key = req_handler.prepare_buy_key(req.identifier, req.reqId)
for node in txnPoolNodeSet:
node.states[DOMAIN_LEDGER_ID].set(key, b'somevalue')
check_result(txnPoolNodeSet, req, True)
def test_make_result_bls_disabled(looper, txnPoolNodeSet, sdk_pool_handle,
sdk_wallet_client):
reqs = sdk_send_random_and_check(looper, txnPoolNodeSet, sdk_pool_handle,
sdk_wallet_client, 1)
req = reqs[0][1]['result']
for node in txnPoolNodeSet:
req_handler = node.get_req_handler(DOMAIN_LEDGER_ID)
key = req_handler.prepare_buy_key(req['identifier'], req['reqId'])
proof = req_handler.make_proof(key)
result = req_handler.make_result(
sdk_json_to_request_object(reqs[0][0]), {TXN_TYPE: "buy"}, 2,
get_utc_epoch(), proof)
assert STATE_PROOF not in result
def mint_request(libsovtoken, payment_address, wallet, trustees, looper):
mint_future = build_mint_req(wallet,
trustees[0],
json.dumps([{"recipient": payment_address, "amount": 10}]),
None)
mint_request, _ = looper.loop.run_until_complete(mint_future)
for trustee in trustees:
mint_future = multi_sign_request(wallet, trustee, mint_request)
mint_request = looper.loop.run_until_complete(mint_future)
mint_request = json.loads(mint_request)
sigs = mint_request["signatures"]
mint_request = sdk_json_to_request_object(mint_request)
setattr(mint_request, "signatures", sigs)
return mint_request
def testOneNodeAltersAClientRequest(looper,
txnPoolNodeSet,
evilAlpha,
sdk_pool_handle,
sdk_wallet_client):
"""Malicious Alpha node sends incorrect propagate. This test check that
nodes raise InsufficientCorrectSignatures in validate this propagate"""
# TODO: This test is throwing a `indy.error.PoolLedgerTerminated` exception
# This is probably happening because a request is sent and the pool is terminated before the reply is processed
alpha = txnPoolNodeSet[0]
goodNodes = list(txnPoolNodeSet)
goodNodes.remove(alpha)
# delay incoming client messages for good nodes by 250 milliseconds
# this gives Alpha a chance to send a propagate message
for n in goodNodes: # type: TestNode
n.nodeIbStasher.delay(ppDelay(sys.maxsize))
n.nodeIbStasher.delay(req_delay(sys.maxsize))
pastNodes = []
request_couple_json = sdk_send_random_requests(looper, sdk_pool_handle,
sdk_wallet_client, 1)
sent1 = sdk_json_to_request_object(request_couple_json[0][0])
checkPropagated(looper, txnPoolNodeSet, sent1, faultyNodes)
def check():
for node in goodNodes:
if node not in pastNodes:
# ensure the nodes are suspicious of Alpha
params = node.spylog.getLastParams(TestNode.reportSuspiciousNode)
frm = params["nodeName"]
reason = params["reason"]
assert frm == 'Alpha'
invalid_signatures = 'did={}, signature={}'.format(sent1.identifier, sent1.signature)
assert reason == InsufficientCorrectSignatures.reason.format(1, 0, 1, invalid_signatures)
# ensure Alpha's propagates were ignored by the other nodes
key = sent1.digest
props = node.requests[key].propagates
assert 'Alpha' not in props
for good in goodNodes:
assert good.name in props
pastNodes.append(node)
for node in goodNodes:
node.nodeIbStasher.resetDelays()
timeout = waits.expectedClientRequestPropagationTime(len(txnPoolNodeSet))
looper.run(eventually(check, retryWait=1, timeout=timeout))
def set_fees_request(libsovtoken, looper, trustees, wallet, fees):
set_fees_future = build_set_txn_fees_req(wallet,
trustees[0],
"sov",
fees)
set_fees_request = looper.loop.run_until_complete(set_fees_future)
for trustee in trustees:
set_fees_future = multi_sign_request(wallet, trustee, set_fees_request)
set_fees_request = looper.loop.run_until_complete(set_fees_future)
set_fees_request = json.loads(set_fees_request)
sigs = set_fees_request["signatures"]
set_fees_request = sdk_json_to_request_object(set_fees_request)
setattr(set_fees_request, "signatures", sigs)
return set_fees_request
def testOneNodeAltersAClientRequest(looper,
txnPoolNodeSet,
evilAlpha,
sdk_pool_handle,
sdk_wallet_client):
"""Malicious Alpha node sends incorrect propagate. This test check that
nodes raise InsufficientCorrectSignatures in validate this propagate"""
alpha = txnPoolNodeSet[0]
goodNodes = list(txnPoolNodeSet)
goodNodes.remove(alpha)
# delay incoming client messages for good nodes by 250 milliseconds
# this gives Alpha a chance to send a propagate message
for n in goodNodes: # type: TestNode
n.nodeIbStasher.delay(ppDelay(sys.maxsize))
n.nodeIbStasher.delay(req_delay(sys.maxsize))
pastNodes = []
request_couple_json = sdk_send_random_requests(looper, sdk_pool_handle,
sdk_wallet_client, 1)
sent1 = sdk_json_to_request_object(request_couple_json[0][0])
checkPropagated(looper, txnPoolNodeSet, sent1, faultyNodes)
def check():
for node in goodNodes:
if node not in pastNodes:
# ensure the nodes are suspicious of Alpha
params = node.spylog.getLastParams(TestNode.reportSuspiciousNode)
frm = params["nodeName"]
reason = params["reason"]
assert frm == 'Alpha'
assert reason == InsufficientCorrectSignatures.reason.format(0, 1)
# ensure Alpha's propagates were ignored by the other nodes
key = sent1.digest
props = node.requests[key].propagates
assert 'Alpha' not in props
for good in goodNodes:
assert good.name in props
pastNodes.append(node)
for node in goodNodes:
node.nodeIbStasher.resetDelays()
timeout = waits.expectedClientRequestPropagationTime(len(txnPoolNodeSet))
looper.run(eventually(check, retryWait=1, timeout=timeout))
def nym_request_with_fees(libsovtoken, nym_request, wallet, payment_address,
looper):
inputs = json.dumps([
"txo:sov:" + b58encode_check(
json.dumps({
"address": payment_address,
"seqNo": 1
}).encode()).decode()
])
outputs = json.dumps([{"recipient": payment_address, "amount": 9}])
fees_future = add_request_fees(wallet, None, nym_request, inputs, outputs,
None)
fees, _ = looper.loop.run_until_complete(fees_future)
fees_req = json.loads(fees)
fees = fees_req[FEES]
fees_req = sdk_json_to_request_object(fees_req)
setattr(fees_req, FEES, fees)
return fees_req
def test_txn_with_different_signature_and_idr(looper, txnPoolNodeSet,
sdk_pool_handle,
sdk_wallet_trustee,
sdk_wallet_client):
# filling nym request and getting steward did
nym_request, new_did = looper.loop.run_until_complete(
prepare_nym_request(sdk_wallet_trustee, randomString(32),
'newSteward1', STEWARD_STRING))
# sending request using 'sdk_' functions
signed_reqs = sdk_multi_sign_request_objects(
looper, [sdk_wallet_client],
[sdk_json_to_request_object(json.loads(nym_request))])
request_couple = sdk_send_signed_requests(sdk_pool_handle, signed_reqs)[0]
with pytest.raises(RequestNackedException,
match="The identifier is not contained in signatures"):
# waiting for replies
sdk_get_and_check_replies(looper, [request_couple])
def testSendRequestWithoutSignatureFails(looper, txnPoolNodeSet,
sdk_pool_handle, sdk_wallet_client):
"""
A client request sent without a signature fails with an EmptySignature
exception
"""
# remove the client's ability to sign
requests = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
json_req = json.loads(requests[0])
json_req['signature'] = None
request = json.dumps(json_req)
res = sdk_send_signed_requests(sdk_pool_handle, [request])
obj_req = sdk_json_to_request_object(res[0][0])
timeout = waits.expectedClientRequestPropagationTime(nodeCount)
with pytest.raises(AssertionError):
for node in txnPoolNodeSet:
looper.loop.run_until_complete(
eventually(checkLastClientReqForNode,
node,
obj_req,
retryWait=1,
timeout=timeout))
for n in txnPoolNodeSet:
params = n.spylog.getLastParams(Node.handleInvalidClientMsg)
ex = params['ex']
msg, _ = params['wrappedMsg']
assert isinstance(ex, MissingSignature)
assert msg.get(f.IDENTIFIER.nm) == obj_req.identifier
params = n.spylog.getLastParams(Node.discard)
reason = params["reason"]
(msg, frm) = params["msg"]
assert msg == json_req
assert msg.get(f.IDENTIFIER.nm) == obj_req.identifier
assert "MissingSignature" in reason
def _build_node(self, steward_wallet_handle, tconf, tdir, services=[VALIDATOR],
node_name=None, node_data=None):
if not node_name:
node_name = randomString(10)
print(node_name)
sigseed, verkey, bls_key, nodeIp, nodePort, clientIp, clientPort, key_proof = \
prepare_new_node_data(tconf, tdir, node_name) if not node_data else node_data
# filling node request
_, steward_did = steward_wallet_handle
node_request = self.looper.loop.run_until_complete(
prepare_node_request(steward_did,
new_node_name=node_name,
clientIp=clientIp,
clientPort=clientPort,
nodeIp=nodeIp,
nodePort=nodePort,
bls_key=bls_key,
sigseed=sigseed,
services=services,
key_proof=key_proof))
node_data = sigseed, verkey, bls_key, nodeIp, nodePort, clientIp, clientPort, key_proof
return sdk_json_to_request_object(json.loads(node_request)), node_data, node_name
def _send_request(looper, helpers, fees, wallets_count, address, owner,
sdk_wallet_trustee, sdk_wallet_trustees, sdk_wallet_stewards,
sdk_wallet_clients, sdk_wallet_trust_anchors):
print(wallets_count)
wallets = sdk_wallet_trustees[:wallets_count.get(TRUSTEE, 0)] + \
sdk_wallet_stewards[:wallets_count.get(STEWARD, 0)] + \
sdk_wallet_clients[:wallets_count.get(IDENTITY_OWNER, 0)] + \
sdk_wallet_trust_anchors[:wallets_count.get(TRUST_ANCHOR, 0)]
# prepare owner parameter
if owner == TRUSTEE:
sender_wallet = sdk_wallet_trustees[0]
elif owner == STEWARD:
sender_wallet = sdk_wallet_stewards[0]
elif owner == IDENTITY_OWNER:
sender_wallet = sdk_wallet_clients[0]
elif owner == TRUST_ANCHOR:
sender_wallet = sdk_wallet_trust_anchors[0]
else:
sender_wallet = wallets[0]
target_dest = sdk_wallet_trustee[1] if owner == "-1" else sender_wallet[1]
# prepare data
data = SecretBox().encrypt(json.dumps({'name': 'Jaime'}).encode()).hex()
# create request
request = add_attribute(looper, sender_wallet, None, target_dest, enc=data)
request = sdk_json_to_request_object(json.loads(request))
request.signature = None
request.signatures = None
# add fees
request = add_fees_request_with_address(helpers, fees, request, address)
# sign request
request = sdk_multi_sign_request_objects(looper, wallets, [request])
return helpers.sdk.sdk_send_and_check(request)
def testSendRequestWithoutSignatureFails(looper, txnPoolNodeSet,
sdk_pool_handle, sdk_wallet_client):
"""
A client request sent without a signature fails with an EmptySignature
exception
"""
# remove the client's ability to sign
requests = sdk_signed_random_requests(looper, sdk_wallet_client, 1)
json_req = json.loads(requests[0])
json_req['signature'] = None
request = json.dumps(json_req)
res = sdk_send_signed_requests(sdk_pool_handle, [request])
obj_req = sdk_json_to_request_object(res[0][0])
timeout = waits.expectedClientRequestPropagationTime(nodeCount)
with pytest.raises(AssertionError):
for node in txnPoolNodeSet:
looper.loop.run_until_complete(eventually(
checkLastClientReqForNode, node, obj_req,
retryWait=1, timeout=timeout))
for n in txnPoolNodeSet:
params = n.spylog.getLastParams(Node.handleInvalidClientMsg)
ex = params['ex']
msg, _ = params['wrappedMsg']
assert isinstance(ex, MissingSignature)
assert msg.get(f.IDENTIFIER.nm) == obj_req.identifier
params = n.spylog.getLastParams(Node.discard)
reason = params["reason"]
(msg, frm) = params["msg"]
assert msg == json_req
assert msg.get(f.IDENTIFIER.nm) == obj_req.identifier
assert "MissingSignature" in reason
def testReplicasRejectSamePrePrepareMsg(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client):
"""
Replicas should not accept PRE-PREPARE for view "v" and prepare sequence
number "n" if it has already accepted a request with view number "v" and
sequence number "n"
"""
numOfNodes = 4
fValue = getMaxFailures(numOfNodes)
primaryRepl = getPrimaryReplica(txnPoolNodeSet, 1)
logger.debug("Primary Replica: {}".format(primaryRepl))
nonPrimaryReplicas = getNonPrimaryReplicas(txnPoolNodeSet, 1)
logger.debug("Non Primary Replicas: " + str(nonPrimaryReplicas))
# Delay COMMITs so request is not ordered and checks can be made
c_delay = 10
for node in txnPoolNodeSet:
node.nodeIbStasher.delay(cDelay(delay=c_delay, instId=1))
req1 = sdk_send_random_requests(looper,
sdk_pool_handle,
sdk_wallet_client,
1)[0]
request1 = sdk_json_to_request_object(req1[0])
for npr in nonPrimaryReplicas:
looper.run(eventually(checkPrepareReqSent,
npr,
request1.key,
primaryRepl.viewNo,
retryWait=1))
prePrepareReq = primaryRepl.sentPrePrepares[primaryRepl.viewNo,
primaryRepl.lastPrePrepareSeqNo]
looper.run(eventually(checkPrePrepareReqRecvd,
nonPrimaryReplicas,
prePrepareReq,
retryWait=1))
# logger.debug("Patching the primary replica's pre-prepare sending method ")
# orig_method = primaryRepl.sendPrePrepare
# def patched(self, ppReq):
# self.sentPrePrepares[ppReq.viewNo, ppReq.ppSeqNo] = ppReq
# ppReq = updateNamedTuple(ppReq, **{f.PP_SEQ_NO.nm: 1})
# self.send(ppReq, TPCStat.PrePrepareSent)
#
# primaryRepl.sendPrePrepare = types.MethodType(patched, primaryRepl)
logger.debug(
"Decrementing the primary replica's pre-prepare sequence number by "
"one...")
primaryRepl._lastPrePrepareSeqNo -= 1
view_no = primaryRepl.viewNo
request2 = sdk_json_to_request_object(
sdk_send_random_requests(looper,
sdk_pool_handle,
sdk_wallet_client,
1)[0][0])
timeout = waits.expectedPrePrepareTime(len(txnPoolNodeSet))
looper.run(eventually(checkPrePrepareReqSent, primaryRepl, request2,
retryWait=1, timeout=timeout))
# Since the node is malicious, it will not be able to process requests due
# to conflicts in PRE-PREPARE
primaryRepl.node.stop()
looper.removeProdable(primaryRepl.node)
reqIdr = [request2.digest]
prePrepareReq = PrePrepare(
primaryRepl.instId,
view_no,
primaryRepl.lastPrePrepareSeqNo,
get_utc_epoch(),
reqIdr,
init_discarded(),
primaryRepl.batchDigest([request2]),
DOMAIN_LEDGER_ID,
primaryRepl.stateRootHash(DOMAIN_LEDGER_ID),
primaryRepl.txnRootHash(DOMAIN_LEDGER_ID),
0,
True
)
logger.debug("""Checking whether all the non primary replicas have received
the pre-prepare request with same sequence number""")
timeout = waits.expectedPrePrepareTime(len(txnPoolNodeSet))
looper.run(eventually(checkPrePrepareReqRecvd,
nonPrimaryReplicas,
prePrepareReq,
retryWait=1,
timeout=timeout))
logger.debug("""Check that none of the non primary replicas didn't send
any prepare message "
in response to the pre-prepare message""")
timeout = waits.expectedPrepareTime(len(txnPoolNodeSet))
looper.runFor(timeout) # expect prepare processing timeout
# check if prepares have not been sent
for npr in nonPrimaryReplicas:
with pytest.raises(AssertionError):
looper.run(eventually(checkPrepareReqSent,
npr,
request2.key,
view_no,
retryWait=1,
timeout=timeout))
timeout = waits.expectedTransactionExecutionTime(len(txnPoolNodeSet)) + c_delay
result1 = sdk_get_replies(looper, [req1])[0][1]
logger.debug("request {} gives result {}".format(request1, result1))
def sdk_sign_and_send_prepared_request(looper, sdk_wallet, sdk_pool_handle, string_req):
signed_reqs = sdk_sign_request_objects(looper, sdk_wallet,
[sdk_json_to_request_object(
json.loads(string_req))])
request_couple = sdk_send_signed_requests(sdk_pool_handle, signed_reqs)[0]
return request_couple
def sdk_json_to_request_object(self, obj):
return plenum_helper.sdk_json_to_request_object(obj)
