def poolTxnData(request): nodeCount = getValueFromModule(request, "nodeCount", 4) nodes_with_bls = getValueFromModule(request, "nodes_wth_bls", nodeCount) data = {'txns': [], 'seeds': {}, 'nodesWithBls': {}} for i, node_name in zip(range(1, nodeCount + 1), genNodeNames(nodeCount)): data['seeds'][node_name] = node_name + '0' * (32 - len(node_name)) steward_name = 'Steward' + str(i) data['seeds'][steward_name] = steward_name + \ '0' * (32 - len(steward_name)) n_idr = SimpleSigner(seed=data['seeds'][node_name].encode()).identifier s_idr = DidSigner(seed=data['seeds'][steward_name].encode()) data['txns'].append({ TXN_TYPE: NYM, ROLE: STEWARD, ALIAS: steward_name, TARGET_NYM: s_idr.identifier, VERKEY: s_idr.verkey, }) node_txn = { TXN_TYPE: NODE, f.IDENTIFIER.nm: s_idr.identifier, TARGET_NYM: n_idr, DATA: { ALIAS: node_name, SERVICES: [VALIDATOR], NODE_IP: '127.0.0.1', NODE_PORT: genHa()[1], CLIENT_IP: '127.0.0.1', CLIENT_PORT: genHa()[1], } } if i <= nodes_with_bls: _, bls_key = create_default_bls_crypto_factory().generate_bls_keys( seed=data['seeds'][node_name]) node_txn[DATA][BLS_KEY] = bls_key data['nodesWithBls'][node_name] = True data['txns'].append(node_txn) more_data_seeds = \ { "Alice": "99999999999999999999999999999999", "Jason": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "John": "dddddddddddddddddddddddddddddddd", "Les": "ffffffffffffffffffffffffffffffff" } more_data_users = [] for more_name, more_seed in more_data_seeds.items(): signer = DidSigner(seed=more_seed.encode()) more_data_users.append({TXN_TYPE: NYM, ALIAS: more_name, TARGET_NYM: signer.identifier, VERKEY: signer.verkey, f.IDENTIFIER.nm: "5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC"}) data['txns'].extend(more_data_users) data['seeds'].update(more_data_seeds) return data
def addUser(looper, creatorClient, creatorWallet, name, addVerkey=True): wallet = Wallet(name) signer = DidSigner() idr, _ = wallet.addIdentifier(signer=signer) verkey = wallet.getVerkey(idr) if addVerkey else None createNym(looper, idr, creatorClient, creatorWallet, verkey=verkey) return wallet
def gen_defs(cls, ips, node_count, node_names, node_ports, client_ports): """ Generates some default steward and node definitions for tests :param ips: array of ip addresses :param node_count: number of stewards/nodes :return: duple of steward and node definitions """ steward_defs = [] node_defs = [] for i in range(1, node_count + 1): d = adict() d.name = "Steward" + str(i) d.sigseed = cls.get_signing_seed() s_signer = DidSigner(seed=d.sigseed) d.nym = s_signer.identifier d.verkey = s_signer.verkey steward_defs.append(d) name = node_names[i - 1] sigseed = cls.get_signing_seed() node_defs.append( NodeDef(name=name, ip=ips[i - 1], port=node_ports[i - 1], client_port=client_ports[i - 1], idx=i, sigseed=sigseed, verkey=Signer(sigseed).verhex, steward_nym=d.nym)) return steward_defs, node_defs
def put_load(): port = genHa()[1] ha = HA('0.0.0.0', port) name = "hello" wallet = Wallet(name) wallet.addIdentifier(signer=DidSigner( seed=b'000000000000000000000000Steward1')) client = Client(name, ha=ha) with Looper(debug=getConfig().LOOPER_DEBUG) as looper: looper.add(client) print('Will send {} reqs in all'.format(numReqs)) requests = sendRandomRequests(wallet, client, numReqs) start = perf_counter() for i in range(0, numReqs, numReqs // splits): print('Will wait for {} now'.format(numReqs // splits)) s = perf_counter() reqs = requests[i:i + numReqs // splits + 1] waitForSufficientRepliesForRequests(looper, client, requests=reqs, customTimeoutPerReq=100, override_timeout_limit=True) print('>>> Got replies for {} requests << in {}'.format( numReqs // splits, perf_counter() - s)) end = perf_counter() print('>>>Total {} in {}<<<'.format(numReqs, end - start)) exit(0)
def philCli(be, do, philCLI, trusteeCli): be(philCLI) do('prompt Phil', expect=prompt_is('Phil')) do('new keyring Phil', expect=['New keyring Phil created', 'Active keyring set to "Phil"']) phil_seed = '11111111111111111111111111111111' phil_signer = DidSigner(seed=phil_seed.encode()) mapper = {'seed': phil_seed, 'idr': phil_signer.identifier} do('new key with seed {seed}', expect=[ 'Key created in keyring Phil', 'Identifier for key is {idr}', 'Current identifier set to {idr}' ], mapper=mapper) addNym(be, do, trusteeCli, phil_signer.identifier, verkey=phil_signer.verkey, role=Roles.TRUSTEE.name) return philCLI
def newSigner(): while True: signer = DidSigner() idr = signer.identifier if idr not in usedIdentifiers: usedIdentifiers.add(idr) return signer
def _add_did(role, did_name, with_verkey=True): nonlocal data data['seeds'][did_name] = did_name + '0' * (32 - len(did_name)) t_sgnr = DidSigner(seed=data['seeds'][did_name].encode()) verkey = t_sgnr.full_verkey if with_verkey else None data['txns'].append( Member.nym_txn(nym=t_sgnr.identifier, verkey=verkey, role=role.value, name=did_name, creator=trustee.did) ) if verkey: (sdk_did, sdk_verkey) = looper.loop.run_until_complete( create_and_store_my_did( trustee.wallet_handle, json.dumps({'seed': data['seeds'][did_name]})) ) return DID( did=t_sgnr.identifier, role=role, verkey=verkey, creator=trustee, wallet_handle=trustee.wallet_handle )
def acceptInvitation(self, link: Union[str, Link]): if isinstance(link, str): link = self.wallet.getLink(link, required=True) elif isinstance(link, Link): pass else: raise TypeError("Type of link must be either string or Link but " "provided {}".format(type(link))) # TODO should move to wallet in a method like accept(link) if not link.localIdentifier: signer = DidSigner() self.wallet.addIdentifier(signer=signer) link.localIdentifier = signer.identifier msg = { TYPE: ACCEPT_INVITE, # TODO should not send this... because origin should be the sender NONCE: link.invitationNonce, VERKEY: self.wallet.getVerkey(link.localIdentifier) } logger.debug("{} accepting invitation from {} with id {}". format(self.name, link.name, link.localIdentifier)) self.agentLogger.info('Invitation accepted with nonce {} from id {}' .format(link.invitationNonce, link.localIdentifier)) self.signAndSend(msg, None, None, link.name)
def philCli(be, do, philCLI, trusteeCli, poolTxnData): be(philCLI) do('prompt Phil', expect=prompt_is('Phil')) do('new wallet Phil', expect=['New wallet Phil created', 'Active wallet set to "Phil"']) phil_seed = randomSeed() phil_signer = DidSigner(seed=phil_seed) mapper = {'seed': phil_seed.decode(), 'idr': phil_signer.identifier} do('new key with seed {seed}', expect=[ 'Key created in wallet Phil', 'DID for key is {idr}', 'Current DID set to {idr}' ], mapper=mapper) addNym(be, do, trusteeCli, phil_signer.identifier, verkey=phil_signer.verkey, role=Roles.TRUSTEE.name) return philCLI
def createAgent(agentClass, name, wallet=None, basedirpath=None, port=None, loop=None, clientClass=Client): config = getConfig() if not wallet: wallet = Wallet(name) wallet.addIdentifier(signer=DidSigner( seed=randomString(32).encode('utf-8'))) if not basedirpath: basedirpath = config.baseDir if not port: _, port = genHa() client = create_client(base_dir_path=basedirpath, client_class=clientClass) return agentClass(basedirpath=basedirpath, client=client, wallet=wallet, port=port, loop=loop)
def test_non_steward_cannot_create_trust_anchor(nodeSet, trustAnchor, addedTrustAnchor, client1, looper): with whitelistextras("UnknownIdentifier"): non_permission = Wallet() signer = DidSigner() non_permission.addIdentifier(signer=signer) createNym(looper, non_permission.defaultId, trustAnchor, addedTrustAnchor, role=None, verkey=non_permission.getVerkey()) op = add_nym_operation(seed=b'a secret trust anchor seed......', role=TRUST_ANCHOR) submitAndCheckRejects(looper=looper, client=client1, wallet=non_permission, op=op, identifier=non_permission.defaultId, contains="UnauthorizedClientRequest")
def new_identity(): wallet = Wallet(randomString(5)) signer = DidSigner() new_idr, _ = wallet.addIdentifier(signer=signer) verkey = wallet.getVerkey(new_idr) idy = Identity(identifier=new_idr, verkey=verkey, role=None) return idy, wallet
def nymsAddedInQuickSuccession(looper, nodeSet, sdk_added_raw_attribute, trustAnchor, trustAnchorWallet): usigner = DidSigner() nym = usigner.verkey idy = Identity(identifier=nym) trustAnchorWallet.addTrustAnchoredIdentity(idy) # Creating a NYM request with same nym again req = idy.ledgerRequest() trustAnchorWallet._pending.appendleft((req, idy.identifier)) reqs = trustAnchorWallet.preparePending() trustAnchor.submitReqs(*reqs) def check(): assert trustAnchorWallet._trustAnchored[nym].seqNo timeout = waits.expectedTransactionExecutionTime(len(nodeSet)) looper.run(eventually(check, timeout=timeout)) timeout = waits.expectedReqNAckQuorumTime() looper.run( eventually(checkNacks, trustAnchor, req.reqId, "is already added", retryWait=1, timeout=timeout)) count = 0 for node in nodeSet: for seq, txn in node.domainLedger.getAllTxn(): if txn[TXN_TYPE] == NYM and txn[TARGET_NYM] == usigner.identifier: count += 1 assert (count == len(nodeSet))
def test_attr_with_no_dest_added(nodeSet, tdirWithClientPoolTxns, looper, trustAnchor, addedTrustAnchor, attributeData): user_wallet = Wallet() signer = DidSigner() user_wallet.addIdentifier(signer=signer) client, _ = genTestClient(nodeSet, tmpdir=tdirWithClientPoolTxns, usePoolLedger=True) client.registerObserver(user_wallet.handleIncomingReply) looper.add(client) looper.run(client.ensureConnectedToNodes()) makePendingTxnsRequest(client, user_wallet) createNym(looper, user_wallet.defaultId, trustAnchor, addedTrustAnchor, role=None, verkey=user_wallet.getVerkey()) attr1 = json.dumps({'age': "24"}) attrib = Attribute(name='test4 attribute', origin=user_wallet.defaultId, value=attr1, dest=None, ledgerStore=LedgerStore.RAW) addAttributeAndCheck(looper, client, user_wallet, attrib)
def changeHA(looper, config, nodeName, nodeSeed, newNodeHA, stewardName, stewardsSeed, newClientHA=None, basedir=None): if not newClientHA: newClientHA = HA(newNodeHA.host, newNodeHA.port + 1) assert basedir is not None # prepare steward wallet stewardSigner = DidSigner(seed=stewardsSeed) stewardWallet = Wallet(stewardName) stewardWallet.addIdentifier(signer=stewardSigner) # prepare client to submit change ha request _, randomClientPort = genHa() client = Client(stewardName, ha=('0.0.0.0', randomClientPort), config=config, basedirpath=basedir) looper.add(client) timeout = waits.expectedClientToPoolConnectionTimeout(4) looper.run(eventually(__checkClientConnected, client, retryWait=1, timeout=timeout)) nodeVerKey = SimpleSigner(seed=nodeSeed).verkey # send request req = submitNodeIpChange(client, stewardWallet, nodeName, nodeVerKey, newNodeHA, newClientHA) return client, req
def changeNodeHa(looper, txnPoolNodeSet, tdirWithClientPoolTxns, poolTxnData, poolTxnStewardNames, tconf, shouldBePrimary, tdir): # prepare new ha for node and client stack subjectedNode = None stewardName = None stewardsSeed = None for nodeIndex, n in enumerate(txnPoolNodeSet): if shouldBePrimary == n.has_master_primary: subjectedNode = n stewardName = poolTxnStewardNames[nodeIndex] stewardsSeed = poolTxnData["seeds"][stewardName].encode() break nodeStackNewHA, clientStackNewHA = genHa(2) logger.debug("change HA for node: {} to {}".format( subjectedNode.name, (nodeStackNewHA, clientStackNewHA))) nodeSeed = poolTxnData["seeds"][subjectedNode.name].encode() # change HA stewardClient, req = changeHA(looper, tconf, subjectedNode.name, nodeSeed, nodeStackNewHA, stewardName, stewardsSeed, basedir=tdirWithClientPoolTxns) waitForSufficientRepliesForRequests(looper, stewardClient, requests=[req]) # stop node for which HA will be changed subjectedNode.stop() looper.removeProdable(subjectedNode) # start node with new HA config_helper = PNodeConfigHelper(subjectedNode.name, tconf, chroot=tdir) restartedNode = TestNode(subjectedNode.name, config_helper=config_helper, config=tconf, ha=nodeStackNewHA, cliha=clientStackNewHA) looper.add(restartedNode) txnPoolNodeSet[nodeIndex] = restartedNode looper.run(checkNodesConnected(txnPoolNodeSet, customTimeout=70)) electionTimeout = waits.expectedPoolElectionTimeout( nodeCount=len(txnPoolNodeSet), numOfReelections=3) ensureElectionsDone(looper, txnPoolNodeSet, retryWait=1, customTimeout=electionTimeout) # start client and check the node HA anotherClient, _ = genTestClient(tmpdir=tdirWithClientPoolTxns, usePoolLedger=True) looper.add(anotherClient) looper.run(eventually(anotherClient.ensureConnectedToNodes)) stewardWallet = Wallet(stewardName) stewardWallet.addIdentifier(signer=DidSigner(seed=stewardsSeed)) sendReqsToNodesAndVerifySuffReplies( looper, stewardWallet, stewardClient, 8)
def client1Signer(): seed = b'client1Signer secret key........' signer = DidSigner(seed=seed) testable_verkey = friendlyToRaw(signer.identifier) testable_verkey += friendlyToRaw(signer.verkey[1:]) testable_verkey = base58.b58encode(testable_verkey).decode("utf-8") assert testable_verkey == '6JvpZp2haQgisbXEXE9NE6n3Tuv77MZb5HdF9jS5qY8m' return signer
def testNewverkeyAddedToCID(be, do, philCli, trustAnchorSigner, verkeyRemovedFromExistingCID): newSigner = DidSigner() addNym(be, do, philCli, trustAnchorSigner.identifier, newSigner.verkey) getNym( be, do, philCli, trustAnchorSigner.identifier, getCurrentVerkeyIsgMsgs(trustAnchorSigner.identifier, newSigner.verkey))
def req(poolTxnClientData): _, seed = poolTxnClientData signer = DidSigner(seed=seed) request = { f.IDENTIFIER.nm: signer.identifier, f.REQ_ID.nm: int(time.time() * 10**6), OPERATION: { 'amount': 62, 'type': 'buy' }, f.PROTOCOL_VERSION.nm: CURRENT_PROTOCOL_VERSION } request[f.SIG.nm] = signer.sign(request) return request
def gen_trustee_def(cls, idx): d = adict() d.name = 'Trustee' + str(idx) d.sigseed = cls.getSigningSeed(d.name) t_signer = DidSigner(seed=d.sigseed) d.nym = t_signer.identifier d.verkey = t_signer.verkey return d
def newStewardVals(): newStewardSeed = randomSeed() signer = DidSigner(seed=newStewardSeed) return { 'newStewardSeed': newStewardSeed.decode(), 'newStewardIdr': signer.identifier, 'newStewardVerkey': signer.verkey }
def gen_client_def(cls, idx): d = adict() d.name = "Client" + str(idx) d.sigseed = cls.getSigningSeed(d.name) c_signer = DidSigner(seed=d.sigseed) d.nym = c_signer.identifier d.verkey = c_signer.verkey return d
def trustAnchorAdded(be, do, trusteeCli, nymAddedOut): global vals v = copy(vals) v['remote'] = vals['newTrustAnchorIdr'][0] v['remote_verkey'] = DidSigner(seed=vals['newTrustAnchorIdr'][1]).verkey be(trusteeCli) do('send NYM dest={{remote}} role={role} verkey={{remote_verkey}}'.format( role=Roles.TRUST_ANCHOR.name), within=5, expect=nymAddedOut, mapper=v) return v
def addRole(looper, creatorClient, creatorWallet, name, useDid=True, addVerkey=True, role=None): wallet = Wallet(name) signer = DidSigner() if useDid else SimpleSigner() idr, _ = wallet.addIdentifier(signer=signer) verkey = wallet.getVerkey(idr) if addVerkey else None createNym(looper, idr, creatorClient, creatorWallet, verkey=verkey, role=role) return wallet
def createClientAndWalletWithSeed(name, seed, ha=None): if isinstance(seed, str): seed = seed.encode() if not ha: port = genHa()[1] ha = HA('0.0.0.0', port) wallet = Wallet(name) wallet.addIdentifier(signer=DidSigner(seed=seed)) client = Client(name, ha=ha) return client, wallet
def __init__(self, identity_name, vault_path): self.vault_path = vault_path self.identity_name = identity_name self.seed = self.get_signing_seed() self.did = DidSigner(seed=self.seed).identifier self.bls_generator = BlsGenerator(self.seed) self.public_key = None self.secret_key = None self.sig_key = None self.verif_key = None
def nonTrustAnchor(looper, nodeSet, tdir): sseed = b'a secret trust anchor seed......' signer = DidSigner(seed=sseed) c, _ = genTestClient(nodeSet, tmpdir=tdir, usePoolLedger=True) w = Wallet(c.name) w.addIdentifier(signer=signer) c.registerObserver(w.handleIncomingReply) looper.add(c) looper.run(c.ensureConnectedToNodes()) return c, w
def buildPoolClientAndWallet(clientData, tempDir, clientClass=None, walletClass=None): walletClass = walletClass or Wallet clientClass = clientClass or TestClient name, sigseed = clientData w = walletClass(name) w.addIdentifier(signer=DidSigner(seed=sigseed)) client, _ = genTestClient(name=name, identifier=w.defaultId, tmpdir=tempDir, usePoolLedger=True, testClientClass=clientClass) return client, w
def spawnClient(clientName, port, signerSeed, host='0.0.0.0'): clientAddress = HA(host, port) # from plenum.client.request_id_store import FileRequestIdStore # walletFilePath = os.path.join(config.baseDir, "wallet") # print("Storing request ids in {}".format(walletFilePath)) # store = FileRequestIdStore(walletFilePath) # wallet = Wallet(clientName, store) wallet = Wallet(clientName) wallet.addIdentifier(signer=DidSigner(seed=signerSeed)) client = Client(clientName, ha=clientAddress) return client, wallet
def updatedPoolTxnData(poolTxnData): data = deepcopy(poolTxnData) trusteeSeed = 'thisistrusteeseednotsteward12345' signer = DidSigner(seed=trusteeSeed.encode()) t = Member.nym_txn(nym=signer.identifier, name="Trustee1", verkey=signer.verkey, role=TRUSTEE, txn_id="6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4a") data["seeds"]["Trustee1"] = trusteeSeed data["txns"].insert(0, t) return data