Merge pull request #11 from PredicateSystems/auth

auth endpoint

Author: rcholic

predicate_authority/daemon.py

@@ -49,7 +49,18 @@
     SidecarConfig,
 )
 from predicate_authority.sidecar_store import LocalCredentialStore
-from predicate_contracts import PolicyRule, TraceEmitter
+from predicate_contracts import (
+    ActionRequest,
+    ActionSpec,
+    AuthorizationDecision,
+    PolicyRule,
+    PrincipalRef,
+    StateEvidence,
+    TraceEmitter,
+    VerificationEvidence,
+    VerificationSignal,
+    VerificationStatus,
+)
 
 
 @dataclass(frozen=True)
@@ -185,6 +196,8 @@ def do_GET(self) -> None:  # noqa: N802
     def do_POST(self) -> None:  # noqa: N802
         parsed = urlparse(self.path)
         handlers: dict[str, Any] = {
+            "/v1/authorize": self._handle_authorize,
+            "/authorize": self._handle_authorize,
             "/policy/reload": self._handle_policy_reload,
             "/revoke/principal": self._handle_revoke_principal,
             "/revoke/intent": self._handle_revoke_intent,
@@ -201,6 +214,137 @@ def do_POST(self) -> None:  # noqa: N802
             return
         handler()
 
+    def _handle_authorize(self) -> None:
+        payload = self._read_json_body()
+        try:
+            request = self._build_action_request(payload)
+        except ValueError as exc:
+            self._send_json(400, {"error": str(exc)})
+            return
+        decision = self.server.daemon_ref.authorize_request(request)  # type: ignore[attr-defined]
+        response = {
+            "allowed": decision.allowed,
+            "reason": decision.reason.value,
+            "mandate_id": (
+                decision.mandate.claims.mandate_id if decision.mandate is not None else None
+            ),
+            "violated_rule": decision.violated_rule,
+            "missing_labels": list(decision.missing_labels),
+        }
+        self._send_json(200 if decision.allowed else 403, response)
+
+    def _build_action_request(self, payload: dict[str, Any]) -> ActionRequest:
+        principal_id = payload.get("principal")
+        if not isinstance(principal_id, str) or principal_id.strip() == "":
+            raise ValueError("principal is required")
+        action = payload.get("action")
+        if not isinstance(action, str) or action.strip() == "":
+            raise ValueError("action is required")
+        resource = payload.get("resource")
+        if not isinstance(resource, str) or resource.strip() == "":
+            raise ValueError("resource is required")
+
+        intent_hash = payload.get("intent_hash")
+        if isinstance(intent_hash, str) and intent_hash.strip() != "":
+            intent = intent_hash.strip()
+        else:
+            intent = f"{action.strip()}:{resource.strip()}"
+
+        context_raw = payload.get("context")
+        context = context_raw if isinstance(context_raw, dict) else {}
+        tenant_id = context.get("tenant_id")
+        session_id = context.get("session_id")
+        state = self._parse_state_evidence(payload=payload, context=context, intent=intent)
+        verification = self._parse_verification_evidence(payload=payload)
+
+        return ActionRequest(
+            principal=PrincipalRef(
+                principal_id=principal_id.strip(),
+                tenant_id=tenant_id if isinstance(tenant_id, str) else None,
+                session_id=session_id if isinstance(session_id, str) else None,
+            ),
+            action_spec=ActionSpec(
+                action=action.strip(),
+                resource=resource.strip(),
+                intent=intent,
+            ),
+            state_evidence=state,
+            verification_evidence=verification,
+        )
+
+    def _parse_state_evidence(
+        self,
+        payload: dict[str, Any],
+        context: dict[str, Any],
+        intent: str,
+    ) -> StateEvidence:
+        state_raw = payload.get("state_evidence")
+        if not isinstance(state_raw, dict):
+            state_raw = {}
+        source = state_raw.get("source")
+        state_hash = state_raw.get("state_hash")
+        schema_version = state_raw.get("schema_version")
+        confidence = state_raw.get("confidence")
+
+        source_value = (
+            source.strip() if isinstance(source, str) and source.strip() != "" else "external"
+        )
+        if isinstance(state_hash, str) and state_hash.strip() != "":
+            state_hash_value = state_hash.strip()
+        else:
+            context_state_hash = context.get("state_hash")
+            if isinstance(context_state_hash, str) and context_state_hash.strip() != "":
+                state_hash_value = context_state_hash.strip()
+            else:
+                state_hash_value = intent
+        schema_value = (
+            schema_version.strip()
+            if isinstance(schema_version, str) and schema_version.strip() != ""
+            else "v1"
+        )
+        confidence_value = float(confidence) if isinstance(confidence, (float, int)) else None
+        return StateEvidence(
+            source=source_value,
+            state_hash=state_hash_value,
+            schema_version=schema_value,
+            confidence=confidence_value,
+        )
+
+    def _parse_verification_evidence(self, payload: dict[str, Any]) -> VerificationEvidence:
+        verification_raw = payload.get("verification_evidence")
+        if not isinstance(verification_raw, dict):
+            return VerificationEvidence()
+        signals_raw = verification_raw.get("signals")
+        if not isinstance(signals_raw, list):
+            return VerificationEvidence()
+        parsed_signals: list[VerificationSignal] = []
+        for item in signals_raw:
+            if not isinstance(item, dict):
+                continue
+            label = item.get("label")
+            status = item.get("status")
+            if not isinstance(label, str) or label.strip() == "":
+                continue
+            if not isinstance(status, str):
+                continue
+            try:
+                parsed_status = VerificationStatus(status.strip())
+            except ValueError:
+                continue
+            required_raw = item.get("required")
+            required = bool(required_raw) if isinstance(required_raw, bool) else True
+            reason_raw = item.get("reason")
+            reason = reason_raw if isinstance(reason_raw, str) else None
+            parsed_signals.append(
+                VerificationSignal(
+                    label=label.strip(),
+                    status=parsed_status,
+                    required=required,
+                    reason=reason,
+                )
+            )
+        return VerificationEvidence(signals=tuple(parsed_signals))
+
     def _handle_policy_reload(self) -> None:
         reloaded = self.server.daemon_ref.reload_policy_now()  # type: ignore[attr-defined]
         self._send_json(200, {"reloaded": reloaded})
@@ -447,6 +591,9 @@ def revoke_mandate(self, mandate_id: str) -> None:
     def max_request_body_bytes(self) -> int:
         return max(0, int(self._config.max_request_body_bytes))
 
+    def authorize_request(self, request: ActionRequest) -> AuthorizationDecision:
+        return self._sidecar.issue_mandate(request)
+
     def issue_task_identity(
         self,
         principal_id: str,

tests/test_daemon_phase2.py

@@ -116,6 +116,24 @@ def _post_json(url: str, body: dict[str, object] | None = None) -> dict[str, obj
     return loaded
 
 
+def _post_json_with_status(
+    url: str, body: dict[str, object] | None = None
+) -> tuple[int, dict[str, object]]:
+    parsed = urlsplit(url)
+    path = parsed.path or "/"
+    payload = json.dumps(body or {})
+    connection = http.client.HTTPConnection(parsed.netloc, timeout=2.0)
+    try:
+        connection.request("POST", path, body=payload, headers={"Content-Type": "application/json"})
+        response = connection.getresponse()
+        content = response.read().decode("utf-8")
+        loaded = json.loads(content) if content else {}
+    finally:
+        connection.close()
+    assert isinstance(loaded, dict)
+    return int(response.status), loaded
+
+
 def _fetch_text(url: str) -> str:
     parsed = urlsplit(url)
     path = parsed.path or "/"
@@ -310,6 +328,119 @@ def test_daemon_supports_policy_reload_and_revoke_endpoints(tmp_path: Path) -> N
         daemon.stop()
 
 
+def test_daemon_authorize_endpoint_allows_and_returns_mandate_metadata(tmp_path: Path) -> None:
+    policy_file = tmp_path / "policy.json"
+    policy_file.write_text(
+        json.dumps(
+            {
+                "rules": [
+                    {
+                        "name": "allow-any-http",
+                        "effect": "allow",
+                        "principals": ["agent:*"],
+                        "actions": ["http.*"],
+                        "resources": ["https://*/*"],
+                    }
+                ]
+            }
+        ),
+        encoding="utf-8",
+    )
+    sidecar = _build_sidecar(tmp_path, policy_file)
+    daemon = PredicateAuthorityDaemon(
+        sidecar=sidecar,
+        config=DaemonConfig(host="127.0.0.1", port=0, policy_poll_interval_s=10.0),
+    )
+    daemon.start()
+    try:
+        base_url = f"http://127.0.0.1:{daemon.bound_port}"
+        status_code, payload = _post_json_with_status(
+            f"{base_url}/v1/authorize",
+            {
+                "principal": "agent:test",
+                "action": "http.post",
+                "resource": "https://api.vendor.com/orders",
+                "intent_hash": "intent-hash-123",
+                "context": {"tenant_id": "tenant-a", "session_id": "session-a"},
+                "state_evidence": {"source": "test", "state_hash": "state-1"},
+            },
+        )
+        assert status_code == 200
+        assert payload["allowed"] is True
+        assert payload["reason"] == "allowed"
+        assert isinstance(payload.get("mandate_id"), str)
+        assert payload.get("missing_labels") == []
+    finally:
+        daemon.stop()
+
+
+def test_daemon_authorize_endpoint_denies_with_403(tmp_path: Path) -> None:
+    policy_file = tmp_path / "policy.json"
+    policy_file.write_text(
+        json.dumps(
+            {
+                "rules": [
+                    {
+                        "name": "allow-only-orders",
+                        "effect": "allow",
+                        "principals": ["agent:*"],
+                        "actions": ["http.post"],
+                        "resources": ["https://api.vendor.com/orders"],
+                    }
+                ]
+            }
+        ),
+        encoding="utf-8",
+    )
+    sidecar = _build_sidecar(tmp_path, policy_file)
+    daemon = PredicateAuthorityDaemon(
+        sidecar=sidecar,
+        config=DaemonConfig(host="127.0.0.1", port=0, policy_poll_interval_s=10.0),
+    )
+    daemon.start()
+    try:
+        base_url = f"http://127.0.0.1:{daemon.bound_port}"
+        status_code, payload = _post_json_with_status(
+            f"{base_url}/v1/authorize",
+            {
+                "principal": "agent:test",
+                "action": "http.delete",
+                "resource": "https://api.vendor.com/orders",
+                "intent_hash": "intent-hash-123",
+                "state_evidence": {"source": "test", "state_hash": "state-1"},
+            },
+        )
+        assert status_code == 403
+        assert payload["allowed"] is False
+        assert payload["reason"] == "no_matching_policy"
+    finally:
+        daemon.stop()
+
+
+def test_daemon_authorize_endpoint_validates_required_fields(tmp_path: Path) -> None:
+    policy_file = tmp_path / "policy.json"
+    policy_file.write_text(json.dumps({"rules": []}), encoding="utf-8")
+    sidecar = _build_sidecar(tmp_path, policy_file)
+    daemon = PredicateAuthorityDaemon(
+        sidecar=sidecar,
+        config=DaemonConfig(host="127.0.0.1", port=0, policy_poll_interval_s=10.0),
+    )
+    daemon.start()
+    try:
+        base_url = f"http://127.0.0.1:{daemon.bound_port}"
+        status_code, payload = _post_json_with_status(
+            f"{base_url}/v1/authorize",
+            {
+                "action": "http.post",
+                "resource": "https://api.vendor.com/orders",
+            },
+        )
+        assert status_code == 400
+        assert payload["error"] == "principal is required"
+    finally:
+        daemon.stop()
+
+
 class _ControlPlaneHandler(BaseHTTPRequestHandler):
     requests: list[tuple[str, dict[str, object], dict[str, str]]]