authgent-server 0.2.2__tar.gz → 0.2.4__tar.gz

{authgent_server-0.2.2 → authgent_server-0.2.4}/.env.production

@@ -14,6 +14,11 @@ AUTHGENT_DATABASE_URL=sqlite+aiosqlite:////tmp/demo/authgent.db
 # Strict CORS — only the deployed frontend + local dev origins.
 AUTHGENT_CORS_ORIGINS=["https://authgent.github.io", "http://localhost:3000", "http://localhost:3001"]
 
+# Public origin used for issuer claim, RFC 9207 iss=, and SEP-2351 path-suffix
+# metadata. Without this, the AS advertises localhost:8000 in production and
+# every issuer-comparison check at the MCP client fails.
+AUTHGENT_SERVER_URL=https://authgent-demo.dhruvagnihotri.com
+
 AUTHGENT_REGISTRATION_POLICY=open
 AUTHGENT_CONSENT_MODE=auto_approve
 AUTHGENT_HOST=0.0.0.0

{authgent_server-0.2.2 → authgent_server-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: authgent-server
-Version: 0.2.2
+Version: 0.2.4
 Summary: Open-source reference implementation of the IETF agent-identity stack — OAuth 2.1 + identity-chaining + transaction-tokens + DPoP + MCP
 Project-URL: Homepage, https://github.com/authgent/authgent
 Project-URL: Documentation, https://github.com/authgent/authgent/tree/main/server

{authgent_server-0.2.2 → authgent_server-0.2.4}/authgent_server/__init__.py

@@ -1,3 +1,3 @@
 """authgent-server — The open-source identity provider for AI agents."""
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"

{authgent_server-0.2.2 → authgent_server-0.2.4}/authgent_server/endpoints/__init__.py

@@ -10,6 +10,7 @@ from authgent_server.endpoints.health import router as health_router
 from authgent_server.endpoints.introspect import router as introspect_router
 from authgent_server.endpoints.register import router as register_router
 from authgent_server.endpoints.revoke import router as revoke_router
+from authgent_server.endpoints.scan import router as scan_router
 from authgent_server.endpoints.stepup import router as stepup_router
 from authgent_server.endpoints.token import router as token_router
 from authgent_server.endpoints.token_check import router as token_check_router
@@ -30,3 +31,4 @@ api_router.include_router(audit_router)
 api_router.include_router(token_inspect_router)
 api_router.include_router(wellknown_router)
 api_router.include_router(health_router)
+api_router.include_router(scan_router)

authgent_server-0.2.4/authgent_server/endpoints/scan.py

@@ -0,0 +1,117 @@
+"""GET /api/scan — public MCP-OAuth conformance scanner endpoint.
+
+Wraps :func:`authgent_server.scanner.scan` so the static GitHub Pages
+``/scan`` page can call it without bundling the scanner. Stateless;
+no DB writes; safe to expose publicly. Per-IP rate limiting is provided
+by the existing :class:`RateLimitMiddleware`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from typing import Literal
+from urllib.parse import urlparse
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+from authgent_server.scanner import (
+    Finding,
+    has_blocking,
+    scan,
+)
+
+router = APIRouter(tags=["scan"])
+
+
+class ScanResponse(BaseModel):
+    target: str
+    grade: Literal["A", "B", "C", "D", "F"]
+    score: int  # 0-100
+    blocking: bool
+    finding_count: int
+    findings: list[dict]
+
+
+def _grade(findings: list[Finding]) -> tuple[str, int]:
+    """Compute a letter grade and 0-100 score from findings."""
+    weight = {"info": 1, "warning": 5, "critical": 25, "error": 15}
+    penalty = sum(weight.get(f.severity, 5) for f in findings)
+    score = max(0, 100 - penalty)
+    if score >= 95:
+        return "A", score
+    if score >= 85:
+        return "B", score
+    if score >= 70:
+        return "C", score
+    if score >= 50:
+        return "D", score
+    return "F", score
+
+
+def _is_safe_url(url: str) -> bool:
+    """Reject URLs that target the Oracle host's own internal network.
+
+    The scanner makes outbound HTTP. If a visitor pastes
+    ``http://localhost`` / ``127.0.0.1`` / a private IP, the scanner would
+    probe authgent's own internal services. Block those.
+    """
+    parsed = urlparse(url)
+    if parsed.scheme not in ("http", "https"):
+        return False
+    host = (parsed.hostname or "").lower()
+    if not host:
+        return False
+    blocked_hosts = {"localhost", "0.0.0.0", "::1"}
+    if host in blocked_hosts:
+        return False
+    if host.startswith("127.") or host.startswith("169.254."):
+        return False
+    if host.startswith("10.") or host.startswith("192.168."):
+        return False
+    if host.startswith("172.") and len(host.split(".")) > 1:
+        try:
+            second = int(host.split(".")[1])
+            if 16 <= second <= 31:
+                return False
+        except ValueError:
+            pass
+    if host.endswith(".internal") or host.endswith(".local"):
+        return False
+    return True
+
+
+@router.get("/api/scan", response_model=ScanResponse)
+async def scan_endpoint(
+    url: str = Query(
+        ...,
+        description="MCP server base URL to audit, e.g. https://mcp.example.com",
+        max_length=2048,
+    ),
+) -> ScanResponse:
+    """Run the MCP-OAuth conformance scanner against ``url`` and return JSON."""
+    if not _is_safe_url(url):
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                "url must be an http(s) URL pointing at a public host. "
+                "Loopback, link-local, and RFC 1918 addresses are blocked."
+            ),
+        )
+    try:
+        findings = await scan(url)
+    except Exception as exc:  # noqa: BLE001 — surface a friendly error
+        raise HTTPException(
+            status_code=502,
+            detail=f"Scanner failed: {exc}",
+        ) from exc
+
+    grade, score = _grade(findings)
+    return ScanResponse(
+        target=url,
+        grade=grade,  # type: ignore[arg-type]
+        score=score,
+        blocking=has_blocking(findings),
+        finding_count=len(findings),
+        findings=[asdict(f) for f in findings],
+    )

{authgent_server-0.2.2 → authgent_server-0.2.4}/authgent_server/endpoints/wellknown.py

@@ -73,6 +73,8 @@ async def oauth_server_metadata(
         "scopes_supported": scopes,
         "resource_indicators_supported": True,
         "dpop_signing_alg_values_supported": ["ES256"],
+        # RFC 9207 / MCP SEP-2468 — we emit iss= on every /authorize redirect.
+        "authorization_response_iss_parameter_supported": True,
         "service_documentation": "https://authgent.dev/docs",
     }
 

{authgent_server-0.2.2 → authgent_server-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "authgent-server"
-version = "0.2.2"
+version = "0.2.4"
 description = "Open-source reference implementation of the IETF agent-identity stack — OAuth 2.1 + identity-chaining + transaction-tokens + DPoP + MCP"
 readme = "README.md"
 license = "Apache-2.0"

authgent_server-0.2.4/tests/test_scan_endpoint.py

@@ -0,0 +1,101 @@
+"""Tests for the public ``/api/scan`` endpoint.
+
+The endpoint must (a) refuse loopback / RFC-1918 / link-local targets so
+the scanner can't probe the host's own internal network, and (b) return
+a structured grade + findings for safe URLs.
+
+The actual scan is patched out — the routing + safety guards are what
+matters here. ``test_scanner.py`` covers the scanner internals.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from authgent_server.endpoints.scan import _grade, _is_safe_url
+from authgent_server.scanner import Finding
+
+# --- safety guard ----------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "http://localhost/",
+        "http://127.0.0.1:8000",
+        "https://10.0.0.5",
+        "http://192.168.1.1",
+        "http://172.16.0.1",
+        "http://172.31.255.255",
+        "http://169.254.169.254",  # AWS metadata
+        "http://thing.internal",
+        "http://thing.local",
+        "ftp://example.com",
+        "javascript:alert(1)",
+        "",
+    ],
+)
+def test_unsafe_urls_rejected(url: str):
+    assert _is_safe_url(url) is False
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "https://mcp.example.com",
+        "https://mcp.example.com/sub",
+        "http://198.51.100.1",  # TEST-NET-2 (public-routed for examples)
+        "https://api.descope.com",
+    ],
+)
+def test_safe_urls_accepted(url: str):
+    assert _is_safe_url(url) is True
+
+
+# --- grading ---------------------------------------------------------------
+
+
+def _f(severity):
+    return Finding(
+        check_id="X",
+        severity=severity,
+        title="t",
+        detail="d",
+        spec_link="https://example",
+        remediation="r",
+    )
+
+
+def test_grade_clean_is_a():
+    grade, score = _grade([])
+    assert grade == "A"
+    assert score == 100
+
+
+def test_grade_one_critical_drops_to_c_or_lower():
+    grade, _ = _grade([_f("critical")])
+    assert grade in ("C", "D", "F", "B")  # depends on weights; never A
+
+
+def test_grade_three_criticals_is_failing():
+    grade, _ = _grade([_f("critical")] * 3)
+    assert grade in ("D", "F")
+
+
+# --- HTTP --------------------------------------------------------------
+
+
+def test_scan_endpoint_rejects_loopback(test_client):
+    resp = test_client.get("/api/scan", params={"url": "http://localhost"})
+    assert resp.status_code == 400
+    assert "blocked" in resp.json()["detail"].lower()
+
+
+def test_scan_endpoint_rejects_private_ip(test_client):
+    resp = test_client.get("/api/scan", params={"url": "http://10.0.0.1"})
+    assert resp.status_code == 400
+
+
+def test_scan_endpoint_rejects_non_http(test_client):
+    resp = test_client.get("/api/scan", params={"url": "ftp://example.com"})
+    assert resp.status_code == 400