def testTrusteeCannotChangeVerkey(trustee, trusteeWallet, looper, nodeSet,
anotherTrustee, anotherTGB, anotherSteward,
anotherTrustAnchor):
for identity in (anotherTrustee, anotherTGB, anotherSteward,
anotherTrustAnchor):
# Trustee cannot change verkey
_, wallet = identity
signer = DidSigner()
changeVerkey(looper,
trustee,
trusteeWallet,
wallet.defaultId,
signer.verkey,
nAckReasonContains='TRUSTEE cannot update verkey')
# Identity owner can change verkey
changeVerkey(looper, *identity, wallet.defaultId, signer.verkey)
def updatedPoolTxnData(poolTxnData):
data = deepcopy(poolTxnData)
trusteeSeed = 'thisistrusteeseednotsteward12345'
signer = DidSigner(seed=trusteeSeed.encode())
t = {
TARGET_NYM: signer.identifier,
VERKEY: signer.verkey,
ROLE: TRUSTEE,
TYPE: NYM,
ALIAS: "Trustee1",
TXN_ID:
"6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4a"
}
data["seeds"]["Trustee1"] = trusteeSeed
data["txns"].insert(0, t)
return data
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 addRole(looper,
creatorClient,
creatorWallet,
name,
addVerkey=True,
role=None):
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,
role=role)
return wallet
def testNonTrustAnchoredNymCanDoGetNym(nodeSet, addedTrustAnchor,
trustAnchorWallet,
tdirWithClientPoolTxns, looper):
signer = DidSigner()
someClient, _ = genTestClient(nodeSet,
tmpdir=tdirWithClientPoolTxns,
usePoolLedger=True)
wallet = Wallet(someClient.name)
wallet.addIdentifier(signer=signer)
someClient.registerObserver(wallet.handleIncomingReply)
looper.add(someClient)
looper.run(someClient.ensureConnectedToNodes())
needle = trustAnchorWallet.defaultId
makeGetNymRequest(someClient, wallet, needle)
timeout = waits.expectedTransactionExecutionTime(len(nodeSet))
looper.run(
eventually(someClient.hasNym, needle, retryWait=1, timeout=timeout))
def build_wallet_core(wallet_name, seed_file):
config = getConfig()
baseDir = os.path.expanduser(config.baseDir)
seedFilePath = '{}/{}'.format(baseDir, seed_file)
seed = wallet_name + '0' * (32 - len(wallet_name))
# if seed file is available, read seed from it
if os.path.isfile(seedFilePath):
with open(seedFilePath, mode='r+') as file:
seed = file.read().strip(' \t\n\r')
wallet = Wallet(wallet_name)
seed = bytes(seed, encoding='utf-8')
wallet.addIdentifier(signer=DidSigner(seed=seed))
return wallet
def test_non_trust_anchor_cannot_create_user(nodeSet, looper, trustAnchor, addedTrustAnchor, client1):
with whitelistextras("UnknownIdentifier"):
non_trust_anchor = Wallet()
signer = DidSigner()
non_trust_anchor.addIdentifier(signer=signer)
createNym(looper,
non_trust_anchor.defaultId,
trustAnchor,
addedTrustAnchor,
role=None,
verkey=non_trust_anchor.getVerkey())
op = add_nym_operation(seed=b'a secret trust anchor seed......')
submitAndCheckRejects(looper=looper, client=client1, wallet=non_trust_anchor, op=op,
identifier=non_trust_anchor.defaultId,
contains="UnauthorizedClientRequest")
def testTrustAnchorSuspendingHimselfByVerkeyFlush(be, do, trusteeCli,
trustAnchorAdded,
nymAddedOut, trustAnchorCli):
# The trust anchor has already lost its role due to previous tests,
# but it is ok for this test where the trust anchor flushes its verkey
# and then he is unable to send NYM due to empty verkey.
be(trustAnchorCli)
do('send NYM dest={remote} verkey=',
within=5,
expect=nymAddedOut,
mapper=trustAnchorAdded)
s = DidSigner().identifier
errorMsg = "CouldNotAuthenticate('Can not find verkey for"
do('send NYM dest={remote}',
within=5,
expect=[errorMsg],
mapper={'remote': s})
def gen_trustee_def(cls, trustee_seeds):
if (trustee_seeds == None):
trustee_seeds = []
seed = "Trustee1"
seed = ('0' * (32 - len(seed)) + seed)
trustee_seeds.append(seed)
trustee_defs = []
for i in range(1, len(trustee_seeds) + 1):
d = adict()
d.name = "Trustee" + str(i)
d.sigseed = cls.get_signing_seed(trustee_seeds[i - 1])
t_signer = DidSigner(seed=d.sigseed)
d.nym = t_signer.identifier
d.verkey = t_signer.verkey
trustee_defs.append(d)
return trustee_defs
def anotherTrustAnchor(nodeSet, steward, stewardWallet, tdirWithClientPoolTxns,
looper):
sseed = b'1 secret trust anchor seed......'
signer = DidSigner(seed=sseed)
c, _ = genTestClient(nodeSet,
tmpdir=tdirWithClientPoolTxns,
usePoolLedger=True)
w = Wallet(c.name)
w.addIdentifier(signer=signer)
c.registerObserver(w.handleIncomingReply)
looper.add(c)
looper.run(c.ensureConnectedToNodes())
createNym(looper,
signer.identifier,
steward,
stewardWallet,
role=TRUST_ANCHOR,
verkey=signer.verkey)
return c, w
def addNyms():
with Looper(debug=getConfig().LOOPER_DEBUG) as looper:
from indy_client.test.helper import createNym
# Starting clients
print("Spawning client")
client, wallet = spawnClient(stewardName, 5678, stewardSeed)
client.registerObserver(wallet.handleIncomingReply)
print("Adding it to looper")
looper.add(client)
print("Running it")
looper.run(ensureConnectedToNodes(client))
# Creating request
print("Creating request")
bad = []
for seed in trustAnchorSeeds:
signer = DidSigner(seed=seed.encode())
nym = signer.identifier
verkey = signer.verkey
# Sending requests
print("Creating nym for seed {}".format(seed))
try:
createNym(looper=looper,
nym=nym,
creatorClient=client,
creatorWallet=wallet,
verkey=verkey,
role=TRUST_ANCHOR)
print("Successfully created nym for {}".format(seed))
except Exception as ex:
bad.append(seed)
print("Failed to create nym for {}".format(seed))
print("=======================")
if not bad:
print("All nyms created successfully")
else:
print("Failed to created nyms for:")
for nym in bad:
print("-", nym)
print("=======================")
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 gen_defs(cls, ips, nodeCount, starting_port):
"""
Generates some default steward and node definitions for tests
:param ips: array of ip addresses
:param nodeCount: number of stewards/nodes
:param starting_port: ports are assigned incremental starting with this
:return: duple of steward and node definitions
"""
if not ips:
ips = ['127.0.0.1'] * nodeCount
else:
if len(ips) != nodeCount:
if len(ips) > nodeCount:
ips = ips[:nodeCount]
else:
ips += ['127.0.0.1'] * (nodeCount - len(ips))
steward_defs = []
node_defs = []
for i in range(1, nodeCount + 1):
d = adict()
d.name = "Steward" + str(i)
d.sigseed = cls.getSigningSeed(d.name)
s_signer = DidSigner(seed=d.sigseed)
d.nym = s_signer.identifier
d.verkey = s_signer.verkey
steward_defs.append(d)
name = "Node" + str(i)
sigseed = cls.getSigningSeed(name)
node_defs.append(NodeDef(
name=name,
ip=ips[i - 1],
port=starting_port + (i * 2) - 1,
client_port=starting_port + (i * 2),
idx=i,
sigseed=sigseed,
verkey=Signer(sigseed).verhex,
steward_nym=d.nym))
return steward_defs, node_defs
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 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.signAndSend(msg, None, None, link.name)
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 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 newFullKeySigner(wallet, fullKeyIdr):
return DidSigner(identifier=fullKeyIdr)
from indy_client.client.wallet.wallet import Wallet
from indy_client.test.client.TestClient import TestClient
from indy_client.test.constants import primes
from stp_core.common.log import getlogger
from indy_client.agent.runnable_agent import RunnableAgent
from indy_client.agent.agent import create_client
from indy_client.test.agent.mock_backend_system import MockBackendSystem
from anoncreds.protocol.types import AttribType, AttribDef, ID, SchemaKey
from indy_client.agent.walleted_agent import WalletedAgent
logger = getlogger()
FABER_SEED = b'Faber000000000000000000000000000'
FABER_SIGNER = DidSigner(seed=FABER_SEED)
FABER_ID = FABER_SIGNER.identifier
FABER_VERKEY = FABER_SIGNER.verkey
def create_faber(name=None,
wallet=None,
base_dir_path=None,
port=5555,
client=None):
if client is None:
client = create_client(base_dir_path=base_dir_path,
client_class=TestClient)
endpoint_args = {'onlyListener': True}
def updateWalletIdrWithFullKeySigner(wallet, idr):
newSigner = DidSigner(identifier=idr)
wallet.updateSigner(idr, newSigner)
assertEquality(newSigner.verkey, wallet.getVerkey(idr))
checkFullVerkeySize(wallet.getVerkey(idr))
return newSigner.verkey
def newFullKeySigner(wallet, abbrevIdr):
return DidSigner(identifier=abbrevIdr)
def newAbbrvKey(wallet, abbrevIdr):
newSigner = DidSigner(identifier=abbrevIdr)
wallet.updateSigner(abbrevIdr, newSigner)
assertEquality(newSigner.verkey, wallet.getVerkey(abbrevIdr))
return newSigner.verkey
def testNewverkeyAddedToDID(be, do, philCli, abbrevIdr,
verkeyRemovedFromExistingDID):
newSigner = DidSigner()
addNym(be, do, philCli, abbrevIdr, newSigner.verkey)
getNym(be, do, philCli, abbrevIdr,
getCurrentVerkeyIsgMsgs(abbrevIdr, newSigner.verkey))
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 buildAgentWallet(name, seed):
wallet = Wallet(name)
wallet.addIdentifier(signer=DidSigner(seed=seed))
return wallet
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(
Member.nym_txn(nym=s_idr.identifier,
verkey=s_idr.verkey,
role=STEWARD,
name=steward_name,
seq_no=i))
node_txn = Steward.node_txn(steward_nym=s_idr.identifier,
node_name=node_name,
nym=n_idr,
ip='127.0.0.1',
node_port=genHa()[1],
client_port=genHa()[1],
client_ip='127.0.0.1',
services=[VALIDATOR],
seq_no=i)
if i <= nodes_with_bls:
_, bls_key, bls_key_proof = create_default_bls_crypto_factory(
).generate_bls_keys(seed=data['seeds'][node_name])
get_payload_data(node_txn)[DATA][BLS_KEY] = bls_key
get_payload_data(node_txn)[DATA][BLS_KEY_PROOF] = bls_key_proof
data['nodesWithBls'][node_name] = True
data['txns'].append(node_txn)
# Add 4 Trustees
for i in range(4):
trustee_name = 'Trs' + str(i)
data['seeds'][trustee_name] = trustee_name + '0' * (32 -
len(trustee_name))
t_sgnr = DidSigner(seed=data['seeds'][trustee_name].encode())
data['txns'].append(
Member.nym_txn(nym=t_sgnr.identifier,
verkey=t_sgnr.verkey,
role=TRUSTEE,
name=trustee_name))
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(
Member.nym_txn(
nym=signer.identifier,
verkey=signer.verkey,
name=more_name,
creator="5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC"))
data['txns'].extend(more_data_users)
data['seeds'].update(more_data_seeds)
return data
def ensurePoolIsOperable(be, do, cli):
randomNymMapper = {'remote': DidSigner(seed=randomSeed()).identifier}
addAgent(be, do, cli, randomNymMapper)
from sovrin_client.agent.agent import create_client
from sovrin_client.test.agent.mock_backend_system import MockBackendSystem
from sovrin_client.agent.walleted_agent import WalletedAgent
from sovrin_client.test.constants import primes
from sovrin_client.test.agent.helper import buildAcmeWallet
from sovrin_client.test.client.TestClient import TestClient
from anoncreds.protocol.types import AttribType, AttribDef, ID
logger = getlogger()
schema_id = None
ACME_SEED = b'Acme0000000000000000000000000000'
ACME_ID = DidSigner(seed=ACME_SEED).identifier
ACME_VERKEY = DidSigner(seed=ACME_SEED).verkey
ACME_SIGNER = DidSigner(seed=ACME_SEED)
class AcmeAgent(WalletedAgent):
async def postProofVerif(self, claimName, link, frm):
if claimName == "Job-Application":
for schema in await self.issuer.wallet.getAllSchemas():
if schema.name == 'Job-Certificate':
await self._set_available_claim_by_internal_id(
link.internalId,
ID(schemaKey=schema.getKey(), schemaId=schema.seqId))
def create_identifier_for_link(self, link):
signer = DidSigner()
self.wallet.addIdentifier(signer=signer)
link.localIdentifier = signer.identifier
link.localVerkey = signer.verkey
def _(name):
wallet = Wallet(name)
wallet.addIdentifier(signer=DidSigner())
return wallet
