svc-infra 0.1.593__py3-none-any.whl → 0.1.595__py3-none-any.whl

svc_infra/api/fastapi/auth/routers/oauth_router.py

@@ -28,6 +28,8 @@ from svc_infra.api.fastapi.paths.auth import (
     OAUTH_LOGIN_PATH,
     OAUTH_REFRESH_PATH,
 )
+from svc_infra.security.models import RefreshToken
+from svc_infra.security.session import issue_session_and_refresh, rotate_session_refresh
 
 
 def _gen_pkce_pair() -> tuple[str, str]:
@@ -466,9 +468,13 @@ async def _validate_and_decode_jwt_token(raw_token: str) -> str:
 
 
 async def _set_cookie_on_response(
-    resp: Response, auth_backend: AuthenticationBackend, user: Any
+    resp: Response,
+    auth_backend: AuthenticationBackend,
+    user: Any,
+    *,
+    refresh_raw: str,
 ) -> None:
-    """Set authentication cookie on response."""
+    """Set authentication (JWT) and refresh cookies on response."""
     st = get_auth_settings()
     strategy = auth_backend.get_strategy()
     jwt_token = await strategy.write_token(user)
@@ -477,6 +483,7 @@ async def _set_cookie_on_response(
     if same_site_lit == "none" and not bool(st.session_cookie_secure):
         raise HTTPException(500, "session_cookie_samesite=None requires session_cookie_secure=True")
 
+    # Access/Auth cookie (short-lived JWT)
     resp.set_cookie(
         key=_cookie_name(st),
         value=jwt_token,
@@ -488,6 +495,18 @@ async def _set_cookie_on_response(
         path="/",
     )
 
+    # Refresh cookie (opaque token, longer lived)
+    resp.set_cookie(
+        key=getattr(st, "session_cookie_name", "svc_session"),
+        value=refresh_raw,
+        max_age=60 * 60 * 24 * 7,  # 7 days default
+        httponly=True,
+        secure=bool(st.session_cookie_secure),
+        samesite=same_site_lit,
+        domain=_cookie_domain(st),
+        path="/",
+    )
+
 
 def _clean_oauth_session_state(request: Request, provider: str) -> None:
     """Clean up transient OAuth session state."""
@@ -641,9 +660,18 @@ def _create_oauth_router(
         user.last_login = datetime.now(timezone.utc)
         await session.commit()
 
-        # Create response with auth cookie
+        # Create session + initial refresh token
+        raw_refresh, _rt = await issue_session_and_refresh(
+            session,
+            user_id=user.id,
+            tenant_id=getattr(user, "tenant_id", None),
+            user_agent=str(request.headers.get("user-agent", ""))[:512],
+            ip_hash=None,
+        )
+
+        # Create response with auth + refresh cookies
         resp = RedirectResponse(url=redirect_url, status_code=status.HTTP_302_FOUND)
-        await _set_cookie_on_response(resp, auth_backend, user)
+        await _set_cookie_on_response(resp, auth_backend, user, refresh_raw=raw_refresh)
 
         # Clean up session state
         _clean_oauth_session_state(request, provider)
@@ -667,44 +695,60 @@ def _create_oauth_router(
         """Refresh authentication token."""
         st = get_auth_settings()
 
-        # Read and validate cookie
-        name = _cookie_name(st)
-        raw = request.cookies.get(name)
-        if not raw:
+        # Read and validate auth JWT cookie
+        name_auth = _cookie_name(st)
+        raw_auth = request.cookies.get(name_auth)
+        if not raw_auth:
             raise HTTPException(401, "missing_token")
 
-        # Validate and decode JWT token
-        user_id = await _validate_and_decode_jwt_token(raw)
+        # Validate and decode JWT token to get user id
+        user_id = await _validate_and_decode_jwt_token(raw_auth)
 
         # Load user
         user = await session.get(user_model, user_id)
         if not user:
             raise HTTPException(401, "invalid_token")
 
-        # Handle MFA if required
-        if await policy.should_require_mfa(user):
-            pre = await get_mfa_pre_jwt_writer().write(user)
-            redirect_url = str(getattr(st, "post_login_redirect", "/"))
-            allow_hosts = parse_redirect_allow_hosts(getattr(st, "redirect_allow_hosts_raw", None))
-            require_https = bool(getattr(st, "session_cookie_secure", False))
-            _validate_redirect(redirect_url, allow_hosts, require_https=require_https)
-
-            nxt = request.query_params.get("next")
-            if nxt:
-                try:
-                    _validate_redirect(nxt, allow_hosts, require_https=require_https)
-                    redirect_url = nxt
-                except HTTPException:
-                    pass
-
-            qs = urlencode({"mfa": "required", "pre_token": pre})
-            return RedirectResponse(url=f"{redirect_url}?{qs}", status_code=status.HTTP_302_FOUND)
-
-        # Create response with new token
-        resp = Response(status_code=204)
-        await _set_cookie_on_response(resp, auth_backend, user)
-
-        # Optional: notify policy hook
+        # Obtain refresh cookie
+        refresh_cookie_name = getattr(st, "session_cookie_name", "svc_session")
+        raw_refresh = request.cookies.get(refresh_cookie_name)
+        if not raw_refresh:
+            raise HTTPException(401, "missing_refresh_token")
+
+        # Lookup refresh token row by hash
+        from sqlalchemy import select
+
+        from svc_infra.security.models import hash_refresh_token
+
+        token_hash = hash_refresh_token(raw_refresh)
+        found: RefreshToken | None = (
+            (
+                await session.execute(
+                    select(RefreshToken).where(RefreshToken.token_hash == token_hash)
+                )
+            )
+            .scalars()
+            .first()
+        )
+        if (
+            not found
+            or found.revoked_at
+            or (found.expires_at and found.expires_at < datetime.now(timezone.utc))
+        ):
+            raise HTTPException(401, "invalid_refresh_token")
+
+        # Rotate refresh token
+        try:
+            new_raw, _new_rt = await rotate_session_refresh(session, current=found)
+        except ValueError:
+            # Token expired between validation and rotation; treat as invalid
+            raise HTTPException(401, "invalid_refresh_token") from None
+
+        # Write response (204) with new cookies
+        resp = Response(status_code=status.HTTP_204_NO_CONTENT)
+        await _set_cookie_on_response(resp, auth_backend, user, refresh_raw=new_raw)
+
+        # Dead code removed: MFA branch handled earlier in login flow, refresh returns 204 above.
         if hasattr(policy, "on_token_refresh"):
             try:
                 await policy.on_token_refresh(user)
@@ -713,4 +757,5 @@ def _create_oauth_router(
 
         return resp
 
+    # Return router at end of factory
     return router

svc_infra/api/fastapi/auth/routers/session_router.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import List
+
+from fastapi import APIRouter, HTTPException
+from sqlalchemy import select
+
+from svc_infra.api.fastapi.auth.security import Identity
+from svc_infra.api.fastapi.db.sql.session import SqlSessionDep
+from svc_infra.security.models import AuthSession
+from svc_infra.security.permissions import RequirePermission
+
+
+def build_session_router() -> APIRouter:
+    router = APIRouter(prefix="/sessions", tags=["sessions"])
+
+    @router.get(
+        "/me", response_model=list[dict], dependencies=[RequirePermission("security.session.list")]
+    )
+    async def list_my_sessions(identity: Identity, session: SqlSessionDep) -> List[dict]:
+        stmt = select(AuthSession).where(AuthSession.user_id == identity.user.id)
+        rows = (await session.execute(stmt)).scalars().all()
+        return [
+            {
+                "id": str(r.id),
+                "user_agent": r.user_agent,
+                "ip_hash": r.ip_hash,
+                "revoked": bool(r.revoked_at),
+                "last_seen_at": r.last_seen_at.isoformat() if r.last_seen_at else None,
+                "created_at": r.created_at.isoformat() if r.created_at else None,
+            }
+            for r in rows
+        ]
+
+    @router.post(
+        "/{session_id}/revoke",
+        status_code=204,
+        dependencies=[RequirePermission("security.session.revoke")],
+    )
+    async def revoke_session(session_id: str, identity: Identity, db: SqlSessionDep):
+        # Load session and ensure it belongs to the user (non-admin users cannot revoke others)
+        s = await db.get(AuthSession, session_id)
+        if not s:
+            raise HTTPException(404, "session_not_found")
+        # Basic ownership check; could extend for admin bypass later
+        if s.user_id != identity.user.id:
+            raise HTTPException(403, "forbidden")
+        if s.revoked_at:
+            return  # already revoked
+        s.revoked_at = datetime.now(timezone.utc)
+        s.revoke_reason = "user_revoked"
+        # Revoke all refresh tokens for this session
+        for rt in s.refresh_tokens:
+            if not rt.revoked_at:
+                rt.revoked_at = s.revoked_at
+                rt.revoke_reason = "session_revoked"
+        await db.flush()
+
+    return router
+
+
+__all__ = ["build_session_router"]

svc_infra/api/fastapi/auth/settings.py

@@ -18,6 +18,8 @@ class OIDCProvider(BaseModel):
 class JWTSettings(BaseModel):
     secret: SecretStr
     lifetime_seconds: int = 60 * 60 * 24 * 7
+    # Optional older secrets accepted for verification during rotation window
+    old_secrets: List[SecretStr] = Field(default_factory=list)
 
 
 class PasswordClient(BaseModel):

svc_infra/api/fastapi/db/sql/users.py

@@ -12,6 +12,7 @@ from svc_infra.api.fastapi.auth.settings import get_auth_settings
 from svc_infra.api.fastapi.dual.dualize import dualize_public, dualize_user
 from svc_infra.api.fastapi.dual.router import DualAPIRouter
 from svc_infra.app.env import CURRENT_ENVIRONMENT, DEV_ENV, LOCAL_ENV
+from svc_infra.security.jwt_rotation import RotatingJWTStrategy
 
 from ...auth.security import auth_login_path
 from ...auth.sender import get_sender
@@ -94,7 +95,18 @@ def get_fastapi_users(
         lifetime = getattr(jwt_block, "lifetime_seconds", None) if jwt_block else None
         if not isinstance(lifetime, int) or lifetime <= 0:
             lifetime = 3600
-        return JWTStrategy(secret=secret, lifetime_seconds=lifetime)
+        old = []
+        if jwt_block and getattr(jwt_block, "old_secrets", None):
+            old = [s.get_secret_value() for s in jwt_block.old_secrets or []]
+        audience = "fastapi-users:auth"
+        if old:
+            return RotatingJWTStrategy(
+                secret=secret,
+                lifetime_seconds=lifetime,
+                old_secrets=old,
+                token_audience=audience,
+            )
+        return JWTStrategy(secret=secret, lifetime_seconds=lifetime, token_audience=audience)
 
     bearer_transport = BearerTransport(tokenUrl=auth_login_path)
     auth_backend = AuthenticationBackend(

svc_infra/api/fastapi/dependencies/ratelimit.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import time
+from typing import Callable
+
+from fastapi import HTTPException
+from starlette.requests import Request
+
+from svc_infra.api.fastapi.middleware.ratelimit_store import InMemoryRateLimitStore, RateLimitStore
+from svc_infra.obs.metrics import emit_rate_limited
+
+
+class RateLimiter:
+    def __init__(
+        self,
+        *,
+        limit: int,
+        window: int = 60,
+        key_fn: Callable = lambda r: "global",
+        store: RateLimitStore | None = None,
+    ):
+        self.limit = limit
+        self.window = window
+        self.key_fn = key_fn
+        self.store = store or InMemoryRateLimitStore(limit=limit)
+
+    async def __call__(self, request: Request):
+        key = self.key_fn(request)
+        count, limit, reset = self.store.incr(str(key), self.window)
+        if count > limit:
+            retry = max(0, reset - int(time.time()))
+            try:
+                emit_rate_limited(str(key), limit, retry)
+            except Exception:
+                pass
+            raise HTTPException(
+                status_code=429, detail="Rate limit exceeded", headers={"Retry-After": str(retry)}
+            )
+
+
+__all__ = ["RateLimiter"]
+
+
+def rate_limiter(
+    *,
+    limit: int,
+    window: int = 60,
+    key_fn: Callable = lambda r: "global",
+    store: RateLimitStore | None = None,
+):
+    store_ = store or InMemoryRateLimitStore(limit=limit)
+
+    async def dep(request: Request):
+        key = key_fn(request)
+        count, lim, reset = store_.incr(str(key), window)
+        if count > lim:
+            retry = max(0, reset - int(time.time()))
+            try:
+                emit_rate_limited(str(key), lim, retry)
+            except Exception:
+                pass
+            raise HTTPException(
+                status_code=429, detail="Rate limit exceeded", headers={"Retry-After": str(retry)}
+            )
+
+    return dep

svc_infra/api/fastapi/middleware/ratelimit.py

@@ -3,25 +3,41 @@ import time
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import JSONResponse
 
+from svc_infra.obs.metrics import emit_rate_limited
+
+from .ratelimit_store import InMemoryRateLimitStore, RateLimitStore
+
 
 class SimpleRateLimitMiddleware(BaseHTTPMiddleware):
-    def __init__(self, app, limit: int = 120, window: int = 60, key_fn=None):
+    def __init__(
+        self,
+        app,
+        limit: int = 120,
+        window: int = 60,
+        key_fn=None,
+        store: RateLimitStore | None = None,
+    ):
         super().__init__(app)
         self.limit, self.window = limit, window
         self.key_fn = key_fn or (lambda r: r.headers.get("X-API-Key") or r.client.host)
-        self.buckets = {}  # replace with Redis in prod
+        self.store = store or InMemoryRateLimitStore(limit=limit)
 
     async def dispatch(self, request, call_next):
         key = self.key_fn(request)
         now = int(time.time())
-        win = now - (now % self.window)
-        bucket = self.buckets.setdefault((key, win), 0)
+        # Increment counter in store
+        count, limit, reset = self.store.incr(str(key), self.window)
+        remaining = max(0, limit - count)
 
-        remaining = self.limit - bucket
-        reset = win + self.window
+        if remaining < 0:  # defensive clamp
+            remaining = 0
 
-        if remaining <= 0:
+        if count > limit:
             retry = max(0, reset - now)
+            try:
+                emit_rate_limited(str(key), limit, retry)
+            except Exception:
+                pass
             return JSONResponse(
                 status_code=429,
                 content={
@@ -31,16 +47,15 @@ class SimpleRateLimitMiddleware(BaseHTTPMiddleware):
                     "code": "RATE_LIMITED",
                 },
                 headers={
-                    "X-RateLimit-Limit": str(self.limit),
+                    "X-RateLimit-Limit": str(limit),
                     "X-RateLimit-Remaining": "0",
                     "X-RateLimit-Reset": str(reset),
                     "Retry-After": str(retry),
                 },
             )
 
-        self.buckets[(key, win)] = bucket + 1
         resp = await call_next(request)
-        resp.headers.setdefault("X-RateLimit-Limit", str(self.limit))
-        resp.headers.setdefault("X-RateLimit-Remaining", str(self.limit - (bucket + 1)))
+        resp.headers.setdefault("X-RateLimit-Limit", str(limit))
+        resp.headers.setdefault("X-RateLimit-Remaining", str(remaining))
         resp.headers.setdefault("X-RateLimit-Reset", str(reset))
         return resp

svc_infra/api/fastapi/middleware/ratelimit_store.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import time
+from typing import Optional, Protocol, Tuple
+
+
+class RateLimitStore(Protocol):
+    def incr(self, key: str, window: int) -> Tuple[int, int, int]:
+        """Increment and return (count, limit, resetEpoch).
+
+        Implementations should manage per-window buckets. The 'limit' is stored configuration.
+        """
+        ...
+
+
+class InMemoryRateLimitStore:
+    def __init__(self, limit: int = 120):
+        self.limit = limit
+        self._buckets: dict[tuple[str, int], int] = {}
+
+    def incr(self, key: str, window: int) -> Tuple[int, int, int]:
+        now = int(time.time())
+        win = now - (now % window)
+        count = self._buckets.get((key, win), 0) + 1
+        self._buckets[(key, win)] = count
+        reset = win + window
+        return count, self.limit, reset
+
+
+class RedisRateLimitStore:
+    """Fixed-window counter store using Redis.
+
+    Keys are of the form: {prefix}:{key}:{windowStart}
+    Values are incremented and expire automatically at window end.
+
+    This implementation uses atomic INCR and EXPIRE semantics. To avoid race conditions
+    on first-set expiry, we set expiry when the counter is created.
+    """
+
+    def __init__(
+        self,
+        redis_client,
+        *,
+        limit: int = 120,
+        prefix: str = "ratelimit",
+        clock: Optional[callable] = None,
+    ):
+        self.redis = redis_client
+        self.limit = limit
+        self.prefix = prefix
+        self._clock = clock or time.time
+
+    def _window_key(self, key: str, window: int) -> tuple[str, int, str]:
+        now = int(self._clock())
+        win = now - (now % window)
+        redis_key = f"{self.prefix}:{key}:{win}"
+        return redis_key, win, now
+
+    def incr(self, key: str, window: int) -> Tuple[int, int, int]:
+        rkey, win, now = self._window_key(key, window)
+        # Increment; if this is the first time we've seen this window key, set expiry to window end
+        pipe = self.redis.pipeline()
+        pipe.incr(rkey)
+        pipe.ttl(rkey)
+        count, ttl = pipe.execute()
+        if ttl == -1:  # key exists without expire or just created; set expire to end of window
+            expire_sec = (win + window) - now
+            if expire_sec <= 0:
+                expire_sec = window
+            try:
+                self.redis.expire(rkey, expire_sec)
+            except Exception:
+                pass
+        reset = win + window
+        return int(count), self.limit, reset
+
+
+__all__ = ["RateLimitStore", "InMemoryRateLimitStore", "RedisRateLimitStore"]

svc_infra/api/fastapi/middleware/request_size_limit.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import JSONResponse
+
+from svc_infra.obs.metrics import emit_suspect_payload
+
+
+class RequestSizeLimitMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app, max_bytes: int = 1_000_000):
+        super().__init__(app)
+        self.max_bytes = max_bytes
+
+    async def dispatch(self, request, call_next):
+        length = request.headers.get("content-length")
+        try:
+            size = int(length) if length is not None else None
+        except Exception:
+            size = None
+        if size is not None and size > self.max_bytes:
+            try:
+                emit_suspect_payload(
+                    getattr(request, "url", None).path if hasattr(request, "url") else None, size
+                )
+            except Exception:
+                pass
+            return JSONResponse(
+                status_code=413,
+                content={
+                    "title": "Payload Too Large",
+                    "status": 413,
+                    "detail": "Request body exceeds allowed size.",
+                    "code": "PAYLOAD_TOO_LARGE",
+                },
+            )
+        return await call_next(request)

svc_infra/api/fastapi/setup.py

@@ -61,7 +61,8 @@ def _setup_cors(app: FastAPI, public_cors_origins: list[str] | str | None = None
     elif isinstance(public_cors_origins, str):
         origins = [o.strip() for o in public_cors_origins.split(",") if o and o.strip()]
     else:
-        fallback = os.getenv("CORS_ALLOW_ORIGINS", "http://localhost:3000")
+        # Strict by default: no CORS unless explicitly configured via env or parameter.
+        fallback = os.getenv("CORS_ALLOW_ORIGINS", "")
         origins = [o.strip() for o in fallback.split(",") if o and o.strip()]
 
     if not origins:

svc_infra/obs/metrics/__init__.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+"""
+Metrics package public API.
+
+Provides lightweight, overridable hooks for abuse heuristics so callers can
+plug in logging or a metrics backend without a hard dependency.
+"""
+
+from typing import Callable, Optional
+
+# Function variables so applications/tests can replace them at runtime.
+on_rate_limit_exceeded: Callable[[str, int, int], None] | None = None
+"""
+Called when a request is rate-limited.
+Args:
+    key: identifier used for rate limiting (e.g., API key or IP)
+    limit: configured limit for the window
+    retry_after: seconds until next allowed attempt
+"""
+
+on_suspect_payload: Callable[[Optional[str], int], None] | None = None
+"""
+Called when a request exceeds the configured size limit.
+Args:
+    path: request path if available
+    size: reported content-length
+"""
+
+
+def emit_rate_limited(key: str, limit: int, retry_after: int) -> None:
+    if on_rate_limit_exceeded:
+        try:
+            on_rate_limit_exceeded(key, limit, retry_after)
+        except Exception:
+            # Never break request flow on metrics exceptions
+            pass
+
+
+def emit_suspect_payload(path: Optional[str], size: int) -> None:
+    if on_suspect_payload:
+        try:
+            on_suspect_payload(path, size)
+        except Exception:
+            pass
+
+
+__all__ = [
+    "emit_rate_limited",
+    "emit_suspect_payload",
+    "on_rate_limit_exceeded",
+    "on_suspect_payload",
+]

svc_infra/obs/metrics.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+"""
+Lightweight metrics hooks for abuse heuristics. Intentionally minimal to avoid pulling
+full metrics stacks; these are no-ops by default but can be swapped in tests or wired
+to a metrics backend by overriding the functions.
+"""
+
+from typing import Callable, Optional
+
+# Function variables so applications/tests can replace them at runtime.
+on_rate_limit_exceeded: Callable[[str, int, int], None] | None = None
+"""
+Called when a request is rate-limited.
+Args:
+    key: identifier used for rate limiting (e.g., API key or IP)
+    limit: configured limit for the window
+    retry_after: seconds until next allowed attempt
+"""
+
+on_suspect_payload: Callable[[Optional[str], int], None] | None = None
+"""
+Called when a request exceeds the configured size limit.
+Args:
+    path: request path if available
+    size: reported content-length
+"""
+
+
+def emit_rate_limited(key: str, limit: int, retry_after: int) -> None:
+    if on_rate_limit_exceeded:
+        try:
+            on_rate_limit_exceeded(key, limit, retry_after)
+        except Exception:
+            # Never break request flow on metrics exceptions
+            pass
+
+
+def emit_suspect_payload(path: Optional[str], size: int) -> None:
+    if on_suspect_payload:
+        try:
+            on_suspect_payload(path, size)
+        except Exception:
+            pass
+
+
+__all__ = [
+    "emit_rate_limited",
+    "emit_suspect_payload",
+    "on_rate_limit_exceeded",
+    "on_suspect_payload",
+]