DIDComm V2 Initial Implementation

aries_cloudagent/askar/profile.py

@@ -3,9 +3,6 @@
 import asyncio
 import logging
 import time
-
-# import traceback
-
 from typing import Any, Mapping
 from weakref import ref
 
@@ -21,13 +18,13 @@
 from ..indy.verifier import IndyVerifier
 from ..ledger.base import BaseLedger
 from ..ledger.indy_vdr import IndyVdrLedger, IndyVdrLedgerPool
+from ..resolver.did_resolver import DIDResolver
 from ..storage.base import BaseStorage, BaseStorageSearch
 from ..storage.vc_holder.base import VCHolder
 from ..utils.multi_ledger import get_write_ledger_config_for_profile
 from ..wallet.base import BaseWallet
 from ..wallet.crypto import validate_seed
-
-from .store import AskarStoreConfig, AskarOpenStore
+from .store import AskarOpenStore, AskarStoreConfig
 
 LOGGER = logging.getLogger(__name__)
 
@@ -94,6 +91,18 @@ def bind_providers(self):
         """Initialize the profile-level instance providers."""
         injector = self._context.injector
 
+        if self.context.settings.get("experiment.didcomm_v2"):
+            from didcomm_messaging.resolver import DIDResolver as DMPResolver
+
+            injector.bind_provider(
+                DMPResolver,
+                ClassProvider(
+                    "aries_cloudagent.didcomm_v2.adapters.ResolverAdapter",
+                    ref(self),
+                    ClassProvider.Inject(DIDResolver),
+                ),
+            )
+
         injector.bind_provider(
             BaseStorageSearch,
             ClassProvider(
@@ -252,6 +261,35 @@ async def _setup(self):
             ClassProvider("aries_cloudagent.storage.askar.AskarStorage", ref(self)),
         )
 
+        if self.profile.settings.get("experiment.didcomm_v2"):
+            from didcomm_messaging import (
+                CryptoService,
+                DIDCommMessaging,
+                PackagingService,
+                RoutingService,
+                SecretsManager,
+            )
+            from didcomm_messaging.resolver import DIDResolver as DMPResolver
+
+            injector.bind_provider(
+                SecretsManager,
+                ClassProvider(
+                    "aries_cloudagent.didcomm_v2.adapters.SecretsAdapter", ref(self)
+                ),
+            )
+
+            injector.bind_provider(
+                DIDCommMessaging,
+                ClassProvider(
+                    DIDCommMessaging,
+                    ClassProvider.Inject(CryptoService),
+                    ClassProvider.Inject(SecretsManager),
+                    ClassProvider.Inject(DMPResolver),
+                    ClassProvider.Inject(PackagingService),
+                    ClassProvider.Inject(RoutingService),
+                ),
+            )
+
     async def _teardown(self, commit: bool = None):
         """Dispose of the session or transaction connection."""
         if commit:

aries_cloudagent/config/argparse.py

@@ -1172,6 +1172,13 @@ def add_arguments(self, parser: ArgumentParser):
             ),
         )
 
+        parser.add_argument(
+            "--experimental-didcomm-v2",
+            action="store_true",
+            env_var="ACAPY_EXP_DIDCOMM_V2",
+            help="Enable experimental DIDComm V2 support.",
+        )
+
     def get_settings(self, args: Namespace) -> dict:
         """Get protocol settings."""
         settings = {}
@@ -1237,6 +1244,8 @@ def get_settings(self, args: Namespace) -> dict:
         if args.exch_use_unencrypted_tags:
             settings["exch_use_unencrypted_tags"] = True
             environ["EXCH_UNENCRYPTED_TAGS"] = "True"
+        if args.experimental_didcomm_v2:
+            settings["experiment.didcomm_v2"] = True
 
         return settings
 

aries_cloudagent/config/default_context.py

@@ -6,7 +6,10 @@
 from ..core.event_bus import EventBus
 from ..core.goal_code_registry import GoalCodeRegistry
 from ..core.plugin_registry import PluginRegistry
-from ..core.profile import ProfileManager, ProfileManagerProvider
+from ..core.profile import (
+    ProfileManager,
+    ProfileManagerProvider,
+)
 from ..core.protocol_registry import ProtocolRegistry
 from ..protocols.actionmenu.v1_0.base_service import BaseMenuService
 from ..protocols.actionmenu.v1_0.driver_service import DriverMenuService
@@ -53,14 +56,27 @@ async def build_context(self) -> InjectionContext:
         context.injector.bind_instance(EventBus, EventBus())
 
         # Global did resolver
