def test_create_invitation__with_label(self):
conn = WalletConnection(self.WALLET_UID, self.WALLET_PASS_PHRASE)
wallet = Wallet.objects.create(uid=self.WALLET_UID, owner=self.account)
endpoint = Endpoint.objects.create(uid='endpoint_uid',
owner=self.account,
wallet=wallet,
url='http://example.com/endpoint')
# first: create wallet
run_async(conn.create())
try:
label = 'My Test Label'
cred = dict(pass_phrase=self.WALLET_PASS_PHRASE, label=label)
url = self.live_server_url + '/agent/admin/wallets/%s/endpoints/%s/invitations/' % (
self.WALLET_UID, endpoint.uid)
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(201, resp.status_code)
entity = resp.json()
self.assertTrue(entity['url'])
invite_url = entity['url']
matches = re.match("(.+)?c_i=(.+)", invite_url)
self.assertTrue(matches)
_ = base64.urlsafe_b64decode(matches.group(2)).decode('utf-8')
invite_msg = json.loads(_)
self.assertEqual(label, invite_msg.get('label'))
finally:
os.popen("pkill -f run_wallet_agent")
sleep(1)
run_async(conn.delete())
def test_create_invitation_with_seed(self):
conn = WalletConnection(self.WALLET_UID, self.WALLET_PASS_PHRASE)
wallet = Wallet.objects.create(uid=self.WALLET_UID, owner=self.account)
endpoint = Endpoint.objects.create(uid='endpoint_uid',
owner=self.account,
wallet=wallet,
url='http://example.com/endpoint')
# first: create wallet
run_async(conn.create())
try:
seed = 'blablabla-seed-'
expected_key = '3XvPjB4EDpmBBF4sRmqVbrQXQY5vk7zjiggSCGxSkPpV'
cred = dict(pass_phrase=self.WALLET_PASS_PHRASE, seed=seed)
url = self.live_server_url + '/agent/admin/wallets/%s/endpoints/%s/invitations/' % (
self.WALLET_UID, endpoint.uid)
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(201, resp.status_code)
instance = Invitation.objects.get(endpoint=endpoint)
connection_key = resp.json()['connection_key']
self.assertEqual(expected_key, connection_key)
self.assertEqual(instance.connection_key, connection_key)
self.assertEqual(instance.seed, seed)
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(409, resp.status_code)
finally:
os.popen("pkill -f run_wallet_agent")
sleep(1)
run_async(conn.delete())
def test_create_and_store_my_did__with_seed(self):
conn = WalletConnection(self.WALLET_UID, self.WALLET_PASS_PHRASE)
wallet = Wallet.objects.create(uid=self.WALLET_UID, owner=self.account)
url = self.live_server_url + '/agent/admin/wallets/%s/did/create_and_store_my_did/' % wallet.uid
# first: create wallet
run_async(conn.create())
try:
cred = dict(pass_phrase=self.WALLET_PASS_PHRASE,
seed='000000000000000000000000Steward1')
# open
url_open = self.live_server_url + reverse(
'admin-wallets-open', kwargs=dict(uid=self.WALLET_UID))
resp = requests.post(url_open,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(200, resp.status_code)
# FIRE!!!
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(201, resp.status_code)
info = resp.json()
self.assertTrue(info.get('did'))
self.assertTrue(info.get('verkey'))
# Fire second time
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertIn(resp.status_code, [201, 409])
finally:
os.popen("pkill -f run_wallet_agent")
sleep(1)
run_async(conn.delete())
def create_did(self, wallet_uid: str, seed: str = None):
run_async(WalletAgent.open(wallet_uid, self.WALLET_PASS_PHRASE))
did, verkey = run_async(
WalletAgent.create_and_store_my_did(wallet_uid,
self.WALLET_PASS_PHRASE, seed))
run_async(
WalletAgent.add_wallet_record(wallet_uid, self.WALLET_PASS_PHRASE,
WALLET_KEY_TO_DID_KEY, verkey, did))
return did, verkey
def test_create_invitation_with_did(self):
conn = WalletConnection(self.WALLET_UID, self.WALLET_PASS_PHRASE)
wallet = Wallet.objects.create(uid=self.WALLET_UID, owner=self.account)
endpoint = Endpoint.objects.create(uid='endpoint_uid',
owner=self.account,
wallet=wallet,
url='http://example.com/endpoint')
# first: create wallet
run_async(conn.create())
run_async(conn.open())
my_did, my_verkey = run_async(conn.create_and_store_my_did())
run_async(conn.close())
try:
cred = dict(pass_phrase=self.WALLET_PASS_PHRASE, my_did=my_did)
url = self.live_server_url + '/agent/admin/wallets/%s/endpoints/%s/invitations/' % (
self.WALLET_UID, endpoint.uid)
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(201, resp.status_code)
instance = Invitation.objects.get(endpoint=endpoint)
self.assertEqual(my_did, instance.my_did)
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(201, resp.status_code)
finally:
os.popen("pkill -f run_wallet_agent")
sleep(1)
run_async(conn.delete())
def test_list_my_dids_with_meta(self):
conn = WalletConnection(self.WALLET_UID, self.WALLET_PASS_PHRASE)
wallet = Wallet.objects.create(uid=self.WALLET_UID, owner=self.account)
url = self.live_server_url + '/agent/admin/wallets/%s/did/list_my_dids_with_meta/' % wallet.uid
# first: create wallet
run_async(conn.create())
try:
# create did from seed
run_async(conn.open())
did, verkey = run_async(
conn.create_and_store_my_did(
seed='000000000000000000000000Steward1'))
run_async(conn.close())
cred = dict(pass_phrase=self.WALLET_PASS_PHRASE)
# open
url_open = self.live_server_url + reverse(
'admin-wallets-open', kwargs=dict(uid=self.WALLET_UID))
resp = requests.post(url_open,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(200, resp.status_code)
# FIRE!!!
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(200, resp.status_code)
raw = json.dumps(resp.json())
self.assertIn(did, raw)
self.assertIn(verkey, raw)
finally:
os.popen("pkill -f run_wallet_agent")
sleep(1)
run_async(conn.delete())
def stop_agents(self):
async def stop_agent(agent_name, pass_phrase):
try:
await WalletAgent.close(agent_name, pass_phrase)
except AgentTimeOutError:
pass
for agent in [self.WALLET_AGENT1, self.WALLET_AGENT2]:
run_async(stop_agent(agent, self.WALLET_PASS_PHRASE))
sleep(5)
for thread in self.agents:
thread.stop()
def setUp(self):
self.ws = websocket.WebSocket()
self.server_url = self.live_server_url
self.server_url = self.server_url.replace('http://', 'ws://')
self.server_url = self.server_url.replace('https://', 'ws://')
self.account = AgentAccount.objects.create(username=self.IDENTITY, is_active=True, is_staff=True)
self.account.set_password(self.PASS)
self.account.save()
self.assertTrue(self.account.check_password(self.PASS))
self.wallet = None
run_async(self.create_wallet())
super().setUp()
def ensure_exists(self, request, *args, **kwargs):
wallet = self.get_wallet()
serializer = EnsureExistsInvitationSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
entity = serializer.create(serializer.validated_data)
pass_phrase = extract_pass_phrase(request)
invitation_label = entity.get('label') or request.user.username
seed = entity['seed']
invitation_inst = self.get_endpoint().invitations.filter(
seed=seed,
feature=EnsureExistsInvitationSerializer.FEATURE_0160_ARIES_RFC
).first()
if invitation_inst:
connection_key = invitation_inst.connection_key
invite_string, invite_msg = run_async(
ConnectionProtocol.generate_invite_link(
label=invitation_label,
endpoint=self.get_endpoint().url,
agent_name=wallet.uid,
pass_phrase=pass_phrase,
connection_key=connection_key),
timeout=10)
invitation_inst.invitation_string = invite_string
invitation_inst.my_did = entity.get('my_did', None)
invitation_inst.save()
entity['url'] = invitation_inst.invitation_url
entity['connection_key'] = connection_key
else:
invite_string, invite_msg = run_async(
ConnectionProtocol.generate_invite_link(
label=invitation_label,
endpoint=self.get_endpoint().url,
agent_name=wallet.uid,
pass_phrase=pass_phrase,
seed=entity.get('seed', None)),
timeout=10)
connection_key = invite_msg['recipientKeys'][0]
instance = Invitation.objects.create(
endpoint=self.get_endpoint(),
invitation_string=invite_string,
feature=EnsureExistsInvitationSerializer.
FEATURE_0160_ARIES_RFC,
connection_key=connection_key,
seed=seed,
my_did=entity.get('my_did', None))
entity['url'] = instance.invitation_url
entity['connection_key'] = connection_key
entity['label'] = invitation_label
serializer = CreateInvitationSerializer(instance=entity)
return Response(data=serializer.data)
def test_ensure_exists(self):
conn = WalletConnection(self.WALLET_UID, self.WALLET_PASS_PHRASE)
try:
url = self.live_server_url + '/agent/admin/wallets/ensure_exists/'
cred = dict(pass_phrase=self.WALLET_PASS_PHRASE,
uid=self.WALLET_UID)
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertIn(resp.status_code, [200, 201])
finally:
os.popen("pkill -f run_wallet_agent")
sleep(1)
run_async(conn.delete())
def create(self, request, *args, **kwargs):
wallet = self.get_wallet()
serializer = CreateInvitationSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
entity = serializer.create(serializer.validated_data)
pass_phrase = extract_pass_phrase(request)
invitation_label = entity.get('label') or request.user.username
# FIRE!!!
if entity['feature'] == InvitationSerializer.FEATURE_0023_ARIES_RFC:
invite_string, invite_msg = run_async(
DIDExchangeFeature.generate_invite_link(
label=invitation_label,
endpoint=self.get_endpoint().url,
agent_name=wallet.uid,
pass_phrase=pass_phrase,
),
timeout=10)
connection_key = invite_msg['recipientKeys'][0]
elif entity['feature'] == InvitationSerializer.FEATURE_0160_ARIES_RFC:
try:
invite_string, invite_msg = run_async(
ConnectionProtocol.generate_invite_link(
label=invitation_label,
endpoint=self.get_endpoint().url,
agent_name=wallet.uid,
pass_phrase=pass_phrase,
seed=entity.get('seed', None)),
timeout=10)
connection_key = invite_msg['recipientKeys'][0]
except WalletOperationError as e:
if 'already exists' in str(e).lower():
return Response(status=status.HTTP_409_CONFLICT)
else:
raise
else:
raise exceptions.ValidationError('Unexpected feature: %s' %
entity['feature'])
instance = Invitation.objects.create(endpoint=self.get_endpoint(),
invitation_string=invite_string,
feature=entity['feature'],
connection_key=connection_key,
seed=entity.get('seed', None),
my_did=entity.get('my_did', None))
entity['url'] = instance.invitation_url
entity['connection_key'] = connection_key
entity['label'] = invitation_label
serializer = CreateInvitationSerializer(instance=entity)
return Response(data=serializer.data, status=status.HTTP_201_CREATED)
def test_vcx_issue_credential(self):
# 1 Prepare Faber issuer
faber_vcx_config = ProvisionConfig(
agency_url='http://localhost:8080',
agency_did='VsKV7grR1BUE29mG2Fm2kX',
agency_verkey='Hezce2UWMZ3wUhVkh2LfKSs8nDzWwzs2Win7EzNN3YaR',
wallet_name='faber_wallet',
enterprise_seed='000000000000000000000000Trustee1')
invite_msg, vcx_connection, schema_id, cred_def_handle = run_async(
faber_setup_issuer(faber_vcx_config, 'Faber'), timeout=60)
b64_invite = base64.urlsafe_b64encode(
json.dumps(invite_msg).encode('ascii')).decode('ascii')
invitation_url = 'http://localhost:8080?c_i=' + b64_invite
# 2 Prepare Schemas and CredDef(s)
# Prepare Invitee
endpoint_inviter = AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).endpoints.first()
endpoint_inviter.url = self.live_server_url + reverse(
'endpoint',
kwargs=dict(uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).endpoints.first().uid))
endpoint_inviter.save()
invitee = dict(
identity=self.IDENTITY_AGENT1,
password=self.IDENTITY_PASS,
wallet_uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).wallets.first().uid,
endpoint_uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).endpoints.first().uid,
endpoint_url=endpoint_inviter.url)
cred = dict(pass_phrase=self.WALLET_PASS_PHRASE)
# 3 Run faber listener
thread = ThreadScheduler()
thread.start()
try:
asyncio.run_coroutine_threadsafe(
faber_establish_connection(vcx_connection), loop=thread.loop)
# 4 FIRE!!!
url = self.live_server_url + '/agent/admin/wallets/%s/endpoints/%s/invite/' % (
invitee['wallet_uid'], invitee['endpoint_uid'])
invite = dict(**cred)
invite['url'] = invitation_url
resp = requests.post(url,
json=invite,
auth=HTTPBasicAuth(invitee['identity'],
invitee['password']))
self.assertEqual(200, resp.status_code)
thread = ThreadScheduler()
thread.start()
try:
asyncio.run_coroutine_threadsafe(faber_issue_credential(
vcx_connection, cred_def_handle),
loop=thread.loop)
sleep(1000)
finally:
thread.stop()
finally:
thread.stop()
def endpoint(request, uid):
instance = Endpoint.objects.filter(uid=uid).first()
response_timeout = settings.INDY['WALLET_SETTINGS']['TIMEOUTS'][
'AGENT_REQUEST']
if instance:
print('============= Endpoint triggered ==================')
print('Content-Type: ' + request.content_type)
print('endpoint uid: ' + instance.uid)
print('endpoint url: ' + instance.url)
if request.content_type not in WIRED_CONTENT_TYPES + JSON_CONTENT_TYPES:
return Response(status=status.HTTP_406_NOT_ACCEPTABLE)
processed = False
if request.content_type in WIRED_CONTENT_TYPES:
try:
for feature in [
IssueCredentialProtocol, PresentProofProtocol,
ConnectionProtocol, DIDExchangeFeature
]:
success = run_async(feature.handle(
agent_name=instance.wallet.uid,
wire_message=request.body,
my_label=instance.owner.username,
my_endpoint=instance.url),
timeout=response_timeout)
processed = processed or success
if success:
print('Catched by protocol: ' +
feature.__class__.__name__)
except AgentTimeOutError:
return Response(status=status.HTTP_410_GONE)
if processed:
return Response(status=status.HTTP_202_ACCEPTED)
if not processed:
count = run_async(
write_to_channel(name=make_wallet_wired_messages_channel_name(
instance.wallet.uid),
data=dict(content_type=request.content_type,
transport=json.loads(
request.body.decode('utf-8')))))
if count > 0:
return Response(status=status.HTTP_202_ACCEPTED)
else:
return Response(status=status.HTTP_410_GONE)
print('====================================================')
else:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
def invite(self, request, *args, **kwargs):
wallet = self.get_wallet()
endpoint = self.get_object()
serializer = InviteSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
entity = serializer.create(serializer.validated_data)
pass_phrase = extract_pass_phrase(request)
if entity.get('url', None):
try:
for feature in [ConnectionProtocol, DIDExchangeFeature]:
log_channel_name = run_async(
feature.receive_invite_link(entity['url'],
wallet.uid,
pass_phrase,
request.user.username,
endpoint.url,
entity['ttl'] + 3,
my_did=entity.get(
'my_did', None)))
if log_channel_name:
try:
invite_log = run_async(read_from_channel(
log_channel_name, entity['ttl']),
timeout=entity['ttl'])
except TimeoutError:
return Response(
data='Invite procedure was terminated by timeout'
.encode('utf-8'),
status=status.HTTP_408_REQUEST_TIMEOUT)
else:
return Response(data=invite_log,
status=status.HTTP_200_OK)
raise exceptions.ValidationError('Unknown invitation format')
except DIDExchangeBadInviteException as e:
raise exceptions.ValidationError(e.message)
except BadInviteException as e:
raise exceptions.ValidationError(e.message)
elif entity.get('invite_msg', None):
raise NotImplemented()
else:
raise exceptions.ValidationError(
'You must specify any of fields: "invite_msg" or "invite_link"'
)
def test_open_close__via_http_header(self):
conn = WalletConnection(self.WALLET_UID, self.WALLET_PASS_PHRASE)
Wallet.objects.create(uid=self.WALLET_UID, owner=self.account)
# first: create wallet
run_async(conn.create())
headers = dict()
headers[HEADER_PASS_PHRASE] = self.WALLET_PASS_PHRASE
try:
# open
url = self.live_server_url + reverse(
'admin-wallets-open', kwargs=dict(uid=self.WALLET_UID))
resp = requests.post(url,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS),
headers=headers)
self.assertEqual(200, resp.status_code)
# is_open
url = self.live_server_url + reverse(
'admin-wallets-is-open', kwargs=dict(uid=self.WALLET_UID))
resp = requests.get(url,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(200, resp.status_code)
stat = resp.json()
self.assertTrue(stat['is_open'])
# close
url = self.live_server_url + reverse(
'admin-wallets-close', kwargs=dict(uid=self.WALLET_UID))
resp = requests.post(url,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS),
headers=headers)
self.assertEqual(200, resp.status_code)
# is_open
url = self.live_server_url + reverse(
'admin-wallets-is-open', kwargs=dict(uid=self.WALLET_UID))
resp = requests.get(url,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(200, resp.status_code)
stat = resp.json()
self.assertFalse(stat['is_open'])
finally:
os.popen("pkill -f run_wallet_agent")
sleep(1)
run_async(conn.delete())
def test_create_invitation(self):
conn = WalletConnection(self.WALLET_UID, self.WALLET_PASS_PHRASE)
wallet = Wallet.objects.create(uid=self.WALLET_UID, owner=self.account)
endpoint = Endpoint.objects.create(uid='endpoint_uid',
owner=self.account,
wallet=wallet,
url='http://example.com/endpoint')
# first: create wallet
run_async(conn.create())
try:
cred = dict(pass_phrase=self.WALLET_PASS_PHRASE)
url = self.live_server_url + '/agent/admin/wallets/%s/endpoints/%s/invitations/' % (
self.WALLET_UID, endpoint.uid)
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(201, resp.status_code)
instance = Invitation.objects.get(endpoint=endpoint)
entity = resp.json()
self.assertTrue(entity['url'])
invite_url = entity['url']
self.assertTrue(resp.json()['connection_key'])
connection_key = resp.json()['connection_key']
self.assertIn(instance.invitation_string, invite_url)
self.assertIn(settings.INDY['INVITATION_URL_BASE'], invite_url)
self.assertEqual(1, invite_url.count('c_i='))
# check list
resp = requests.get(url,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(200, resp.status_code)
raw = str(resp.json())
self.assertIn(invite_url, raw)
self.assertIn(connection_key, raw)
finally:
os.popen("pkill -f run_wallet_agent")
sleep(1)
run_async(conn.delete())
def test_vcx_invitee(self):
cred = dict(pass_phrase=self.WALLET_PASS_PHRASE)
endpoint_inviter = AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).endpoints.first()
endpoint_inviter.url = self.live_server_url + reverse(
'endpoint',
kwargs=dict(uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).endpoints.first().uid))
endpoint_inviter.save()
inviter = dict(
identity=self.IDENTITY_AGENT1,
password=self.IDENTITY_PASS,
wallet_uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).wallets.first().uid,
endpoint_uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).endpoints.first().uid,
endpoint_url=endpoint_inviter.url)
# generate invitation link
url = self.live_server_url + '/agent/admin/wallets/%s/endpoints/%s/invitations/' % \
(inviter['wallet_uid'], inviter['endpoint_uid'])
invitation_kwargs = dict(**cred)
invitation_kwargs['feature'] = 'feature_0160'
resp = requests.post(url,
json=invitation_kwargs,
auth=HTTPBasicAuth(inviter['identity'],
inviter['password']))
self.assertEqual(201, resp.status_code, resp.text)
# Parse invitation message body
link = resp.json()['url']
matches = re.match("(.+)?c_i=(.+)", link)
buffer = base64.urlsafe_b64decode(matches.group(2)).decode('utf-8')
msg = json.loads(buffer)
alice_vcx_config = ProvisionConfig(
agency_url='http://localhost:8080',
agency_did='VsKV7grR1BUE29mG2Fm2kX',
agency_verkey='Hezce2UWMZ3wUhVkh2LfKSs8nDzWwzs2Win7EzNN3YaR',
wallet_name='alice_wallet',
enterprise_seed='000000000000000000000000Trustee1')
alice_vcx_invitation = Invitation(
label=msg['label'],
recipient_keys=msg['recipientKeys'],
service_endpoint=msg['serviceEndpoint'],
routing_keys=[])
connection_ok = run_async(alice_establish_connection(
alice=alice_vcx_config, invitation=alice_vcx_invitation),
timeout=60)
self.assertTrue(connection_ok)
def tearDown(self):
os.popen("pkill -f run_wallet_agent")
sleep(1)
run_async(self.delete_wallet())
sleep(1)
def test_receive_wired_message(self):
headers = dict()
headers[HEADER_PASS_PHRASE] = self.WALLET_PASS_PHRASE
account_sender = self.IDENTITY1
account_receiver = self.IDENTITY2
wallet_sender = self.WALLET1_UID
wallet_receiver = self.WALLET2_UID
endpoint_sender = self.create_and_open_wallet(wallet_sender,
account_sender)
endpoint_receiver = self.create_and_open_wallet(
wallet_receiver, account_receiver)
try:
did_sender, verkey_sender = self.create_did(
account_sender, wallet_sender)
did_receiver, verkey_receiver = self.create_did(
account_receiver, wallet_receiver)
# create pairwise on receiver-side
url = self.live_server_url + '/agent/admin/wallets/%s/pairwise/create_pairwise_statically/' % wallet_receiver
pairwise = dict(my_did=did_receiver,
their_did=did_sender,
their_verkey=verkey_sender,
metadata={
'their_endpoint': endpoint_sender,
'their_vk': verkey_sender,
'my_vk': verkey_receiver,
})
resp = requests.post(url,
json=pairwise,
auth=HTTPBasicAuth(account_receiver,
self.PASS),
headers=headers)
self.assertEqual(200, resp.status_code, resp.text)
# create auth-crypt message
url = self.live_server_url + '/agent/admin/wallets/%s/messaging/auth_crypt/' % wallet_sender
message = dict(content=uuid.uuid4().hex)
entity = dict(message=message,
their_verkey=verkey_receiver,
my_verkey=verkey_sender)
resp = requests.post(url,
json=entity,
auth=HTTPBasicAuth(account_sender, self.PASS))
self.assertEqual(200, resp.status_code)
encrypted_message = resp.json()
extra_field_value = uuid.uuid4().hex
encrypted_message['extra_field'] = extra_field_value
# send to receiver endpoint
transport = EndpointTransport(address=endpoint_receiver)
status = run_async(
transport.send_wire_message(
json.dumps(encrypted_message).encode('utf-8')))
self.assertEqual(410, status)
# allocate channel
ws = StubWalletStatusNotification(
scope={},
agent_name=wallet_receiver,
pass_phrase=self.WALLET_PASS_PHRASE)
async def run_websocket():
chan_wired = await ReadOnlyChannel.create(
make_wallet_wired_messages_channel_name(wallet_receiver))
await ws.listen_wired(chan_wired)
async def run_send_wire_message(msg):
await asyncio.sleep(3)
t = EndpointTransport(address=endpoint_receiver)
s = await t.send_wire_message(json.dumps(msg).encode('utf-8'))
assert 202 == s
async def run_tests():
done, pending = await asyncio.wait([
run_websocket(),
run_send_wire_message(encrypted_message)
],
timeout=5)
for f in pending:
f.cancel()
for f in done:
if f.exception():
raise f.exception()
await asyncio.sleep(1)
assert ws.is_closed
assert len(ws.send_queue) == 1
# check structure
recv = ws.send_queue[0]
assert recv.get('topic') == UNPACKED_TRANSPORT
data = recv.get('data')
assert data['content_type'] == DEFAULT_WIRE_CONTENT_TYPE
assert data['unpacked']['message']['content'] == message[
'content']
assert data['unpacked']['recipient_verkey'] == verkey_receiver
assert data['unpacked']['sender_verkey'] == verkey_sender
assert data['their_did'] == did_sender
assert data['extra']['extra_field'] == extra_field_value
f = asyncio.ensure_future(run_tests())
asyncio.get_event_loop().run_until_complete(f)
if f.exception():
raise f.exception()
finally:
self.close_and_delete_wallet(wallet_sender, account_sender)
self.close_and_delete_wallet(wallet_receiver, account_receiver)
def test_demo_issuer__feature_0037(self):
"""Тест на проблмы верификации credentials Android агента по feature 0037"""
# Setup issuer
endpoint_issuer = AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).endpoints.first()
endpoint_issuer.url = self.live_server_url + reverse(
'endpoint',
kwargs=dict(uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).endpoints.first().uid))
endpoint_issuer.save()
issuer = dict(account=self.IDENTITY_AGENT1,
wallet=AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).wallets.first().uid,
password=self.IDENTITY_PASS,
endpoint_uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).endpoints.first().uid,
endpoint_url=endpoint_issuer.url)
# Setup holder
endpoint_holder = AgentAccount.objects.get(
username=self.IDENTITY_AGENT2).endpoints.first()
endpoint_holder.url = self.live_server_url + reverse(
'endpoint',
kwargs=dict(uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT2).endpoints.first().uid))
endpoint_holder.save()
holder = dict(account=self.IDENTITY_AGENT2,
wallet=AgentAccount.objects.get(
username=self.IDENTITY_AGENT2).wallets.first().uid,
password=self.IDENTITY_PASS,
endpoint_uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT2).endpoints.first().uid,
endpoint_url=endpoint_holder.url)
# Setup DID, VerKeys and schemas
issuer_seed = '000000000000000000000000Steward1'
holder_seed = '00000000000000000000000000Holder'
did_issuer, verkey_issuer = self.create_did(issuer['wallet'],
issuer_seed)
did_holder, verkey_holder = self.create_did(holder['wallet'],
holder_seed)
# Exchange pairwise dids
run_async(
self.register_pairwise(wallet_uid=issuer['wallet'],
their_did=did_holder,
their_vk=verkey_holder,
my_did=did_issuer,
my_vk=verkey_issuer,
their_endpoint=holder['endpoint_url'],
label='Holder'))
run_async(
self.register_pairwise(wallet_uid=holder['wallet'],
their_did=did_issuer,
their_vk=verkey_issuer,
my_did=did_holder,
my_vk=verkey_holder,
their_endpoint=issuer['endpoint_url'],
label='Issuer'))
# Load schema and cred-defs meta
path = '/agent/admin/wallets/demo_issuer/did/%s/ledger/schemas/' % did_issuer
resp = get_indy_agent(path)
assert resp.status_code == 200
print('=========== SCHEMAS ============')
print(json.dumps(resp.json(), indent=2, sort_keys=True))
print('================================')
registered_schema = list(
filter(
lambda s: s['name'] == 'Transcript' and s['version'] == '1.2',
resp.json()))[0]
resp = get_indy_agent(
'/agent/admin/wallets/demo_issuer/did/%s/cred_def/all/' %
did_issuer)
assert resp.status_code == 200
print('=========== CRED-DEFs ============')
print(json.dumps(resp.json(), indent=2, sort_keys=True))
print('================================')
registered_creddef = list(
filter(lambda cd: cd['schema']['id'] == registered_schema['id'],
resp.json()))[0]
credential = dict(birthday='Value for birthday',
ssn='Value for ssn',
first_name='Value for first_name',
last_name='Value for last_name')
params = dict(cred_def_id=registered_creddef['id'],
cred_def=registered_creddef['cred_def'],
issuer_schema=registered_schema,
their_did=did_holder,
values=credential,
pass_phrase='pass')
cred_req_meta = run_async(
WalletAgent.issuer_create_credential_def(
agent_name=issuer['wallet'],
pass_phrase=self.WALLET_PASS_PHRASE,
self_did=did_issuer,
schema_id=registered_schema['id'],
tag='DEMO',
support_revocation=False))
url = self.live_server_url + '/agent/admin/wallets/%s/messaging/issue_credential/' % issuer[
'wallet']
resp = requests.post(url,
json=params,
auth=HTTPBasicAuth(issuer['account'],
issuer['password']))
self.assertEqual(resp.status_code, 200, resp.text)
log = resp.json()
self.assertTrue(log)
print('------- LOG -----------')
print(json.dumps(log, indent=2))
print('------------------------')
def test_issue_feature_0036_0037_verify_error(self):
# Setup issuer
endpoint_issuer = AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).endpoints.first()
endpoint_issuer.url = self.live_server_url + reverse(
'endpoint',
kwargs=dict(uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).endpoints.first().uid))
endpoint_issuer.save()
issuer = dict(account=self.IDENTITY_AGENT1,
wallet=AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).wallets.first().uid,
password=self.IDENTITY_PASS,
endpoint_uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT1).endpoints.first().uid,
endpoint_url=endpoint_issuer.url)
# Setup holder
endpoint_holder = AgentAccount.objects.get(
username=self.IDENTITY_AGENT2).endpoints.first()
endpoint_holder.url = self.live_server_url + reverse(
'endpoint',
kwargs=dict(uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT2).endpoints.first().uid))
endpoint_holder.save()
holder = dict(account=self.IDENTITY_AGENT2,
wallet=AgentAccount.objects.get(
username=self.IDENTITY_AGENT2).wallets.first().uid,
password=self.IDENTITY_PASS,
endpoint_uid=AgentAccount.objects.get(
username=self.IDENTITY_AGENT2).endpoints.first().uid,
endpoint_url=endpoint_holder.url)
# Setup DID, VerKeys and schemas
trustee_seed = '000000000000000000000000Trustee1'
did_issuer, verkey_issuer = self.create_did(issuer['wallet'],
trustee_seed)
did_holder, verkey_holder = self.create_did(holder['wallet'])
# Exchange pairwise dids
run_async(
self.register_pairwise(wallet_uid=issuer['wallet'],
their_did=did_holder,
their_vk=verkey_holder,
my_did=did_issuer,
my_vk=verkey_issuer,
their_endpoint=holder['endpoint_url'],
label='Holder'))
run_async(
self.register_pairwise(wallet_uid=holder['wallet'],
their_did=did_issuer,
their_vk=verkey_issuer,
my_did=did_holder,
my_vk=verkey_holder,
their_endpoint=issuer['endpoint_url'],
label='Issuer'))
# Register schemas and cred defs
schema = {
'name': 'test_schema_' + uuid.uuid4().hex,
'version': '1.0',
'attributes': ["age", "sex", "height", "name"]
}
cred_def_id, cred_def_json, cred_def_request, schema = run_async(
self.register_schema(issuer['wallet'], schema, did_issuer),
timeout=30)
# Issuer: start
credential = dict(sex='male', name='Alex', height=175, age=28)
data = dict(cred_def=cred_def_json,
cred_def_id=cred_def_id,
issuer_schema=schema,
values=credential,
comment='My Comment',
locale='ru',
preview={'age': '28'},
translation={'age': 'Возраст'},
their_did=did_holder,
pass_phrase=self.WALLET_PASS_PHRASE)
url = self.live_server_url + '/agent/admin/wallets/%s/messaging/issue_credential/' % issuer[
'wallet']
resp = requests.post(url,
json=data,
auth=HTTPBasicAuth(issuer['account'],
issuer['password']))
self.assertEqual(resp.status_code, 200, resp.text)
log = resp.json()
self.assertTrue(log)
print('------- LOG -----------')
print(json.dumps(log, indent=2))
print('------------------------')
# Stop issuer state machine
url = self.live_server_url + '/agent/admin/wallets/%s/messaging/stop_issue_credential/' % issuer[
'wallet']
data = dict(their_did=did_holder, pass_phrase=self.WALLET_PASS_PHRASE)
resp = requests.post(url,
json=data,
auth=HTTPBasicAuth(issuer['account'],
issuer['password']))
self.assertTrue(400 >= resp.status_code < 500, resp.text)
# Verify Proof Error
print('------ Verify Proof Error ------')
proof_request = {
'nonce': '123432421212',
'name': 'proof_req_2',
'version': '0.1',
'requested_attributes': {
'attr1_referent': {
'name': 'name',
"restrictions": {
"issuer_did": did_issuer,
"schema_id": schema['id']
}
},
'attr2_referent': {
'name': 'name-invalid'
}
}
}
data = dict(their_did=did_holder,
pass_phrase=self.WALLET_PASS_PHRASE,
proof_request=proof_request)
url = self.live_server_url + '/agent/admin/wallets/%s/messaging/verify_proof/' % issuer[
'wallet']
print('>')
resp = requests.post(url,
json=data,
auth=HTTPBasicAuth(issuer['account'],
issuer['password']))
print('<')
self.assertEqual(resp.status_code, 200, resp.text)
stat = resp.json()
self.assertFalse(stat.get('success'))
def test_invitation_ensure_exists(self):
conn = WalletConnection(self.WALLET_UID, self.WALLET_PASS_PHRASE)
wallet = Wallet.objects.create(uid=self.WALLET_UID, owner=self.account)
endpoint = Endpoint.objects.create(uid='endpoint_uid',
owner=self.account,
wallet=wallet,
url='http://example.com/endpoint')
# first: create wallet
run_async(conn.create())
run_async(conn.open())
my_did, my_verkey = run_async(conn.create_and_store_my_did())
run_async(conn.close())
try:
seed = 'blablabla-seed-'
expected_key = '3XvPjB4EDpmBBF4sRmqVbrQXQY5vk7zjiggSCGxSkPpV'
cred = dict(pass_phrase=self.WALLET_PASS_PHRASE, seed=seed)
url = self.live_server_url + '/agent/admin/wallets/%s/endpoints/%s/invitations/ensure_exists/' % (
self.WALLET_UID, endpoint.uid)
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(200, resp.status_code)
i1 = resp.json()
instance = Invitation.objects.get(endpoint=endpoint)
self.assertEqual(seed, instance.seed)
self.assertEqual(expected_key, instance.connection_key)
self.assertIsNone(instance.my_did)
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(200, resp.status_code)
i2 = resp.json()
self.assertEqual(
1,
Invitation.objects.filter(connection_key=expected_key).count())
matches = re.match("(.+)?c_i=(.+)", i1['url'])
invite_msg1 = Serializer.deserialize(
base64.urlsafe_b64decode(
matches.group(2)).decode('utf-8')).to_dict()
del invite_msg1['@id']
matches = re.match("(.+)?c_i=(.+)", i2['url'])
invite_msg2 = Serializer.deserialize(
base64.urlsafe_b64decode(
matches.group(2)).decode('utf-8')).to_dict()
del invite_msg2['@id']
self.assertDictEqual(invite_msg1, invite_msg2)
cred['my_did'] = my_did
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(200, resp.status_code)
instance = Invitation.objects.get(endpoint=endpoint)
self.assertEqual(my_did, instance.my_did)
self.assertEqual(1, Invitation.objects.count())
cred = dict(pass_phrase=self.WALLET_PASS_PHRASE,
seed=seed + 'salt')
resp = requests.post(url,
json=cred,
auth=HTTPBasicAuth(self.IDENTITY, self.PASS))
self.assertEqual(200, resp.status_code)
self.assertEqual(2, Invitation.objects.count())
finally:
os.popen("pkill -f run_wallet_agent")
sleep(1)
run_async(conn.delete())
