Merge pull request #23 from airlock-protocol/worktree-agent-ac96ae14

feat: dual-mode auth (Ed25519 + OAuth) and challenge deprecation

Author: shivdeep1

airlock/config.py

@@ -73,7 +73,7 @@ class AirlockConfig(BaseSettings):
     expect_replicas: int = Field(default=1, ge=1)
 
     # Challenge fallback mode when LLM is unavailable: "ambiguous" (default) or "rule_based".
-    challenge_fallback_mode: str = "ambiguous"
+    challenge_fallback_mode: str = "disabled"
 
     # -----------------------------------------------------------------------
     # Scoring (generic defaults — production overrides via env vars)

airlock/engine/orchestrator.py

@@ -3,15 +3,18 @@
 Node map (11 nodes):
   resolve                  -> validate_schema
   validate_schema          -> check_revocation
-  check_revocation         -> verify_signature          (or failed)
-  verify_signature         -> validate_vc               (or failed)
+  check_revocation         -> verify_identity           (or failed)
+  verify_identity          -> validate_vc               (or failed)
   validate_vc              -> validate_delegation        (or failed)
   validate_delegation      -> cross_ref_capabilities    (or failed)
   cross_ref_capabilities   -> check_reputation          (or failed)
-  check_reputation         -> semantic_challenge | issue_verdict (fast-path / blacklist)
+  check_reputation         -> semantic_challenge | issue_verdict (fast-path / blacklist / disabled)
   semantic_challenge       -> issue_verdict
   issue_verdict            -> seal_session
   seal_session             -> END