-        context.injector.bind_instance(DIDResolver, DIDResolver([]))
+        context.injector.bind_instance(DIDResolver, DIDResolver())
         context.injector.bind_instance(AnonCredsRegistry, AnonCredsRegistry())
         context.injector.bind_instance(DIDMethods, DIDMethods())
         context.injector.bind_instance(KeyTypes, KeyTypes())
         context.injector.bind_instance(
             BaseVerificationKeyStrategy, DefaultVerificationKeyStrategy()
         )
 
+        # DIDComm Messaging
+        if context.settings.get("experiment.didcomm_v2"):
+            from didcomm_messaging import (
+                CryptoService,
+                PackagingService,
+                RoutingService,
+            )
+            from didcomm_messaging.crypto.backend.askar import AskarCryptoService
+
+            context.injector.bind_instance(CryptoService, AskarCryptoService())
+            context.injector.bind_instance(PackagingService, PackagingService())
+            context.injector.bind_instance(RoutingService, RoutingService())
+
         await self.bind_providers(context)
         await self.load_plugins(context)
 

aries_cloudagent/connections/base_manager.py

@@ -55,7 +55,7 @@
 from ..wallet.did_info import INVITATION_REUSE_KEY, DIDInfo, KeyInfo
 from ..wallet.did_method import PEER2, PEER4, SOV, DIDMethod
 from ..wallet.error import WalletNotFoundError
-from ..wallet.key_type import ED25519
+from ..wallet.key_type import ED25519, X25519
 from ..wallet.util import b64_to_bytes, bytes_to_b58
 from .models.conn_record import ConnRecord
 from .models.connection_target import ConnectionTarget
@@ -85,9 +85,18 @@ def __init__(self, profile: Profile):
     @staticmethod
     def _key_info_to_multikey(key_info: KeyInfo) -> str:
         """Convert a KeyInfo to a multikey."""
-        return multibase.encode(
-            multicodec.wrap("ed25519-pub", b58decode(key_info.verkey)), "base58btc"
-        )
+        if key_info.key_type == ED25519:
+            return multibase.encode(
+                multicodec.wrap("ed25519-pub", b58decode(key_info.verkey)), "base58btc"
+            )
+        elif key_info.key_type == X25519:
+            return multibase.encode(
+                multicodec.wrap("x25519-pub", b58decode(key_info.verkey)), "base58btc"
+            )
+        else:
+            raise BaseConnectionManagerError(
+                "Unsupported key type. Could not convert to multikey."
+            )
 
     def long_did_peer_to_short(self, long_did: str) -> str:
         """Convert did:peer:4 long format to short format and return."""
@@ -222,13 +231,30 @@ async def create_did_peer_2(
                     "serviceEndpoint": endpoint,
                 }
             )
+            if self._profile.settings.get("experiment.didcomm_v2"):
+                services.append(
+                    {
+                        "id": f"#service-{index}",
+                        "type": "DIDCommMessaging",
+                        "serviceEndpoint": {
+                            "uri": endpoint,
+                            "accept": ["didcomm/v2"],
+                            "routingKeys": routing_keys,
+                        },
+                    }
+                )
 
         async with self._profile.session() as session:
             wallet = session.inject(BaseWallet)
             key = await wallet.create_key(ED25519)
+            xk = await wallet.create_key(X25519)
 
             did = generate(
-                [KeySpec.verification(self._key_info_to_multikey(key))], services
+                [
+                    KeySpec.verification(self._key_info_to_multikey(key)),
+                    KeySpec.key_agreement(self._key_info_to_multikey(xk)),
+                ],
+                services,
             )
 
             did_metadata = metadata if metadata else {}
@@ -240,6 +266,8 @@ async def create_did_peer_2(
                 key_type=ED25519,
             )
             await wallet.store_did(did_info)
+            await wallet.assign_kid_to_key(key.verkey, f"{did}#key-1")
+            await wallet.assign_kid_to_key(xk.verkey, f"{did}#key-2")
 
         return did_info
 

aries_cloudagent/core/dispatcher.py

@@ -17,12 +17,13 @@
 from ..connections.models.conn_record import ConnRecord
 from ..core.profile import Profile
 from ..messaging.agent_message import AgentMessage
-from ..messaging.base_message import BaseMessage
+from ..messaging.base_message import BaseMessage, DIDCommVersion
 from ..messaging.error import MessageParseError
 from ..messaging.models.base import BaseModelError
 from ..messaging.request_context import RequestContext
 from ..messaging.responder import BaseResponder, SKIP_ACTIVE_CONN_CHECK_MSG_TYPES
 from ..messaging.util import datetime_now
+from ..messaging.v2_agent_message import V2AgentMessage
 from ..protocols.problem_report.v1_0.message import ProblemReport
 from ..transport.inbound.message import InboundMessage
 from ..transport.outbound.message import OutboundMessage
