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

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

@@ -10,9 +10,9 @@ from urllib.parse import urlencode, urlparse
 import jwt
 from authlib.integrations.base_client.errors import OAuthError
 from authlib.integrations.starlette_client import OAuth
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, Depends, HTTPException, Request
 from fastapi.responses import RedirectResponse
-from fastapi_users.authentication import AuthenticationBackend
+from fastapi_users.authentication import AuthenticationBackend, Strategy
 from fastapi_users.password import PasswordHelper
 from sqlalchemy import select
 from starlette import status
@@ -20,7 +20,10 @@ from starlette.responses import Response
 
 from svc_infra.api.fastapi.auth.mfa.pre_auth import get_mfa_pre_jwt_writer
 from svc_infra.api.fastapi.auth.policy import AuthPolicy, DefaultAuthPolicy
-from svc_infra.api.fastapi.auth.settings import get_auth_settings, parse_redirect_allow_hosts
+from svc_infra.api.fastapi.auth.settings import (
+    get_auth_settings,
+    parse_redirect_allow_hosts,
+)
 from svc_infra.api.fastapi.db.sql.session import SqlSessionDep
 from svc_infra.api.fastapi.dual.public import public_router
 from svc_infra.api.fastapi.paths.auth import (
@@ -28,6 +31,7 @@ from svc_infra.api.fastapi.paths.auth import (
     OAUTH_LOGIN_PATH,
     OAUTH_REFRESH_PATH,
 )
+from svc_infra.app.env import require_secret
 from svc_infra.security.models import RefreshToken
 from svc_infra.security.session import issue_session_and_refresh, rotate_session_refresh
 
@@ -40,14 +44,19 @@ def _gen_pkce_pair() -> tuple[str, str]:
     return verifier, challenge
 
 
-def _validate_redirect(url: str, allow_hosts: list[str], *, require_https: bool) -> None:
+def _validate_redirect(
+    url: str, allow_hosts: list[str], *, require_https: bool
+) -> None:
     """Validate that a redirect URL is allowed and secure."""
     p = urlparse(url)
     if not p.netloc:
         return
-    host_port = p.hostname.lower() + (f":{p.port}" if p.port else "")
+    if not p.hostname:
+        raise HTTPException(400, "redirect_not_allowed")
+    hostname = p.hostname
+    host_port = hostname.lower() + (f":{p.port}" if p.port else "")
     allowed = {h.lower() for h in allow_hosts}
-    if host_port not in allowed and p.hostname.lower() not in allowed:
+    if host_port not in allowed and hostname.lower() not in allowed:
         raise HTTPException(400, "redirect_not_allowed")
     if require_https and p.scheme != "https":
         raise HTTPException(400, "https_required")
@@ -77,7 +86,11 @@ def _coerce_expires_at(token: dict | None) -> datetime | None:
 def _cookie_name(st) -> str:
     """Get the cookie name with appropriate security prefix."""
     name = getattr(st, "auth_cookie_name", "svc_auth")
-    if st.session_cookie_secure and not st.session_cookie_domain and not name.startswith("__Host-"):
+    if (
+        st.session_cookie_secure
+        and not st.session_cookie_domain
+        and not name.startswith("__Host-")
+    ):
         name = "__Host-" + name
     return name
 
@@ -88,7 +101,9 @@ def _cookie_domain(st):
     return d or None
 
 
-def _register_oauth_providers(oauth: OAuth, providers: Dict[str, Dict[str, Any]]) -> None:
+def _register_oauth_providers(
+    oauth: OAuth, providers: Dict[str, Dict[str, Any]]
+) -> None:
     """Register all OAuth providers with the OAuth client."""
     for name, cfg in providers.items():
         kind = cfg.get("kind")
@@ -187,7 +202,9 @@ async def _extract_user_info_github(
     """Extract user information from GitHub provider."""
     u = (await client.get("user", token=token)).json()
     emails_resp = (await client.get("user/emails", token=token)).json()
-    primary = next((e for e in emails_resp if e.get("primary") and e.get("verified")), None)
+    primary = next(
+        (e for e in emails_resp if e.get("primary") and e.get("verified")), None
+    )
 
     if not primary:
         raise HTTPException(400, "unverified_email")
@@ -195,7 +212,9 @@ async def _extract_user_info_github(
     email = primary["email"]
     email_verified = True
     full_name = u.get("name") or u.get("login")
-    provider_user_id = str(u.get("id")) if isinstance(u, dict) and u.get("id") is not None else None
+    provider_user_id = (
+        str(u.get("id")) if isinstance(u, dict) and u.get("id") is not None else None
+    )
 
     return email, full_name, provider_user_id, email_verified, {"user": u}
 
@@ -210,7 +229,9 @@ async def _extract_user_info_linkedin(
     )
 
     em = (
-        await client.get("emailAddress?q=members&projection=(elements*(handle~))", token=token)
+        await client.get(
+            "emailAddress?q=members&projection=(elements*(handle~))", token=token
+        )
     ).json()
 
     email = None
@@ -249,9 +270,15 @@ async def _extract_user_info_from_provider(
         raise HTTPException(400, "Unsupported provider kind")
 
 
-async def _find_or_create_user(session, user_model, email: str, full_name: str | None) -> Any:
+async def _find_or_create_user(
+    session, user_model, email: str, full_name: str | None
+) -> Any:
     """Find existing user by email or create a new one."""
-    existing = (await session.execute(select(user_model).filter_by(email=email))).scalars().first()
+    existing = (
+        (await session.execute(select(user_model).filter_by(email=email)))
+        .scalars()
+        .first()
+    )
 
     if existing:
         return existing
@@ -263,11 +290,14 @@ async def _find_or_create_user(session, user_model, email: str, full_name: str |
         is_verified=True,
     )
 
-    # Set hashed password for OAuth users
+    # Set hashed password for OAuth users - use cryptographically random password
+    # OAuth users authenticate via provider, not password, so this is never used
+    # but must be unpredictable to prevent password-based login attacks
+    random_password = secrets.token_urlsafe(32)
     if hasattr(user, "hashed_password"):
-        user.hashed_password = PasswordHelper().hash("!oauth!")
+        user.hashed_password = PasswordHelper().hash(random_password)
     elif hasattr(user, "password_hash"):
-        user.password_hash = PasswordHelper().hash("!oauth!")
+        user.password_hash = PasswordHelper().hash(random_password)
 
     if full_name and hasattr(user, "full_name"):
         setattr(user, "full_name", full_name)
@@ -354,10 +384,18 @@ async def _update_provider_account(
     else:
         # Update existing link if values have changed
         dirty = False
-        if hasattr(link, "access_token") and access_token and link.access_token != access_token:
+        if (
+            hasattr(link, "access_token")
+            and access_token
+            and link.access_token != access_token
+        ):
             link.access_token = access_token
             dirty = True
-        if hasattr(link, "refresh_token") and refresh_token and link.refresh_token != refresh_token:
+        if (
+            hasattr(link, "refresh_token")
+            and refresh_token
+            and link.refresh_token != refresh_token
+        ):
             link.refresh_token = refresh_token
             dirty = True
         if hasattr(link, "expires_at") and expires_at and link.expires_at != expires_at:
@@ -370,19 +408,24 @@ async def _update_provider_account(
             await session.flush()
 
 
-def _determine_final_redirect_url(request: Request, provider: str, post_login_redirect: str) -> str:
+def _determine_final_redirect_url(
+    request: Request, provider: str, post_login_redirect: str
+) -> str:
     """Determine the final redirect URL after successful authentication."""
     st = get_auth_settings()
-    redirect_url = str(
-        getattr(st, "post_login_redirect", post_login_redirect) or post_login_redirect
+    # Prioritize the parameter passed to the router over settings
+    redirect_url = str(post_login_redirect or getattr(st, "post_login_redirect", "/"))
+    allow_hosts = parse_redirect_allow_hosts(
+        getattr(st, "redirect_allow_hosts_raw", None)
     )
-    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)
 
     # Prefer ?next or the stashed value from /login
-    nxt = request.query_params.get("next") or request.session.pop(f"oauth:{provider}:next", None)
+    nxt = request.query_params.get("next") or request.session.pop(
+        f"oauth:{provider}:next", None
+    )
     if nxt:
         try:
             _validate_redirect(nxt, allow_hosts, require_https=require_https)
@@ -393,7 +436,9 @@ def _determine_final_redirect_url(request: Request, provider: str, post_login_re
     return redirect_url
 
 
-async def _validate_oauth_state(request: Request, provider: str) -> tuple[str | None, str | None]:
+async def _validate_oauth_state(
+    request: Request, provider: str
+) -> tuple[str | None, str | None]:
     """Validate OAuth state and extract session values."""
     provided_state = request.query_params.get("state")
     expected_state = request.session.pop(f"oauth:{provider}:state", None)
@@ -406,7 +451,9 @@ async def _validate_oauth_state(request: Request, provider: str) -> tuple[str |
     return verifier, nonce
 
 
-async def _exchange_code_for_token(client, request: Request, verifier: str | None, provider: str):
+async def _exchange_code_for_token(
+    client, request: Request, verifier: str | None, provider: str
+):
     """Exchange OAuth authorization code for access token."""
     try:
         return await client.authorize_access_token(request, code_verifier=verifier)
@@ -437,7 +484,13 @@ async def _process_user_authentication(
 
     # Ensure provider link exists
     await _update_provider_account(
-        session, provider_account_model, user, provider, provider_user_id, token, raw_claims
+        session,
+        provider_account_model,
+        user,
+        provider,
+        provider_user_id,
+        token,
+        raw_claims,
     )
 
     return user
@@ -446,11 +499,18 @@ async def _process_user_authentication(
 async def _validate_and_decode_jwt_token(raw_token: str) -> str:
     """Validate and decode JWT token to extract user ID."""
     st = get_auth_settings()
-    secret = (
-        st.jwt.secret.get_secret_value()
-        if getattr(st, "jwt", None) and getattr(st.jwt, "secret", None)
-        else "dev-change-me"
+    jwt_settings = getattr(st, "jwt", None)
+    jwt_secret = (
+        getattr(jwt_settings, "secret", None) if jwt_settings is not None else None
     )
+    if jwt_secret:
+        secret = jwt_secret.get_secret_value()
+    else:
+        secret = require_secret(
+            None,
+            "JWT_SECRET (via auth settings jwt.secret for token validation)",
+            dev_default="dev-only-jwt-validation-secret-not-for-production",
+        )
 
     try:
         payload = jwt.decode(
@@ -462,26 +522,29 @@ async def _validate_and_decode_jwt_token(raw_token: str) -> str:
         user_id = payload.get("sub")
         if not user_id:
             raise HTTPException(401, "invalid_token")
-        return user_id
+        return cast(str, user_id)
     except Exception:
         raise HTTPException(401, "invalid_token")
 
 
 async def _set_cookie_on_response(
     resp: Response,
-    auth_backend: AuthenticationBackend,
+    strategy: Strategy[Any, Any],
     user: Any,
     *,
     refresh_raw: str,
 ) -> None:
     """Set authentication (JWT) and refresh cookies on response."""
     st = get_auth_settings()
-    strategy = auth_backend.get_strategy()
     jwt_token = await strategy.write_token(user)
 
-    same_site_lit = cast(Literal["lax", "strict", "none"], str(st.session_cookie_samesite).lower())
+    same_site_lit = cast(
+        Literal["lax", "strict", "none"], str(st.session_cookie_samesite).lower()
+    )
     if same_site_lit == "none" and not bool(st.session_cookie_secure):
-        raise HTTPException(500, "session_cookie_samesite=None requires session_cookie_secure=True")
+        raise HTTPException(
+            500, "session_cookie_samesite=None requires session_cookie_secure=True"
+        )
 
     # Access/Auth cookie (short-lived JWT)
     resp.set_cookie(
@@ -523,7 +586,9 @@ async def _handle_mfa_redirect(
 
     pre = await get_mfa_pre_jwt_writer().write(user)
     qs = urlencode({"mfa": "required", "pre_token": pre})
-    return RedirectResponse(url=f"{redirect_url}?{qs}", status_code=status.HTTP_302_FOUND)
+    return RedirectResponse(
+        url=f"{redirect_url}?{qs}", status_code=status.HTTP_302_FOUND
+    )
 
 
 def oauth_router_with_backend(
@@ -600,7 +665,12 @@ def _create_oauth_router(
         responses={302: {"description": "Redirect to app (or MFA redirect)."}},
         description="OAuth callback endpoint.",
     )
-    async def oauth_callback(request: Request, provider: str, session: SqlSessionDep):
+    async def oauth_callback(
+        request: Request,
+        provider: str,
+        session: SqlSessionDep,
+        strategy: Strategy[Any, Any] = Depends(auth_backend.get_strategy),
+    ):
         """Handle OAuth callback and complete authentication."""
         # Handle provider-side errors up front
         if err := request.query_params.get("error"):
@@ -621,14 +691,22 @@ def _create_oauth_router(
 
         # Extract user information from provider
         cfg = providers.get(provider, {})
-        email, full_name, provider_user_id, email_verified, raw_claims = (
-            await _extract_user_info_from_provider(request, client, token, provider, cfg, nonce)
+        (
+            email,
+            full_name,
+            provider_user_id,
+            email_verified,
+            raw_claims,
+        ) = await _extract_user_info_from_provider(
+            request, client, token, provider, cfg, nonce
         )
 
         if email_verified is False:
             raise HTTPException(400, "unverified_email")
         if not email:
             raise HTTPException(400, "No email from provider")
+        if not provider_user_id:
+            raise HTTPException(400, "No user ID from provider")
 
         # Process user authentication
         user = await _process_user_authentication(
@@ -648,7 +726,9 @@ def _create_oauth_router(
             raise HTTPException(401, "account_disabled")
 
         # Determine final redirect URL
-        redirect_url = _determine_final_redirect_url(request, provider, post_login_redirect)
+        redirect_url = _determine_final_redirect_url(
+            request, provider, post_login_redirect
+        )
 
         # Handle MFA if required (do NOT set last_login yet; do it after MFA)
         mfa_response = await _handle_mfa_redirect(policy, user, redirect_url)
@@ -669,9 +749,24 @@ def _create_oauth_router(
             ip_hash=None,
         )
 
-        # Create response with auth + refresh cookies
+        # Generate JWT token for the response
+        jwt_token = await strategy.write_token(user)
+
+        # If redirecting to a different origin, append token as URL fragment for frontend to extract
+        # This handles cross-port scenarios like localhost:8000 -> localhost:3000
+        parsed_redirect = urlparse(redirect_url)
+        request_origin = f"{request.url.scheme}://{request.url.netloc}"
+        redirect_origin = f"{parsed_redirect.scheme}://{parsed_redirect.netloc}"
+
+        if redirect_origin and redirect_origin != request_origin:
+            # Cross-origin redirect: append token as URL fragment
+            # Fragment is not sent to server, only accessible to client-side JS
+            separator = "#" if not parsed_redirect.fragment else "&"
+            redirect_url = f"{redirect_url}{separator}access_token={jwt_token}"
+
+        # Create response with auth + refresh cookies (for same-origin requests)
         resp = RedirectResponse(url=redirect_url, status_code=status.HTTP_302_FOUND)
-        await _set_cookie_on_response(resp, auth_backend, user, refresh_raw=raw_refresh)
+        await _set_cookie_on_response(resp, strategy, user, refresh_raw=raw_refresh)
 
         # Clean up session state
         _clean_oauth_session_state(request, provider)
@@ -691,7 +786,11 @@ def _create_oauth_router(
         responses={204: {"description": "Cookie refreshed"}},
         description="Refresh authentication token.",
     )
-    async def refresh(request: Request, session: SqlSessionDep):
+    async def refresh(
+        request: Request,
+        session: SqlSessionDep,
+        strategy: Strategy[Any, Any] = Depends(auth_backend.get_strategy),
+    ):
         """Refresh authentication token."""
         st = get_auth_settings()
 
@@ -705,7 +804,7 @@ def _create_oauth_router(
         user_id = await _validate_and_decode_jwt_token(raw_auth)
 
         # Load user
-        user = await session.get(user_model, user_id)
+        user = await cast(Any, session).get(user_model, user_id)
         if not user:
             raise HTTPException(401, "invalid_token")
 
@@ -738,17 +837,12 @@ def _create_oauth_router(
             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
+        new_raw, _new_rt = await rotate_session_refresh(session, current=found)
 
         # 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.
+        await _set_cookie_on_response(resp, strategy, user, refresh_raw=new_raw)
+        # Policy hook: trigger after successful rotation; suppress hook errors
         if hasattr(policy, "on_token_refresh"):
             try:
                 await policy.on_token_refresh(user)

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

@@ -16,9 +16,13 @@ def build_session_router() -> APIRouter:
     router = APIRouter(prefix="/sessions", tags=["sessions"])
 
     @router.get(
-        "/me", response_model=list[dict], dependencies=[RequirePermission("security.session.list")]
+        "/me",
+        response_model=list[dict],
+        dependencies=[RequirePermission("security.session.list")],
     )
-    async def list_my_sessions(identity: Identity, session: SqlSessionDep) -> List[dict]:
+    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 [

svc_infra/api/fastapi/auth/security.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from datetime import datetime, timezone
-from typing import Annotated, Any, Callable, Optional
+from typing import Annotated, Any, Callable, Optional, cast
 
 from fastapi import Depends, HTTPException, Request
 from fastapi.security import APIKeyCookie, APIKeyHeader, OAuth2PasswordBearer
@@ -16,8 +16,12 @@ from svc_infra.db.sql.apikey import get_apikey_model
 
 # ---------- OpenAPI security schemes (appear in docs) ----------
 auth_login_path = USER_PREFIX + LOGIN_PATH
-oauth2_scheme_optional = OAuth2PasswordBearer(tokenUrl=auth_login_path, auto_error=False)
-cookie_auth_optional = APIKeyCookie(name=get_auth_settings().auth_cookie_name, auto_error=False)
+oauth2_scheme_optional = OAuth2PasswordBearer(
+    tokenUrl=auth_login_path, auto_error=False
+)
+cookie_auth_optional = APIKeyCookie(
+    name=get_auth_settings().auth_cookie_name, auto_error=False
+)
 api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
 
 
@@ -26,7 +30,12 @@ class Principal:
     """Unified identity: user via JWT/cookie or service via API key."""
 
     def __init__(
-        self, *, user=None, scopes: list[str] | None = None, via: str = "jwt", api_key=None
+        self,
+        *,
+        user=None,
+        scopes: list[str] | None = None,
+        via: str = "jwt",
+        api_key=None,
     ):
         self.user = user
         self.scopes = scopes or []
@@ -51,7 +60,11 @@ async def resolve_api_key(
     apikey = None
     if prefix:
         apikey = (
-            (await session.execute(select(ApiKey).where(ApiKey.key_prefix == prefix)))
+            (
+                await session.execute(
+                    select(ApiKey).where(ApiKey.key_prefix == prefix)  # type: ignore[attr-defined]
+                )
+            )
             .scalars()
             .first()
         )
@@ -69,7 +82,9 @@ async def resolve_api_key(
 
     apikey.mark_used()
     await session.flush()
-    return Principal(user=apikey.user, scopes=apikey.scopes, via="api_key", api_key=apikey)
+    return Principal(
+        user=apikey.user, scopes=apikey.scopes, via="api_key", api_key=apikey
+    )
 
 
 async def resolve_bearer_or_cookie_principal(
@@ -77,7 +92,11 @@ async def resolve_bearer_or_cookie_principal(
 ) -> Optional[Principal]:
     st = get_auth_settings()
     raw_auth = (request.headers.get("authorization") or "").strip()
-    token = raw_auth.split(" ", 1)[1].strip() if raw_auth.lower().startswith("bearer ") else ""
+    token = (
+        raw_auth.split(" ", 1)[1].strip()
+        if raw_auth.lower().startswith("bearer ")
+        else ""
+    )
     if not token:
         token = (request.cookies.get(st.auth_cookie_name) or "").strip()
     if not token:
@@ -89,7 +108,7 @@ async def resolve_bearer_or_cookie_principal(
     from fastapi_users.manager import BaseUserManager, UUIDIDMixin
     from fastapi_users_db_sqlalchemy import SQLAlchemyUserDatabase
 
-    user_db = SQLAlchemyUserDatabase(session, UserModel)
+    user_db: Any = SQLAlchemyUserDatabase(session, UserModel)
 
     class _ShimManager(UUIDIDMixin, BaseUserManager[Any, Any]):
         reset_password_token_secret = "unused"
@@ -107,7 +126,7 @@ async def resolve_bearer_or_cookie_principal(
     if not user:
         return None
 
-    db_user = await session.get(UserModel, user.id)
+    db_user = await cast(Any, session).get(UserModel, user.id)
     if not db_user:
         return None
     if not getattr(db_user, "is_active", True):
@@ -154,7 +173,9 @@ AllowIdentity = Depends(_optional_principal)  # same, but optional
 # ---------- DX: small guard factories ----------
 def RequireRoles(*roles: str, resolver: Callable[[Any], list[str]] | None = None):
     async def _guard(p: Identity):
-        have = set((resolver(p.user) if resolver else getattr(p.user, "roles", []) or []))
+        have = set(
+            (resolver(p.user) if resolver else getattr(p.user, "roles", []) or [])
+        )
         if not set(roles).issubset(have):
             raise HTTPException(403, "forbidden")
         return p

svc_infra/api/fastapi/auth/sender.py

@@ -20,7 +20,9 @@ class ConsoleSender:
 
 
 class SMTPSender:
-    def __init__(self, host: str, port: int, username: str, password: str, from_addr: str) -> None:
+    def __init__(
+        self, host: str, port: int, username: str, password: str, from_addr: str
+    ) -> None:
         self.host = host
         self.port = port
         self.username = username
@@ -59,4 +61,9 @@ def get_sender() -> Sender:
     if not configured:
         return ConsoleSender()
 
+    # At this point, all values must be set
+    assert host is not None
+    assert user is not None
+    assert pw is not None
+    assert frm is not None
     return SMTPSender(host, st.smtp_port, user, pw, frm)

svc_infra/api/fastapi/auth/state.py

@@ -19,7 +19,9 @@ def set_auth_state(
 
 def get_auth_state() -> tuple[type, Callable[[], Any], str]:
     if _UserModel is None or _GetStrategy is None:
-        raise RuntimeError("Auth state not initialized; call set_auth_state() in add_auth_users().")
+        raise RuntimeError(
+            "Auth state not initialized; call set_auth_state() in add_auth_users()."
+        )
     return _UserModel, _GetStrategy, _AuthPrefix