+
+Identity verification supports dual-mode auth: Ed25519 signatures (default) and
+OAuth bearer tokens (when airlock.oauth module is available).
 """
 
 from __future__ import annotations
@@ -23,9 +26,9 @@
 
 from langgraph.graph import END, StateGraph
 
+from airlock.config import get_config
 from airlock.crypto.keys import KeyPair, resolve_public_key
 from airlock.crypto.signing import sign_attestation, verify_model
-from airlock.config import get_config
 from airlock.crypto.vc import extract_capabilities, validate_credential
 from airlock.engine.state import SessionManager
 from airlock.gateway.revocation import RedisRevocationStore, RevocationStore
@@ -84,6 +87,7 @@ class OrchestrationState(TypedDict, total=False):
     _challenge_outcome: str | None
     _tier: int  # TrustTier int value
     _local_only: bool
+    _bearer_token: str | None  # OAuth bearer token (if present)
 
 
 # ---------------------------------------------------------------------------
@@ -306,6 +310,7 @@ async def _handle_handshake(self, event: HandshakeReceived) -> None:
             "_challenge_outcome": None,
             "_tier": TrustTier.UNKNOWN,
             "_local_only": getattr(request, "privacy_mode", "any") == "local_only",
+            "_bearer_token": getattr(event, "bearer_token", None),
         }
 
         # Run the graph synchronously through all nodes.
@@ -620,34 +625,66 @@ def _node_check_revocation(self, state: OrchestrationState) -> OrchestrationStat
     def _route_after_revocation(self, state: OrchestrationState) -> str:
         if state.get("failed_at") == "check_revocation":
             return "failed"
-        return "verify_signature"
+        return "verify_identity"
 
-    def _node_verify_signature(self, state: OrchestrationState) -> OrchestrationState:
-        """Node 2: verify the Ed25519 signature on the HandshakeRequest."""
+    def _node_verify_identity(self, state: OrchestrationState) -> OrchestrationState:
+        """Node 2: verify identity via OAuth bearer token or Ed25519 signature.
+
+        Dual-mode auth: tries OAuth first (if bearer token present and oauth module
+        available), then falls back to Ed25519 signature verification.
+        """
         checks: list[CheckResult] = list(state.get("check_results", []))
         request = state["handshake"]
+        auth_method = "ed25519"
 
-        try:
-            verify_key = resolve_public_key(request.initiator.did)
-            valid = verify_model(request, verify_key)
-        except Exception as exc:
-            valid = False
-            logger.debug("Signature verification error: %s", exc)
+        # --- Try OAuth bearer token first ---
+        oauth_validated = False
+        bearer_token = state.get("_bearer_token")
+        if bearer_token is not None:
+            try:
+                from airlock.oauth.token_validator import validate_access_token
+
+                gateway_vk = self._airlock_keypair.verify_key if self._airlock_keypair else None
+                if gateway_vk is not None:
+                    token_data = validate_access_token(bearer_token, gateway_vk)
+                    if token_data.get("sub") == request.initiator.did:
+                        oauth_validated = True
+                        auth_method = "oauth"
+            except ImportError:
+                logger.debug("OAuth module not available, falling back to Ed25519")
+            except Exception as exc:
+                logger.debug("OAuth token validation failed: %s", exc)
+
+        # --- Fall back to Ed25519 signature verification ---
+        if not oauth_validated:
+            try:
+                verify_key = resolve_public_key(request.initiator.did)
+                valid = verify_model(request, verify_key)
+            except Exception as exc:
+                valid = False
+                logger.debug("Signature verification error: %s", exc)
+        else:
+            valid = True
 
+        detail = (
+            f"Identity verified via {auth_method}"
+            if valid
+            else "Identity verification failed"
+        )
         checks.append(
             CheckResult(
                 check=VerificationCheck.SIGNATURE,
                 passed=valid,
-                detail="Ed25519 signature valid" if valid else "Signature verification failed",
+                detail=detail,
             )
         )
         state["check_results"] = checks
         state["_sig_valid"] = valid
         if valid:
             state["session"].state = VerificationState.SIGNATURE_VERIFIED
         else:
-            state["error"] = "Invalid signature"
-            state["failed_at"] = "verify_signature"
+            state["error"] = "Invalid identity"
+            state["failed_at"] = "verify_identity"
             state["verdict"] = TrustVerdict.REJECTED
             state["session"].state = VerificationState.FAILED
         return state
@@ -1055,7 +1092,7 @@ def _node_failed(self, state: OrchestrationState) -> OrchestrationState:
     # Conditional edge functions
     # ------------------------------------------------------------------
 
-    def _route_after_signature(self, state: OrchestrationState) -> str:
+    def _route_after_identity(self, state: OrchestrationState) -> str:
         return "validate_vc" if state.get("_sig_valid") else "failed"
 
     def _route_after_vc(self, state: OrchestrationState) -> str:
@@ -1068,6 +1105,9 @@ def _route_after_reputation(self, state: OrchestrationState) -> str:
         elif routing in ("fast_path", "issue_verdict"):
             return "issue_verdict"
         else:
+            cfg = get_config()
+            if cfg.challenge_fallback_mode == "disabled":
+                return "issue_verdict"
             return "semantic_challenge"
 
     # ------------------------------------------------------------------
@@ -1079,7 +1119,7 @@ def _build_graph(self) -> Any:
 
         graph.add_node("validate_schema", self._node_validate_schema)
         graph.add_node("check_revocation", self._node_check_revocation)
-        graph.add_node("verify_signature", self._node_verify_signature)
+        graph.add_node("verify_identity", self._node_verify_identity)
         graph.add_node("validate_vc", self._node_validate_vc)
         graph.add_node("validate_delegation", self._node_validate_delegation)
         graph.add_node("cross_ref_capabilities", self._node_cross_ref_capabilities)
@@ -1095,11 +1135,11 @@ def _build_graph(self) -> Any:
         graph.add_conditional_edges(
             "check_revocation",
             self._route_after_revocation,
-            {"verify_signature": "verify_signature", "failed": "failed"},
+            {"verify_identity": "verify_identity", "failed": "failed"},
         )
         graph.add_conditional_edges(
-            "verify_signature",
-            self._route_after_signature,
+            "verify_identity",
+            self._route_after_identity,
             {"validate_vc": "validate_vc", "failed": "failed"},
         )
         graph.add_conditional_edges(

airlock/gateway/handlers.py

@@ -67,6 +67,14 @@ def _is_valid_did(did: str) -> bool:
 logger = logging.getLogger(__name__)
 
 
+def _extract_bearer_token(request: Request) -> str | None:
+    """Extract OAuth bearer token from the Authorization header, if present."""
+    auth_header = request.headers.get("authorization", "")
+    if auth_header.lower().startswith("bearer "):
+        return auth_header[7:].strip()
+    return None
+
+
 def _audit_bg(request: Request, **kwargs: object) -> None:
     """Fire-and-forget audit trail append (non-blocking)."""
     trail = getattr(request.app.state, "audit_trail", None)
@@ -310,13 +318,15 @@ async def handle_handshake(
     )
 
     # Publish to event bus — orchestrator handles the rest asynchronously
+    bearer_token = _extract_bearer_token(request)
     event_bus = request.app.state.event_bus
     if not event_bus.try_publish(
         HandshakeReceived(
             session_id=session_id,
             timestamp=datetime.now(UTC),
             request=body,
             callback_url=callback_url,
+            bearer_token=bearer_token,
         )
     ):
         return _nack(request, "Event queue saturated", "SERVICE_BUSY", session_id)

airlock/schemas/events.py

@@ -26,6 +26,7 @@ class HandshakeReceived(VerificationEvent):
     event_type: Literal["handshake_received"] = "handshake_received"
     request: HandshakeRequest
     callback_url: str | None = None
+    bearer_token: str | None = None
 
 
 class SignatureVerified(VerificationEvent):

tests/test_a2a_gateway.py

@@ -30,11 +30,17 @@
 
 
 @pytest.fixture
-def a2a_config(tmp_path):
-    return AirlockConfig(
+def a2a_config(tmp_path, monkeypatch):
+    cfg = AirlockConfig(
         lancedb_path=str(tmp_path / "a2a_rep.lance"),
         trust_token_secret="a2a_jwt_test_secret_not_for_production_use",
+        challenge_fallback_mode="ambiguous",
     )
+    # Ensure the global config singleton also uses challenge mode for A2A tests
+    import airlock.config as _cfg_mod
+
+    monkeypatch.setattr(_cfg_mod, "_config_instance", cfg)
+    return cfg
 
 
 @pytest.fixture

tests/test_decay_on_read.py

@@ -42,8 +42,16 @@ def _make_hs(session_id: str, agent: KeyPair, issuer: KeyPair, target: str) -> H
 
 
 @pytest.mark.asyncio
-async def test_decayed_high_score_routes_to_challenge(tmp_path):
+async def test_decayed_high_score_routes_to_challenge(tmp_path, monkeypatch):
     """Score stored as 0.80 with old last_interaction decays below fast-path threshold."""
+    # Enable challenge mode for this test (default is now "disabled")
+    import airlock.config as _cfg_mod
+    from airlock.config import AirlockConfig
+
+    monkeypatch.setattr(
+        _cfg_mod, "_config_instance", AirlockConfig(challenge_fallback_mode="ambiguous")
+    )
+
     agent = KeyPair.from_seed(b"a" * 32)
     issuer = KeyPair.from_seed(b"i" * 32)
     target = KeyPair.from_seed(b"t" * 32)