128 lines
5.8 KiB
Python
128 lines
5.8 KiB
Python
import asyncio
|
|
import hashlib
|
|
import hmac
|
|
import secrets
|
|
import time
|
|
from dataclasses import dataclass
|
|
from urllib.parse import urlencode
|
|
|
|
from fastapi import APIRouter, HTTPException, Request
|
|
from fastapi.responses import HTMLResponse, JSONResponse
|
|
from pydantic import BaseModel, Field
|
|
from .common import no_cache, peer, rate_limit
|
|
from .platform import PlatformError
|
|
|
|
|
|
@dataclass
|
|
class Transaction:
|
|
secret_hash: str
|
|
expires: float
|
|
status: str = "waiting"
|
|
result: dict | None = None
|
|
|
|
|
|
class Empty(BaseModel):
|
|
pass
|
|
|
|
|
|
class Refresh(BaseModel):
|
|
refresh_token: str = Field(min_length=1, max_length=4096)
|
|
|
|
|
|
class OAuth:
|
|
"""A single connector process owns transactions and tokens in memory only."""
|
|
def __init__(self, settings, redis, platform):
|
|
self.settings, self.redis, self.platform = settings, redis, platform
|
|
self.pending: dict[str, Transaction] = {}
|
|
self.lock = asyncio.Lock()
|
|
self.router = APIRouter()
|
|
self.router.add_api_route("/oauth/start", self.start, methods=["POST"], status_code=201)
|
|
self.router.add_api_route("/oauth/cb", self.callback, methods=["GET"])
|
|
self.router.add_api_route("/oauth/claim", self.claim, methods=["GET"])
|
|
self.router.add_api_route("/oauth/pending", self.status, methods=["GET"])
|
|
self.router.add_api_route("/oauth/refresh", self.refresh, methods=["POST"])
|
|
|
|
def prune(self):
|
|
now = time.monotonic()
|
|
for state in list(self.pending):
|
|
if self.pending[state].expires <= now:
|
|
del self.pending[state]
|
|
|
|
def authenticated(self, state, secret):
|
|
self.prune()
|
|
item = self.pending.get(state)
|
|
digest = hashlib.sha256((secret or "").encode()).hexdigest()
|
|
if not item or not hmac.compare_digest(item.secret_hash, digest):
|
|
raise HTTPException(404, "transaction not found")
|
|
return item
|
|
|
|
async def start(self, body: Empty, request: Request):
|
|
if not self.settings.feishu_enabled:
|
|
raise HTTPException(503, "platform disabled")
|
|
await rate_limit(self.redis, "oauth:start:" + peer(request), 20)
|
|
async with self.lock:
|
|
self.prune()
|
|
if len(self.pending) >= self.settings.max_pending:
|
|
raise HTTPException(503, "too many pending transactions")
|
|
state, secret = secrets.token_urlsafe(32), secrets.token_urlsafe(32)
|
|
self.pending[state] = Transaction(hashlib.sha256(secret.encode()).hexdigest(), time.monotonic() + 600)
|
|
redirect = self.settings.public_url.rstrip("/") + "/oauth/cb"
|
|
url = self.settings.feishu_authorize_url + "?" + urlencode({"app_id": self.settings.feishu_app_id,
|
|
"redirect_uri": redirect, "state": state})
|
|
return no_cache(JSONResponse({"state": state, "claim_secret": secret, "authorization_url": url,
|
|
"redirect_uri": redirect, "expires_in": 600,
|
|
"code_ttl": 60, "poll_interval": 2}, status_code=201))
|
|
|
|
async def callback(self, request: Request, state: str = "", code: str = ""):
|
|
await rate_limit(self.redis, "oauth:cb:" + peer(request))
|
|
async with self.lock:
|
|
self.prune()
|
|
item = self.pending.get(state)
|
|
if not code or len(code) > 4096 or not item or item.status != "waiting":
|
|
raise HTTPException(400, "invalid callback")
|
|
item.status = "exchanging"
|
|
try:
|
|
result = await self.platform.exchange(code)
|
|
except PlatformError:
|
|
async with self.lock:
|
|
item.status = "failed"
|
|
raise HTTPException(502, "authorization exchange failed") from None
|
|
async with self.lock:
|
|
if state not in self.pending or item.expires <= time.monotonic():
|
|
self.pending.pop(state, None)
|
|
raise HTTPException(400, "authorization expired")
|
|
item.result, item.status = result, "ready"
|
|
return no_cache(HTMLResponse("<meta charset='utf-8'><p>授权完成,请返回客户端。</p>"))
|
|
|
|
async def claim(self, request: Request, state: str):
|
|
await rate_limit(self.redis, "oauth:claim:" + peer(request))
|
|
async with self.lock:
|
|
item = self.authenticated(state, request.headers.get("X-OAuth-Claim-Secret"))
|
|
if item.status == "failed":
|
|
del self.pending[state]
|
|
raise HTTPException(502, "authorization failed")
|
|
if item.status != "ready":
|
|
return no_cache(JSONResponse({"status": "waiting", "retry_after": 2}, status_code=202))
|
|
del self.pending[state]
|
|
return no_cache(JSONResponse({"status": "claimed", **item.result}))
|
|
|
|
async def status(self, request: Request, state: str):
|
|
await rate_limit(self.redis, "oauth:pending:" + peer(request))
|
|
async with self.lock:
|
|
item = self.authenticated(state, request.headers.get("X-OAuth-Claim-Secret"))
|
|
return no_cache(JSONResponse({"status": item.status}))
|
|
|
|
async def refresh(self, body: Refresh, request: Request):
|
|
if not self.settings.feishu_enabled:
|
|
raise HTTPException(503, "platform disabled")
|
|
await rate_limit(self.redis, "oauth:refresh:" + peer(request), 20)
|
|
# Lock and consume before the upstream call; ambiguous failures never retry an old refresh token.
|
|
digest = hashlib.sha256(body.refresh_token.encode()).hexdigest()
|
|
if not await self.redis.set("hn:refresh:" + digest, "used", nx=True, ex=2592000):
|
|
raise HTTPException(409, "refresh already attempted; use returned token or reauthorize")
|
|
try:
|
|
result = await self.platform.refresh(body.refresh_token)
|
|
except PlatformError:
|
|
raise HTTPException(502, "refresh failed; reauthorize") from None
|
|
return no_cache(JSONResponse(result))
|