@@ -108,12 +109,55 @@ def queue_message(
             A pending task instance resolving to the handler task
 
         """
+
+        if (
+            self.profile.settings.get("experiment.didcomm_v2")
+            and inbound_message.receipt.didcomm_version == DIDCommVersion.v2
+        ):
+            handle = self.handle_v2_message(profile, inbound_message, send_outbound)
+        else:
+            handle = self.handle_v1_message(profile, inbound_message, send_outbound)
+
         return self.put_task(
-            self.handle_message(profile, inbound_message, send_outbound),
+            handle,
             complete,
         )
 
-    async def handle_message(
+    async def handle_v2_message(
+        self,
+        profile: Profile,
+        inbound_message: InboundMessage,
+        send_outbound: Coroutine,
+    ):
+        """Handle a DIDComm V2 message."""
+
+        # send a DCV2 Problem Report here for testing, and to punt procotol handling down
+        # the road a bit
+        context = RequestContext(profile)
+        context.message_receipt = inbound_message.receipt
+        responder = DispatcherResponder(
+            context,
+            inbound_message,
+            send_outbound,
+            reply_session_id=inbound_message.session_id,
+            reply_to_verkey=inbound_message.receipt.sender_verkey,
+        )
+
+        context.injector.bind_instance(BaseResponder, responder)
+        error_result = V2AgentMessage(
+            message={
+                "type": "https://didcomm.org/report-problem/2.0/problem-report",
+                "body": {
+                    "comment": "No Handlers Found",
+                    "code": "e.p.msg.not-found",
+                },
+            }
+        )
+        if inbound_message.receipt.thread_id:
+            error_result.message["pthid"] = inbound_message.receipt.thread_id
+        await responder.send_reply(error_result)
+
+    async def handle_v1_message(
         self,
         profile: Profile,
         inbound_message: InboundMessage,

aries_cloudagent/didcomm_v2/adapters.py

@@ -0,0 +1,79 @@
+"""Adapters for DMP library."""
+
+import logging
+from typing import Optional, cast
+from aries_askar import Key
+
+try:
+    from didcomm_messaging import SecretsManager
+    from didcomm_messaging.crypto.backend.askar import AskarSecretKey
+    from didcomm_messaging.resolver import DIDResolver as DMPResolver
+except ModuleNotFoundError as err:
+    raise ImportError("Install the didcommv2 extra to use this module.") from err
+
+from ..core.error import BaseError
+from ..core.profile import Profile, ProfileSession
+from ..resolver.did_resolver import DIDResolver
+from ..askar.profile import AskarProfileSession
+
+
+LOGGER = logging.getLogger(__name__)
+
+
+class DMPAdapterError(BaseError):
+    """Raised on general errors from DMP Adapters."""
+
+
+class ResolverAdapter(DMPResolver):
+    """Adapter for ACA-Py resolver to DMP Resolver."""
+
+    def __init__(self, profile: Profile, resolver: DIDResolver):
+        """Init the adapter."""
+        self.profile = profile
+        self.resolver = resolver
+
+    async def resolve(self, did: str) -> dict:
+        """Resolve a DID."""
+        return await self.resolver.resolve(self.profile, did)
+
+    async def is_resolvable(self, did: str) -> bool:
+        """Check to see if a DID is resolvable."""
+        for resolver in self.resolver.resolvers:
+            if await resolver.supports(self.profile, did):
+                return True
+
+        return False
+
+
+class SecretsAdapterError(DMPAdapterError):
+    """Errors from DMP Secrets Adapter."""
+
+
+class SecretsAdapter(SecretsManager[AskarSecretKey]):
+    """Adapter for providing a secrets manager compatible with DMP."""
+
+    def __init__(self, session: ProfileSession):
+        """Init the adapter."""
+        self.session = session
+
+    async def get_secret_by_kid(self, kid: str) -> Optional[AskarSecretKey]:
+        """Get a secret key by its ID."""
+        if not isinstance(self.session, AskarProfileSession):
+            raise SecretsAdapterError(
+                "ACA-Py's implementation of DMP only supports an Askar backend"
+            )
+
+        LOGGER.debug("GETTING SECRET BY KID: %s", kid)
+        key_entries = await self.session.handle.fetch_all_keys(
+            tag_filter={"kid": kid}, limit=2
+        )
+        if len(key_entries) > 1:
+            raise SecretsAdapterError(f"More than one key found with kid {kid}")
+
+        entry = key_entries[0]
+        if entry:
+            key = cast(Key, entry.key)
+            return AskarSecretKey(key=key, kid=kid)
+
+        LOGGER.debug("RETURNING NONE")
+        return None