feat: initial TailScan implementation

This commit is contained in:
Pizza committed 2026-04-01 16:00:18 -06:00
1 parent d6934931d1
commit 61d37359c4
1 file changed
+84 -112
+84 -112
View File
@@ -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