Add present-proof protcol for patching

Signed-off-by: George J Padayatti <[email protected]>

Author: georgepadayatti

mydata_did/patched_protocols/present_proof/__init__.py

@@ -0,0 +1,10 @@
+"""Version definitions for this protocol."""
+
+versions = [
+    {
+        "major_version": 1,
+        "minimum_minor_version": 0,
+        "current_minor_version": 0,
+        "path": "v1_0",
+    }
+]

mydata_did/patched_protocols/present_proof/definition.py

@@ -0,0 +1,47 @@
+"""Presentation ack message handler."""
+
+from .....messaging.base_handler import (
+    BaseHandler,
+    BaseResponder,
+    HandlerException,
+    RequestContext,
+)
+
+from ..manager import PresentationManager
+from ..messages.presentation_ack import PresentationAck
+
+from .....utils.tracing import trace_event, get_timer
+
+
+class PresentationAckHandler(BaseHandler):
+    """Message handler class for presentation acks."""
+
+    async def handle(self, context: RequestContext, responder: BaseResponder):
+        """
+        Message handler logic for presentation acks.
+
+        Args:
+            context: request context
+            responder: responder callback
+        """
+        r_time = get_timer()
+
+        self._logger.debug("PresentationAckHandler called with context %s", context)
+        assert isinstance(context.message, PresentationAck)
+        self._logger.info(
+            "Received presentation ack message: %s",
+            context.message.serialize(as_string=True),
+        )
+
+        if not context.connection_ready:
+            raise HandlerException("No connection established for presentation ack")
+
+        presentation_manager = PresentationManager(context)
+        await presentation_manager.receive_presentation_ack()
+
+        trace_event(
+            context.settings,
+            context.message,
+            outcome="PresentationAckHandler.handle.END",
+            perf_counter=r_time,
+        )

mydata_did/patched_protocols/present_proof/v1_0/__init__.py

@@ -0,0 +1,55 @@
+"""Presentation message handler."""
+
+from .....messaging.base_handler import (
+    BaseHandler,
+    BaseResponder,
+    RequestContext,
+)
+
+from ..manager import PresentationManager
+from ..messages.presentation import Presentation
+
+from .....utils.tracing import trace_event, get_timer
+
+
+class PresentationHandler(BaseHandler):
+    """Message handler class for presentations."""
+
+    async def handle(self, context: RequestContext, responder: BaseResponder):
+        """
+        Message handler logic for presentations.
+
+        Args:
+            context: request context
+            responder: responder callback
+
+        """
+        r_time = get_timer()
+
+        self._logger.debug("PresentationHandler called with context %s", context)
+        assert isinstance(context.message, Presentation)
+        self._logger.info(
+            "Received presentation message: %s",
+            context.message.serialize(as_string=True),
+        )
+
+        presentation_manager = PresentationManager(context)
+
+        presentation_exchange_record = await presentation_manager.receive_presentation()
+
+        r_time = trace_event(
+            context.settings,
+            context.message,
+            outcome="PresentationHandler.handle.END",
+            perf_counter=r_time,
+        )
+
+        if context.settings.get("debug.auto_verify_presentation"):
+            await presentation_manager.verify_presentation(presentation_exchange_record)
+
+            trace_event(
+                context.settings,
+                presentation_exchange_record,
+                outcome="PresentationHandler.handle.VERIFY",
+                perf_counter=r_time,
+            )

mydata_did/patched_protocols/present_proof/v1_0/handlers/__init__.py

