From 61d37359c405be79c15b7e7fc8192fcaee324c33 Mon Sep 17 00:00:00 2001 From: Pizza <33816021+PizzaCow@users.noreply.github.com> Date: Wed, 1 Apr 2026 16:00:18 -0600 Subject: [PATCH] feat: initial TailScan implementation --- auth.py | 196 ++++++++++++++++++++++++-------------------------------- 1 file changed, 84 insertions(+), 112 deletions(-) diff --git a/auth.py b/auth.py index 6143712..3936f9b 100644 --- a/auth.py +++ b/auth.py @@ -1,124 +1,96 @@ -""" -auth.py — Tailscale OAuth 2.0 SSO flow + session handling -""" +"""Tailscale OAuth flow + session handling.""" + import os import secrets +import time import httpx -from fastapi import APIRouter, Request, Response, HTTPException -from fastapi.responses import RedirectResponse +from itsdangerous import TimestampSigner, BadSignature, SignatureExpired -router = APIRouter() +SECRET_KEY = os.getenv("SECRET_KEY", "changeme") +SESSION_MAX_AGE = 60 * 60 * 24 * 7 # 7 days -TAILSCALE_AUTH_URL = "https://login.tailscale.com/oauth/authorize" -TAILSCALE_TOKEN_URL = "https://login.tailscale.com/oauth/token" -TAILSCALE_USERINFO_URL = "https://api.tailscale.com/api/v2/oauth/userinfo" +signer = TimestampSigner(SECRET_KEY) -CLIENT_ID = os.getenv("TS_CLIENT_ID", "") -CLIENT_SECRET = os.getenv("TS_CLIENT_SECRET", "") -BASE_URL = os.getenv("BASE_URL", "http://localhost:8080") -REDIRECT_URI = f"{BASE_URL}/auth/callback" - -# In-memory session store: session_token -> user_info dict -_sessions: dict[str, dict] = {} -# PKCE / state store -_pending_states: dict[str, str] = {} +# In-memory CSRF state store (fine for single-instance) +_csrf_states: dict[str, float] = {} -def create_session(user_info: dict) -> str: - token = secrets.token_urlsafe(32) - _sessions[token] = user_info - return token +def generate_oauth_url(client_id: str, redirect_uri: str) -> tuple[str, str]: + """Generate Tailscale OAuth URL + CSRF state.""" + state = secrets.token_urlsafe(32) + _csrf_states[state] = time.time() + # Clean old states + cutoff = time.time() - 600 + for k in list(_csrf_states.keys()): + if _csrf_states[k] < cutoff: + del _csrf_states[k] - -def get_session(request: Request) -> dict | None: - token = request.cookies.get("session") - if not token: - return None - return _sessions.get(token) - - -def require_session(request: Request) -> dict: - user = get_session(request) - if not user: - raise HTTPException(status_code=401, detail="Not authenticated") - return user - - -@router.get("/auth/login") -async def login(request: Request): - """Redirect to Tailscale OAuth authorization page.""" - state = secrets.token_urlsafe(16) - _pending_states[state] = state - params = { - "client_id": CLIENT_ID, - "redirect_uri": REDIRECT_URI, - "response_type": "code", - "scope": "openid profile email", - "state": state, - } - from urllib.parse import urlencode - url = f"{TAILSCALE_AUTH_URL}?{urlencode(params)}" - return RedirectResponse(url) - - -@router.get("/auth/callback") -async def callback(request: Request, code: str = "", state: str = "", error: str = ""): - """Handle OAuth callback from Tailscale.""" - if error: - raise HTTPException(status_code=400, detail=f"OAuth error: {error}") - if not code: - raise HTTPException(status_code=400, detail="Missing code") - if state not in _pending_states: - raise HTTPException(status_code=400, detail="Invalid state") - del _pending_states[state] - - # Exchange code for token - async with httpx.AsyncClient() as client: - token_resp = await client.post( - TAILSCALE_TOKEN_URL, - data={ - "grant_type": "authorization_code", - "code": code, - "redirect_uri": REDIRECT_URI, - "client_id": CLIENT_ID, - "client_secret": CLIENT_SECRET, - }, - headers={"Accept": "application/json"}, - ) - if token_resp.status_code != 200: - raise HTTPException(status_code=400, detail=f"Token exchange failed: {token_resp.text}") - token_data = token_resp.json() - access_token = token_data.get("access_token", "") - - # Fetch user info - userinfo_resp = await client.get( - TAILSCALE_USERINFO_URL, - headers={"Authorization": f"Bearer {access_token}"}, - ) - if userinfo_resp.status_code != 200: - # Fallback: store minimal info - user_info = {"sub": "unknown", "access_token": access_token} - else: - user_info = userinfo_resp.json() - user_info["access_token"] = access_token - - session_token = create_session(user_info) - response = RedirectResponse(url="/") - response.set_cookie( - "session", - session_token, - httponly=True, - samesite="lax", - max_age=86400 * 7, # 7 days + url = ( + f"https://login.tailscale.com/oauth/authorize" + f"?client_id={client_id}" + f"&response_type=code" + f"&redirect_uri={redirect_uri}" + f"&scope=openid+profile+email" + f"&state={state}" ) - return response + return url, state -@router.get("/auth/logout") -async def logout(request: Request, response: Response): - token = request.cookies.get("session") - if token and token in _sessions: - del _sessions[token] - r = RedirectResponse(url="/") - r.delete_cookie("session") - return r +def validate_csrf_state(state: str) -> bool: + """Validate and consume CSRF state.""" + if state not in _csrf_states: + return False + age = time.time() - _csrf_states.pop(state) + return age < 600 # 10 min expiry + + +def exchange_code(client_id: str, client_secret: str, code: str, redirect_uri: str) -> dict: + """Exchange OAuth code for tokens.""" + resp = httpx.post( + "https://api.tailscale.com/api/v2/oauth/token", + data={ + "grant_type": "authorization_code", + "code": code, + "redirect_uri": redirect_uri, + "client_id": client_id, + "client_secret": client_secret, + }, + timeout=15, + ) + resp.raise_for_status() + return resp.json() + + +def get_userinfo(access_token: str) -> dict: + """Get user info from Tailscale.""" + resp = httpx.get( + "https://api.tailscale.com/api/v2/userinfo", + headers={"Authorization": f"Bearer {access_token}"}, + timeout=10, + ) + resp.raise_for_status() + return resp.json() + + +def make_session_cookie(user_info: dict, access_token: str) -> str: + """Create a signed session cookie value.""" + import json, base64 + payload = json.dumps({ + "sub": user_info.get("sub", ""), + "name": user_info.get("name", ""), + "email": user_info.get("email", ""), + "token": access_token, + }) + encoded = base64.urlsafe_b64encode(payload.encode()).decode() + return signer.sign(encoded).decode() + + +def decode_session_cookie(cookie: str) -> dict | None: + """Decode and validate session cookie. Returns user dict or None.""" + try: + unsigned = signer.unsign(cookie, max_age=SESSION_MAX_AGE) + import json, base64 + payload = json.loads(base64.urlsafe_b64decode(unsigned).decode()) + return payload + except (BadSignature, SignatureExpired, Exception): + return None