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())