@@ -0,0 +1,71 @@
+"""Presentation proposal message handler."""
+
+from .....messaging.base_handler import (
+    BaseHandler,
+    BaseResponder,
+    HandlerException,
+    RequestContext,
+)
+
+from ..manager import PresentationManager
+from ..messages.presentation_proposal import PresentationProposal
+
+from .....utils.tracing import trace_event, get_timer
+
+
+class PresentationProposalHandler(BaseHandler):
+    """Message handler class for presentation proposals."""
+
+    async def handle(self, context: RequestContext, responder: BaseResponder):
+        """
+        Message handler logic for presentation proposals.
+
+        Args:
+            context: proposal context
+            responder: responder callback
+
+        """
+        r_time = get_timer()
+
+        self._logger.debug(
+            "PresentationProposalHandler called with context %s", context
+        )
+        assert isinstance(context.message, PresentationProposal)
+        self._logger.info(
+            "Received presentation proposal message: %s",
+            context.message.serialize(as_string=True),
+        )
+
+        if not context.connection_ready:
+            raise HandlerException(
+                "No connection established for presentation proposal"
+            )
+
+        presentation_manager = PresentationManager(context)
+        presentation_exchange_record = await presentation_manager.receive_proposal()
+
+        r_time = trace_event(
+            context.settings,
+            context.message,
+            outcome="PresentationProposalHandler.handle.END",
+            perf_counter=r_time,
+        )
+
+        # If auto_respond_presentation_proposal is set, reply with proof req
+        if context.settings.get("debug.auto_respond_presentation_proposal"):
+            (
+                presentation_exchange_record,
+                presentation_request_message,
+            ) = await presentation_manager.create_bound_request(
+                presentation_exchange_record=presentation_exchange_record,
+                comment=context.message.comment,
+            )
+
+            await responder.send_reply(presentation_request_message)
+
+            trace_event(
+                context.settings,
+                presentation_request_message,
+                outcome="PresentationProposalHandler.handle.PRESENT",
+                perf_counter=r_time,
+            )

mydata_did/patched_protocols/present_proof/v1_0/handlers/presentation_ack_handler.py

@@ -0,0 +1,121 @@
+"""Presentation request message handler."""
+
+from .....messaging.base_handler import (
+    BaseHandler,
+    BaseResponder,
+    HandlerException,
+    RequestContext,
+)
+from .....holder.base import BaseHolder
+from .....storage.error import StorageNotFoundError
+
+from ..manager import PresentationManager
+from ..messages.presentation_proposal import PresentationProposal
+from ..messages.presentation_request import PresentationRequest
+from ..models.presentation_exchange import V10PresentationExchange
+from ..util.indy import indy_proof_req_preview2indy_requested_creds
+
+from .....utils.tracing import trace_event, get_timer
+
+
+class PresentationRequestHandler(BaseHandler):
+    """Message handler class for Aries#0037 v1.0 presentation requests."""
+
+    async def handle(self, context: RequestContext, responder: BaseResponder):
+        """
+        Message handler logic for Aries#0037 v1.0 presentation requests.
+
+        Args:
+            context: request context
+            responder: responder callback
+
+        """
+        r_time = get_timer()
+
+        self._logger.debug("PresentationRequestHandler called with context %s", context)
+        assert isinstance(context.message, PresentationRequest)
+        self._logger.info(
+            "Received presentation request message: %s",
+            context.message.serialize(as_string=True),
+        )
+
+        if not context.connection_ready:
+            raise HandlerException("No connection established for presentation request")
+
+        presentation_manager = PresentationManager(context)
+
+        indy_proof_request = context.message.indy_proof_request(0)
+
+        # Get presentation exchange record (holder initiated via proposal)
+        # or create it (verifier sent request first)
+        try:
+            (
+                presentation_exchange_record
+            ) = await V10PresentationExchange.retrieve_by_tag_filter(
+                context,
+                {"thread_id": context.message._thread_id},
+                {"connection_id": context.connection_record.connection_id},
+            )  # holder initiated via proposal
+        except StorageNotFoundError:  # verifier sent this request free of any proposal
+            presentation_exchange_record = V10PresentationExchange(
+                connection_id=context.connection_record.connection_id,
+                thread_id=context.message._thread_id,
+                initiator=V10PresentationExchange.INITIATOR_EXTERNAL,
+                role=V10PresentationExchange.ROLE_PROVER,
+                presentation_request=indy_proof_request,
+                auto_present=context.settings.get(
+                    "debug.auto_respond_presentation_request"
+                ),
+                trace=(context.message._trace is not None),
+            )
+
+        presentation_exchange_record.presentation_request = indy_proof_request
+        presentation_exchange_record = await presentation_manager.receive_request(
+            presentation_exchange_record
+        )
+
+        r_time = trace_event(
+            context.settings,
+            context.message,
+            outcome="PresentationRequestHandler.handle.END",
+            perf_counter=r_time,
+        )
+
+        # If auto_present is enabled, respond immediately with presentation
+        if presentation_exchange_record.auto_present:
+            presentation_preview = None
+            if presentation_exchange_record.presentation_proposal_dict:
+                exchange_pres_proposal = PresentationProposal.deserialize(
+                    presentation_exchange_record.presentation_proposal_dict
+                )
+                presentation_preview = exchange_pres_proposal.presentation_proposal
+
+            try:
+                req_creds = await indy_proof_req_preview2indy_requested_creds(
+                    indy_proof_request,
+                    presentation_preview,
+                    holder=await context.inject(BaseHolder),
+                )
+            except ValueError as err:
+                self._logger.warning(f"{err}")
+                return
+
+            (
+                presentation_exchange_record,
+                presentation_message,
+            ) = await presentation_manager.create_presentation(
+                presentation_exchange_record=presentation_exchange_record,
+                requested_credentials=req_creds,
+                comment="auto-presented for proof request nonce={}".format(
+                    indy_proof_request["nonce"]
+                ),
+            )
+
+            await responder.send_reply(presentation_message)
+
+            trace_event(
+                context.settings,
+                presentation_message,
+                outcome="PresentationRequestHandler.handle.PRESENT",
+                perf_counter=r_time,
+            )

