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)