async def test_service_start_introduction_target_conn_rec_not_active(self): service = await demo_service.DemoIntroductionService.service_handler()( self.context) conn_rec_init = ConnectionRecord( connection_id=None, state=ConnectionRecord.STATE_ACTIVE, ) await conn_rec_init.save(self.context) assert conn_rec_init._id conn_rec_target = ConnectionRecord( connection_id=None, state=ConnectionRecord.STATE_INACTIVE, ) await conn_rec_target.save(self.context) assert conn_rec_target._id with self.assertRaises(base_service.IntroductionError): await service.start_introduction( init_connection_id=conn_rec_init._id, target_connection_id=conn_rec_target._id, message="Hello", outbound_handler=None, )
async def test_service_start_and_return_introduction(self): service = await demo_service.DemoIntroductionService.service_handler()( self.context ) start_responder = MockResponder() conn_rec_init = ConnectionRecord( connection_id=None, state=ConnectionRecord.STATE_ACTIVE, ) await conn_rec_init.save(self.context) assert conn_rec_init._id conn_rec_target = ConnectionRecord( connection_id=None, state=ConnectionRecord.STATE_ACTIVE, ) await conn_rec_target.save(self.context) assert conn_rec_target._id await service.start_introduction( init_connection_id=conn_rec_init._id, target_connection_id=conn_rec_target._id, message="Hello Start", outbound_handler=start_responder.send, ) messages = start_responder.messages assert len(messages) == 1 (result, target) = messages[0] assert isinstance(result, demo_service.InvitationRequest) assert result.message == "Hello Start" assert target["connection_id"] == conn_rec_target._id invite = demo_service.Invitation( invitation=ConnectionInvitation( label=TEST_LABEL, did=TEST_DID, recipient_keys=[TEST_VERKEY], endpoint=TEST_ENDPOINT, routing_keys=[TEST_ROUTE_VERKEY], image_url=TEST_IMAGE_URL, ), message="Hello Invite", _id=result._id, ) return_responder = MockResponder() await service.return_invitation( target_connection_id=conn_rec_target._id, invitation=invite, outbound_handler=return_responder.send, ) messages = return_responder.messages assert len(messages) == 1 (result, target) = messages[0] assert isinstance(result, demo_service.ForwardInvitation) assert result.message == "Hello Invite" assert target["connection_id"] == conn_rec_init._id
async def create_request( self, connection: ConnectionRecord, my_label: str = None, my_endpoint: str = None, ) -> ConnectionRequest: """ Create a new connection request for a previously-received invitation. Args: connection: The `ConnectionRecord` representing the invitation to accept my_label: My label my_endpoint: My endpoint Returns: A new `ConnectionRequest` message to send to the other agent """ wallet: BaseWallet = await self.context.inject(BaseWallet) if connection.my_did: my_info = await wallet.get_local_did(connection.my_did) else: # Create new DID for connection my_info = await wallet.create_local_did() connection.my_did = my_info.did # Create connection request message if not my_endpoint: my_endpoints = [] default_endpoint = self.context.settings.get("default_endpoint") if default_endpoint: my_endpoints.append(default_endpoint) my_endpoints.extend( self.context.settings.get("additional_endpoints", [])) else: my_endpoints = [my_endpoint] did_doc = await self.create_did_document( my_info, connection.inbound_connection_id, my_endpoints) if not my_label: my_label = self.context.settings.get("default_label") request = ConnectionRequest( label=my_label, connection=ConnectionDetail(did=connection.my_did, did_doc=did_doc), ) # Update connection state connection.request_id = request._id connection.state = ConnectionRecord.STATE_REQUEST await connection.save(self.context, reason="Created connection request") return request
async def test_service_return_invitation_not_found(self): invite = demo_service.Invitation( invitation=ConnectionInvitation( label=TEST_LABEL, did=TEST_DID, recipient_keys=[TEST_VERKEY], endpoint=TEST_ENDPOINT, routing_keys=[TEST_ROUTE_VERKEY], image_url=TEST_IMAGE_URL, ), message="Hello World", ) service = await demo_service.DemoIntroductionService.service_handler()( self.context) conn_rec_target = ConnectionRecord( connection_id=None, state=ConnectionRecord.STATE_ACTIVE, ) await conn_rec_target.save(self.context) assert conn_rec_target._id await service.return_invitation( target_connection_id=conn_rec_target._id, invitation=invite, outbound_handler=None, )
async def test_request_credential(self): mock = async_mock.MagicMock() record = ConnectionRecord(state=ConnectionRecord.STATE_ACTIVE) context = RequestContext(base_context=InjectionContext( enforce_typing=False)) storage = BasicStorage() context.injector.bind_instance(BaseStorage, storage) connection_id = await record.save(context) mock.json = async_mock.CoroutineMock( return_value={ "connection_id": connection_id, "credential_type": "TYPE_EXAMPLE", "credential_values": { "test1": "1" }, }) mock.app = { "request_context": context, "outbound_message_router": async_mock.CoroutineMock(), } with async_mock.patch.object( test_module, "CredentialExchangeRecord", autospec=True) as mock_conn_rec, async_mock.patch.object( test_module.web, "json_response") as mock_response: await test_module.request_credential(mock) mock_response.assert_called_once()
def setUp(self): self.storage = BasicStorage() self.cache = BasicCache() self.wallet = BasicWallet() self.responder = MockResponder() self.responder.send = async_mock.CoroutineMock() self.context = InjectionContext(enforce_typing=False) self.context.injector.bind_instance(BaseStorage, self.storage) self.context.injector.bind_instance(BaseWallet, self.wallet) self.context.injector.bind_instance(BaseResponder, self.responder) self.context.injector.bind_instance(BaseCache, self.cache) self.context.injector.bind_instance(BaseLedger, async_mock.MagicMock()) self.context.update_settings({ "default_endpoint": "http://aries.ca/endpoint", "default_label": "This guy", "additional_endpoints": ["http://aries.ca/another-endpoint"], "debug.auto_accept_invites": True, "debug.auto_accept_requests": True, }) self.manager = OutOfBandManager(self.context) self.test_conn_rec = ConnectionRecord( my_did=self.test_did, their_did=self.test_target_did, their_role=None, state=ConnectionRecord.STATE_ACTIVE, )
def context(): """Fixture for context used in tests.""" # pylint: disable=W0621 context = RequestContext() context.message = ProvideData(goal_code="test_goal", data=[TEST_DATA]) context.connection_record = ConnectionRecord(connection_id=TEST_CONN_ID) context.connection_ready = True yield context
async def setUp(self): self.context = RequestContext( base_context=InjectionContext(enforce_typing=False) ) self.context.connection_ready = True self.context.connection_record = ConnectionRecord(connection_id="conn-id") self.context.message_receipt = MessageReceipt(sender_verkey=TEST_VERKEY) self.context.injector.bind_instance(BaseStorage, BasicStorage())
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle static connection creation request.""" connection_mgr = ConnectionManager(context) wallet: BaseWallet = await context.inject(BaseWallet) # Make our info for the connection my_info = await wallet.create_local_did() # Create connection record connection = ConnectionRecord( initiator=ConnectionRecord.INITIATOR_SELF, my_did=my_info.did, their_did=context.message.static_did, their_label=context.message.label, their_role=context.message.role if context.message.role else None, state=ConnectionRecord.STATE_ACTIVE, invitation_mode=ConnectionRecord.INVITATION_MODE_STATIC ) # Construct their did doc from the basic components in message diddoc = DIDDoc(context.message.static_did) public_key = PublicKey( did=context.message.static_did, ident="1", value=context.message.static_key, pk_type=PublicKeyType.ED25519_SIG_2018, controller=context.message.static_did ) service = Service( did=context.message.static_did, ident="indy", typ="IndyAgent", recip_keys=[public_key], routing_keys=[], endpoint=context.message.static_endpoint ) diddoc.set(public_key) diddoc.set(service) # Save await connection_mgr.store_did_document(diddoc) await connection.save( context, reason='Created new static connection' ) # Prepare response info = StaticConnectionInfo( did=my_info.did, key=my_info.verkey, endpoint=context.settings.get("default_endpoint") ) info.assign_thread_from(context.message) await responder.send_reply(info) return
async def test_handle(self): handler = test_module.ForwardInvitationHandler() responder = MockResponder() with async_mock.patch.object(test_module, "ConnectionManager", autospec=True) as mock_mgr: mock_mgr.return_value.receive_invitation = async_mock.CoroutineMock( return_value=ConnectionRecord(connection_id="dummy")) await handler.handle(self.context, responder) assert not (responder.messages)
async def establish_inbound(self, connection: ConnectionRecord, inbound_connection_id: str, outbound_handler) -> str: """Assign the inbound routing connection for a connection record. Returns: the current routing state (request or done) """ # The connection must have a verkey, but in the case of a received # invitation we might not have created one yet wallet: BaseWallet = await self.context.inject(BaseWallet) if connection.my_did: my_info = await wallet.get_local_did(connection.my_did) else: # Create new DID for connection my_info = await wallet.create_local_did() connection.my_did = my_info.did try: router = await ConnectionRecord.retrieve_by_id( self.context, inbound_connection_id) except StorageNotFoundError: raise ConnectionManagerError( f"Routing connection not found: {inbound_connection_id}") if not router.is_ready: raise ConnectionManagerError( f"Routing connection is not ready: {inbound_connection_id}") connection.inbound_connection_id = inbound_connection_id route_mgr = RoutingManager(self.context) await route_mgr.send_create_route(inbound_connection_id, my_info.verkey, outbound_handler) connection.routing_state = ConnectionRecord.ROUTING_STATE_REQUEST await connection.save(self.context) return connection.routing_state
async def test_create_credential_null(self): connection = ConnectionRecord(my_did="1234-my", their_did="1234-their") with self.assertRaises(IssuerError): credential, _ = await self.issuer.create_credential( schema={"credential_type": "TestType"}, credential_values={}, credential_offer={}, credential_request={"connection_record": connection}, ) with self.assertRaises(IssuerError): credential, _ = await self.issuer.create_credential( schema={}, credential_values={}, credential_offer={}, credential_request={"connection_record": connection}, )
def conn_record_to_message_repr(conn: ConnectionRecord) -> Dict[str, Any]: """Map ConnectionRecord onto Connection.""" def _state_map(state: str) -> str: if state in ('active', 'response'): return 'active' if state == 'error': return 'error' return 'pending' return { 'label': conn.their_label, 'my_did': conn.my_did, 'their_did': conn.their_did, 'state': _state_map(conn.state), 'role': conn.their_role, 'connection_id': conn.connection_id, 'raw_repr': conn.serialize() }
async def create_invitation( self, my_label: str = None, my_endpoint: str = None, their_role: str = None, auto_accept: bool = None, public: bool = False, multi_use: bool = False, alias: str = None, ) -> Tuple[ConnectionRecord, ConnectionInvitation]: """ Generate new connection invitation. This interaction represents an out-of-band communication channel. In the future and in practice, these sort of invitations will be received over any number of channels such as SMS, Email, QR Code, NFC, etc. Structure of an invite message: :: { "@type": "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/connections/1.0/invitation", "label": "Alice", "did": "did:sov:QmWbsNYhMrjHiqZDTUTEJs" } Or, in the case of a peer DID: :: { "@type": "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/connections/1.0/invitation", "label": "Alice", "did": "did:peer:oiSqsNYhMrjHiqZDTUthsw", "recipientKeys": ["8HH5gYEeNc3z7PYXmd54d4x6qAfCNrqQqEB3nS7Zfu7K"], "serviceEndpoint": "https://example.com/endpoint" } Currently, only peer DID is supported. Args: my_label: label for this connection my_endpoint: endpoint where other party can reach me their_role: a role to assign the connection auto_accept: auto-accept a corresponding connection request (None to use config) public: set to create an invitation from the public DID multi_use: set to True to create an invitation for multiple use alias: optional alias to apply to connection for later use Returns: A tuple of the new `ConnectionRecord` and `ConnectionInvitation` instances """ if not my_label: my_label = self.context.settings.get("default_label") wallet: BaseWallet = await self.context.inject(BaseWallet) if public: if not self.context.settings.get("public_invites"): raise ConnectionManagerError( "Public invitations are not enabled") public_did = await wallet.get_public_did() if not public_did: raise ConnectionManagerError( "Cannot create public invitation with no public DID") if multi_use: raise ConnectionManagerError( "Cannot use public and multi_use at the same time") # FIXME - allow ledger instance to format public DID with prefix? invitation = ConnectionInvitation(label=my_label, did=f"did:sov:{public_did.did}") return None, invitation invitation_mode = ConnectionRecord.INVITATION_MODE_ONCE if multi_use: invitation_mode = ConnectionRecord.INVITATION_MODE_MULTI if not my_endpoint: my_endpoint = self.context.settings.get("default_endpoint") accept = (ConnectionRecord.ACCEPT_AUTO if (auto_accept or (auto_accept is None and self.context.settings.get("debug.auto_accept_requests"))) else ConnectionRecord.ACCEPT_MANUAL) # Create and store new invitation key connection_key = await wallet.create_signing_key() # Create connection record connection = ConnectionRecord( initiator=ConnectionRecord.INITIATOR_SELF, invitation_key=connection_key.verkey, their_role=their_role, state=ConnectionRecord.STATE_INVITATION, accept=accept, invitation_mode=invitation_mode, alias=alias, ) await connection.save(self.context, reason="Created new invitation") # Create connection invitation message # Note: Need to split this into two stages to support inbound routing of invites # Would want to reuse create_did_document and convert the result invitation = ConnectionInvitation( label=my_label, recipient_keys=[connection_key.verkey], endpoint=my_endpoint) await connection.attach_invitation(self.context, invitation) return connection, invitation
async def create_static_connection( self, my_did: str = None, my_seed: str = None, their_did: str = None, their_seed: str = None, their_verkey: str = None, their_endpoint: str = None, their_role: str = None, their_label: str = None, alias: str = None, ) -> (DIDInfo, DIDInfo, ConnectionRecord): """ Register a new static connection (for use by the test suite). Args: my_did: override the DID used in the connection my_seed: provide a seed used to generate our DID and keys their_did: provide the DID used by the other party their_seed: provide a seed used to generate their DID and keys their_verkey: provide the verkey used by the other party their_endpoint: their URL endpoint for routing messages their_role: their role in this connection alias: an alias for this connection record Returns: The new `ConnectionRecord` instance """ wallet: BaseWallet = await self.context.inject(BaseWallet) # seed and DID optional my_info = await wallet.create_local_did(my_seed, my_did) # must provide their DID and verkey if the seed is not known if (not their_did or not their_verkey) and not their_seed: raise ConnectionManagerError( "Either a verkey or seed must be provided for the other party") if not their_did: their_did = seed_to_did(their_seed) if not their_verkey: their_verkey_bin, _ = create_keypair(their_seed.encode()) their_verkey = bytes_to_b58(their_verkey_bin) their_info = DIDInfo(their_did, their_verkey, {}) # Create connection record connection = ConnectionRecord( initiator=ConnectionRecord.INITIATOR_SELF, invitation_mode=ConnectionRecord.INVITATION_MODE_STATIC, my_did=my_info.did, their_did=their_info.did, their_role=their_role, their_label=their_label, state=ConnectionRecord.STATE_ACTIVE, alias=alias, ) await connection.save(self.context, reason="Created new static connection") # Synthesize their DID doc did_doc = await self.create_did_document(their_info, None, [their_endpoint]) await self.store_did_document(did_doc) return my_info, their_info, connection
async def create_response(self, connection: ConnectionRecord, my_endpoint: str = None) -> ConnectionResponse: """ Create a connection response for a received connection request. Args: connection: The `ConnectionRecord` with a pending connection request my_endpoint: The endpoint I can be reached at Returns: A tuple of the updated `ConnectionRecord` new `ConnectionResponse` message """ ConnectionRecord.log_state( self.context, "Creating connection response", {"connection_id": connection.connection_id}, ) if connection.state not in ( ConnectionRecord.STATE_REQUEST, ConnectionRecord.STATE_RESPONSE, ): raise ConnectionManagerError( "Connection is not in the request or response state") request = await connection.retrieve_request(self.context) wallet: BaseWallet = await self.context.inject(BaseWallet) if connection.my_did: my_info = await wallet.get_local_did(connection.my_did) else: my_info = await wallet.create_local_did() connection.my_did = my_info.did # Create connection response message if not my_endpoint: my_endpoints = [] default_endpoint = self.context.settings.get("default_endpoint") if default_endpoint: my_endpoints.append(default_endpoint) my_endpoints.extend( self.context.settings.get("additional_endpoints", [])) did_doc = await self.create_did_document( my_info, connection.inbound_connection_id, my_endpoints) response = ConnectionResponse( connection=ConnectionDetail(did=my_info.did, did_doc=did_doc)) # Assign thread information response.assign_thread_from(request) response.assign_trace_from(request) # Sign connection field using the invitation key wallet: BaseWallet = await self.context.inject(BaseWallet) await response.sign_field("connection", connection.invitation_key, wallet) # Update connection state connection.state = ConnectionRecord.STATE_RESPONSE await connection.save( self.context, reason="Created connection response", log_params={"response": response}, ) return response
async def receive_request(self, request: ConnectionRequest, receipt: MessageReceipt) -> ConnectionRecord: """ Receive and store a connection request. Args: request: The `ConnectionRequest` to accept receipt: The message receipt Returns: The new or updated `ConnectionRecord` instance """ ConnectionRecord.log_state(self.context, "Receiving connection request", {"request": request}) connection = None connection_key = None # Determine what key will need to sign the response if receipt.recipient_did_public: wallet: BaseWallet = await self.context.inject(BaseWallet) my_info = await wallet.get_local_did(receipt.recipient_did) connection_key = my_info.verkey else: connection_key = receipt.recipient_verkey try: connection = await ConnectionRecord.retrieve_by_invitation_key( self.context, connection_key, ConnectionRecord.INITIATOR_SELF) except StorageNotFoundError: raise ConnectionManagerError( "No invitation found for pairwise connection") invitation = None if connection: invitation = await connection.retrieve_invitation(self.context) connection_key = connection.invitation_key ConnectionRecord.log_state(self.context, "Found invitation", {"invitation": invitation}) if connection.is_multiuse_invitation: wallet: BaseWallet = await self.context.inject(BaseWallet) my_info = await wallet.create_local_did() new_connection = ConnectionRecord( initiator=ConnectionRecord.INITIATOR_MULTIUSE, invitation_key=connection_key, my_did=my_info.did, state=ConnectionRecord.STATE_INVITATION, accept=connection.accept, their_role=connection.their_role, ) await new_connection.save( self.context, reason= "Received connection request from multi-use invitation DID", ) connection = new_connection conn_did_doc = request.connection.did_doc if not conn_did_doc: raise ConnectionManagerError( "No DIDDoc provided; cannot connect to public DID") if request.connection.did != conn_did_doc.did: raise ConnectionManagerError( "Connection DID does not match DIDDoc id", error_code=ProblemReportReason.REQUEST_NOT_ACCEPTED, ) await self.store_did_document(conn_did_doc) if connection: connection.their_label = request.label connection.their_did = request.connection.did connection.state = ConnectionRecord.STATE_REQUEST await connection.save( self.context, reason="Received connection request from invitation") elif not self.context.settings.get("public_invites"): raise ConnectionManagerError("Public invitations are not enabled") else: my_info = await wallet.create_local_did() connection = ConnectionRecord( initiator=ConnectionRecord.INITIATOR_EXTERNAL, invitation_key=connection_key, my_did=my_info.did, their_did=request.connection.did, their_label=request.label, state=ConnectionRecord.STATE_REQUEST, ) if self.context.settings.get("debug.auto_accept_requests"): connection.accept = ConnectionRecord.ACCEPT_AUTO await connection.save( self.context, reason="Received connection request from public DID") # Attach the connection request so it can be found and responded to await connection.attach_request(self.context, request) if connection.accept == ConnectionRecord.ACCEPT_AUTO: response = await self.create_response(connection) responder: BaseResponder = await self._context.inject( BaseResponder, required=False) if responder: await responder.send_reply( response, connection_id=connection.connection_id) # refetch connection for accurate state connection = await ConnectionRecord.retrieve_by_id( self._context, connection.connection_id) else: self._logger.debug("Connection request will await acceptance") return connection
async def receive_invitation( self, invitation: ConnectionInvitation, their_role: str = None, auto_accept: bool = None, alias: str = None, ) -> ConnectionRecord: """ Create a new connection record to track a received invitation. Args: invitation: The `ConnectionInvitation` to store their_role: The role assigned to this connection auto_accept: set to auto-accept the invitation (None to use config) alias: optional alias to set on the record Returns: The new `ConnectionRecord` instance """ if not invitation.did: if not invitation.recipient_keys: raise ConnectionManagerError( "Invitation must contain recipient key(s)") if not invitation.endpoint: raise ConnectionManagerError( "Invitation must contain an endpoint") accept = (ConnectionRecord.ACCEPT_AUTO if (auto_accept or (auto_accept is None and self.context.settings.get("debug.auto_accept_invites"))) else ConnectionRecord.ACCEPT_MANUAL) # Create connection record connection = ConnectionRecord( initiator=ConnectionRecord.INITIATOR_EXTERNAL, invitation_key=invitation.recipient_keys and invitation.recipient_keys[0], their_label=invitation.label, their_role=their_role, state=ConnectionRecord.STATE_INVITATION, accept=accept, alias=alias, ) await connection.save( self.context, reason="Created new connection record from invitation", log_params={ "invitation": invitation, "role": their_role }, ) # Save the invitation for later processing await connection.attach_invitation(self.context, invitation) if connection.accept == ConnectionRecord.ACCEPT_AUTO: request = await self.create_request(connection) responder: BaseResponder = await self._context.inject( BaseResponder, required=False) if responder: await responder.send(request, connection_id=connection.connection_id) # refetch connection for accurate state connection = await ConnectionRecord.retrieve_by_id( self._context, connection.connection_id) else: self._logger.debug("Connection invitation will await acceptance") return connection