mydata_did/patched_protocols/present_proof/v1_0/handlers/presentation_handler.py

@@ -0,0 +1,53 @@
+import pytest
+from asynctest import (
+    mock as async_mock,
+    TestCase as AsyncTestCase,
+)
+
+from ......messaging.request_context import RequestContext
+from ......messaging.responder import MockResponder
+from ......transport.inbound.receipt import MessageReceipt
+
+from ...messages.presentation_ack import PresentationAck
+from .. import presentation_ack_handler as handler
+
+
+class TestPresentationAckHandler(AsyncTestCase):
+    async def test_called(self):
+        request_context = RequestContext()
+        request_context.message_receipt = MessageReceipt()
+
+        with async_mock.patch.object(
+            handler, "PresentationManager", autospec=True
+        ) as mock_pres_mgr:
+            mock_pres_mgr.return_value.receive_presentation_ack = (
+                async_mock.CoroutineMock()
+            )
+            request_context.message = PresentationAck()
+            request_context.connection_ready = True
+            handler_inst = handler.PresentationAckHandler()
+            responder = MockResponder()
+            await handler_inst.handle(request_context, responder)
+
+        mock_pres_mgr.assert_called_once_with(request_context)
+        mock_pres_mgr.return_value.receive_presentation_ack.assert_called_once_with()
+        assert not responder.messages
+
+    async def test_called_not_ready(self):
+        request_context = RequestContext()
+        request_context.message_receipt = MessageReceipt()
+
+        with async_mock.patch.object(
+            handler, "PresentationManager", autospec=True
+        ) as mock_pres_mgr:
+            mock_pres_mgr.return_value.receive_presentation_ack = (
+                async_mock.CoroutineMock()
+            )
+            request_context.message = PresentationAck()
+            request_context.connection_ready = False
+            handler_inst = handler.PresentationAckHandler()
+            responder = MockResponder()
+            with self.assertRaises(handler.HandlerException):
+                await handler_inst.handle(request_context, responder)
+
+        assert not responder.messages