439 lines
17 KiB
Python
Executable File
439 lines
17 KiB
Python
Executable File
#!/usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
"""
|
||
demo-system —— 一个「简单业务系统」,用来验证它与 sso 统一认证的对接。
|
||
|
||
两种接入姿势(同一份代码,靠环境变量切换):
|
||
|
||
A. 自己当 OAuth2 客户端(RP)
|
||
/login -> 跳 IdP /authorize -> /oauth2/callback 收 code -> 换 token
|
||
-> 取 userinfo -> 建本地会话 -> 展示用户。
|
||
支持两种端点风格:
|
||
- style=maxkey : /oauth/v20/authorize | /oauth/v20/token | /oauth/v20/me
|
||
(client_id/client_secret 走表单,令牌走 access_token 参数)
|
||
- style=standard : /oauth/authorize | /oauth/token | /oauth/userinfo
|
||
(Basic 认证 + Bearer 令牌)
|
||
未配置 client_secret 时自动启用 PKCE(S256),走公开客户端。
|
||
|
||
B. 前置 IAP,零改造接入
|
||
网关(nginx + sso_gateway 模块)在 access 阶段完成认证,并把身份以
|
||
X-Auth-User / X-Auth-Email / X-Auth-Groups / X-Auth-Sub / X-Auth-Token
|
||
注入请求头。业务系统不写一行 OAuth 代码,只读这几个头即可
|
||
(见 /api/me 的 source=iap 分支)。
|
||
|
||
依赖:仅 Python 3 标准库。
|
||
|
||
安全提示:B 模式下这几个头**必须**被网关覆盖,因此业务系统端口不能让客户端
|
||
直达(否则可伪造 X-Auth-User)。这里为了测试同时暴露了直连端口,生产上
|
||
请用防火墙 / 只绑 127.0.0.1 / 只监听内网接口来限制。
|
||
"""
|
||
|
||
import base64
|
||
import hashlib
|
||
import json
|
||
import os
|
||
import secrets
|
||
import sys
|
||
import urllib.error
|
||
import urllib.parse
|
||
import urllib.request
|
||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 配置
|
||
# ---------------------------------------------------------------------------
|
||
|
||
PORT = int(os.environ.get("DEMO_PORT", "18096"))
|
||
# 默认只绑回环:B 模式下应用信任 X-Auth-* 头,一旦端口直达就能伪造身份。
|
||
BIND = os.environ.get("DEMO_BIND", "127.0.0.1")
|
||
IDP = os.environ.get("DEMO_IDP_BASE", "http://127.0.0.1:18098").rstrip("/")
|
||
CLIENT_ID = os.environ.get("DEMO_CLIENT_ID", "demo-system")
|
||
CLIENT_SECRET = os.environ.get("DEMO_CLIENT_SECRET", "")
|
||
REDIRECT_URI = os.environ.get(
|
||
"DEMO_REDIRECT_URI", "http://127.0.0.1:%d/oauth2/callback" % PORT
|
||
)
|
||
# maxkey | standard
|
||
STYLE = os.environ.get("DEMO_STYLE", "maxkey").strip().lower()
|
||
# 是否信任网关注入的 X-Auth-* 头(B 模式)
|
||
TRUST_IAP = os.environ.get("DEMO_TRUST_IAP", "1") not in ("0", "", "no", "false")
|
||
SCOPE = os.environ.get("DEMO_SCOPE", "openid profile email")
|
||
|
||
SESSION_COOKIE = "demo_sess"
|
||
|
||
# 按风格选择端点(这就是「MaxKey 互通」的落点:同一套代码、只换路径与传参方式)
|
||
if STYLE == "maxkey":
|
||
EP_AUTHORIZE = IDP + "/oauth/v20/authorize"
|
||
EP_TOKEN = IDP + "/oauth/v20/token"
|
||
EP_USERINFO = IDP + "/oauth/v20/me"
|
||
else:
|
||
EP_AUTHORIZE = IDP + "/oauth/authorize"
|
||
EP_TOKEN = IDP + "/oauth/token"
|
||
EP_USERINFO = IDP + "/oauth/userinfo"
|
||
|
||
# 进程内状态(演示用:单进程单实例足够;多实例需换 Redis/共享内存)
|
||
SESSIONS = {} # sid -> {user, tokens}
|
||
PENDING = {} # state -> {verifier, redirect}
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# OAuth2 客户端逻辑
|
||
# ---------------------------------------------------------------------------
|
||
|
||
def _b64url(raw):
|
||
return base64.urlsafe_b64encode(raw).decode().rstrip("=")
|
||
|
||
|
||
def _pkce_pair():
|
||
"""PKCE(S256):verifier 43-128 字符,challenge = base64url(sha256(verifier))。"""
|
||
verifier = _b64url(secrets.token_bytes(32))
|
||
challenge = _b64url(hashlib.sha256(verifier.encode()).digest())
|
||
return verifier, challenge
|
||
|
||
|
||
def build_authorize_url(state):
|
||
"""拼授权地址。公开客户端(无 secret)自动带 PKCE。"""
|
||
params = {
|
||
"response_type": "code",
|
||
"client_id": CLIENT_ID,
|
||
"redirect_uri": REDIRECT_URI,
|
||
"scope": SCOPE,
|
||
"state": state,
|
||
}
|
||
entry = {"verifier": "", "redirect": "/"}
|
||
if not CLIENT_SECRET:
|
||
verifier, challenge = _pkce_pair()
|
||
params["code_challenge"] = challenge
|
||
params["code_challenge_method"] = "S256"
|
||
entry["verifier"] = verifier
|
||
PENDING[state] = entry
|
||
return EP_AUTHORIZE + "?" + urllib.parse.urlencode(params)
|
||
|
||
|
||
def _http(url, data=None, headers=None, method=None):
|
||
req = urllib.request.Request(
|
||
url,
|
||
data=data,
|
||
headers=headers or {},
|
||
method=method or ("POST" if data else "GET"),
|
||
)
|
||
try:
|
||
with urllib.request.urlopen(req, timeout=10) as resp:
|
||
return resp.status, resp.read().decode("utf-8", "replace")
|
||
except urllib.error.HTTPError as e:
|
||
return e.code, e.read().decode("utf-8", "replace")
|
||
|
||
|
||
def _json(text):
|
||
try:
|
||
return json.loads(text)
|
||
except Exception:
|
||
return None
|
||
|
||
|
||
def exchange_code(code, verifier):
|
||
"""用授权码换令牌。两种风格的差别全在这个函数里。"""
|
||
form = {
|
||
"grant_type": "authorization_code",
|
||
"code": code,
|
||
"redirect_uri": REDIRECT_URI,
|
||
}
|
||
headers = {"Content-Type": "application/x-www-form-urlencoded"}
|
||
if CLIENT_SECRET:
|
||
if STYLE == "maxkey":
|
||
# MaxKey 惯例:client_id/client_secret 直接放表单,不用 Basic
|
||
form["client_id"] = CLIENT_ID
|
||
form["client_secret"] = CLIENT_SECRET
|
||
else:
|
||
basic = base64.b64encode(
|
||
("%s:%s" % (CLIENT_ID, CLIENT_SECRET)).encode()
|
||
).decode()
|
||
headers["Authorization"] = "Basic " + basic
|
||
else:
|
||
form["client_id"] = CLIENT_ID
|
||
if verifier:
|
||
form["code_verifier"] = verifier
|
||
|
||
status, body = _http(
|
||
EP_TOKEN, urllib.parse.urlencode(form).encode(), headers
|
||
)
|
||
if status != 200:
|
||
raise RuntimeError("换发令牌失败 HTTP %s: %s" % (status, body[:300]))
|
||
tok = _json(body) or {}
|
||
if isinstance(tok, dict) and "data" in tok and "code" in tok:
|
||
# 标准端点 /oauth/token 用 {code,msg,data} 信封;MaxKey 的 /oauth/v20/token
|
||
# 与 OIDC 惯例都是裸对象。两种都能解析,换端点不用改代码。
|
||
tok = tok["data"] or {}
|
||
if "access_token" not in tok:
|
||
raise RuntimeError("响应中没有 access_token: %s" % body[:300])
|
||
return tok
|
||
|
||
|
||
def fetch_userinfo(access_token):
|
||
"""取用户信息。MaxKey 用 access_token 参数;标准用 Bearer 头。"""
|
||
if STYLE == "maxkey":
|
||
url = EP_USERINFO + "?" + urllib.parse.urlencode({"access_token": access_token})
|
||
status, body = _http(url)
|
||
else:
|
||
status, body = _http(
|
||
EP_USERINFO, headers={"Authorization": "Bearer " + access_token}
|
||
)
|
||
if status != 200:
|
||
raise RuntimeError("取用户信息失败 HTTP %s: %s" % (status, body[:300]))
|
||
data = _json(body)
|
||
if isinstance(data, dict) and "data" in data and "code" in data:
|
||
# sso 标准端点用 {code,msg,data} 信封;MaxKey 的 /me 是裸对象
|
||
data = data["data"]
|
||
return data or {}
|
||
|
||
|
||
def identify_from_iap(headers):
|
||
"""B 模式:从网关注入的头里取身份。"""
|
||
if not TRUST_IAP:
|
||
return None
|
||
user = (headers.get("X-Auth-User") or "").strip()
|
||
if not user:
|
||
return None
|
||
groups = (headers.get("X-Auth-Groups") or "").strip()
|
||
return {
|
||
"username": user,
|
||
"preferred_username": user,
|
||
"sub": (headers.get("X-Auth-Sub") or "").strip(),
|
||
"email": (headers.get("X-Auth-Email") or "").strip(),
|
||
"groups": [g for g in groups.split(",") if g],
|
||
"via": "iap",
|
||
}
|
||
|
||
|
||
def current_identity(handler):
|
||
"""先看 IAP 注入头(B 模式),再看本地会话(A 模式)。"""
|
||
iap = identify_from_iap({k: v for k, v in handler.headers.items()})
|
||
if iap:
|
||
return iap, None
|
||
sid = parse_cookie(handler.headers.get("Cookie"), SESSION_COOKIE)
|
||
sess = SESSIONS.get(sid) if sid else None
|
||
if sess:
|
||
return sess["user"], sess
|
||
return None, None
|
||
|
||
|
||
def parse_cookie(raw, name):
|
||
if not raw:
|
||
return None
|
||
for part in raw.split(";"):
|
||
k, _, v = part.strip().partition("=")
|
||
if k == name:
|
||
return v
|
||
return None
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 页面
|
||
# ---------------------------------------------------------------------------
|
||
|
||
PAGE = """<!doctype html>
|
||
<html lang="zh-CN"><head><meta charset="utf-8">
|
||
<title>demo-system · 简单业务系统</title>
|
||
<style>
|
||
body{{font:15px/1.7 -apple-system,BlinkMacSystemFont,"PingFang SC",sans-serif;
|
||
background:#0f1729;color:#e6edf7;margin:0;padding:40px}}
|
||
.card{{max-width:720px;margin:0 auto;background:#16233c;border:1px solid #24365c;
|
||
border-radius:14px;padding:28px 32px;box-shadow:0 8px 30px rgba(0,0,0,.3)}}
|
||
h1{{margin:0 0 4px;font-size:21px;color:#7db3ff}}
|
||
.sub{{color:#8ea3c4;font-size:13px;margin-bottom:22px}}
|
||
dl{{display:grid;grid-template-columns:150px 1fr;gap:8px 14px;margin:0}}
|
||
dt{{color:#8ea3c4}} dd{{margin:0;word-break:break-all}}
|
||
.tag{{display:inline-block;padding:2px 9px;border-radius:999px;font-size:12px;
|
||
background:#1d3a63;color:#8fc4ff;border:1px solid #2c5387}}
|
||
.tag.iap{{background:#1b3d2e;color:#7de0a8;border-color:#276b47}}
|
||
a.btn{{display:inline-block;margin-top:22px;padding:9px 18px;border-radius:9px;
|
||
background:#2b6cb0;color:#fff;text-decoration:none;font-size:14px}}
|
||
a.btn.ghost{{background:transparent;border:1px solid #2c5387;color:#8fc4ff}}
|
||
.btn + .btn{{margin-left:8px}}
|
||
.hint{{margin-top:20px;font-size:12.5px;color:#7a8dab;border-top:1px solid #223354;padding-top:14px}}
|
||
</style></head><body><div class="card">{body}</div></body></html>"""
|
||
|
||
|
||
def render_home(ident, sess):
|
||
if not ident:
|
||
body = """
|
||
<h1>demo-system</h1>
|
||
<div class="sub">未登录 · 一个用来验证统一认证对接的简单业务系统</div>
|
||
<p>方式 A(自己做 OAuth2 客户端):点下面的按钮跳转 IdP 登录。</p>
|
||
<a class="btn" href="/login">使用统一认证登录</a>
|
||
<div class="hint">方式 B(前置 IAP):经网关访问时,网关已完成认证并注入
|
||
X-Auth-User 等请求头,本系统直接读取、零 OAuth 代码。</div>
|
||
"""
|
||
else:
|
||
iap = ident.get("via") == "iap"
|
||
rows = [
|
||
("账号", ident.get("preferred_username") or ident.get("username") or "-"),
|
||
("姓名", ident.get("name") or ident.get("realname") or "-"),
|
||
("用户 ID (sub)", ident.get("sub") or "-"),
|
||
("邮箱", ident.get("email") or "-"),
|
||
("用户组", "、".join(ident.get("groups") or []) or "-"),
|
||
("部门", ident.get("department") or "-"),
|
||
]
|
||
if sess and sess.get("access_token"):
|
||
rows.append(("令牌前缀", sess["access_token"][:28] + "…"))
|
||
rows.append(("令牌类型", "%s / 有效期 %ss" % (
|
||
sess.get("token_type", "Bearer"), sess.get("expires_in", "-"))))
|
||
dl = "".join("<dt>%s</dt><dd>%s</dd>" % (k, v) for k, v in rows)
|
||
tag = ('<span class="tag iap">来源:IAP 网关注入</span>' if iap
|
||
else '<span class="tag">来源:OAuth2 授权码流程</span>')
|
||
body = """
|
||
<h1>demo-system</h1>
|
||
<div class="sub">已登录 %s</div>
|
||
<dl>%s</dl>
|
||
<a class="btn ghost" href="/api/me">查看 /api/me</a>
|
||
<a class="btn ghost" href="/api/echo">查看收到的身份头</a>
|
||
<a class="btn ghost" href="/logout">退出</a>
|
||
<div class="hint">方式 A 的令牌已换到本系统会话里;方式 B 下本系统只知道网关
|
||
注入的身份头,从不接触令牌(除非网关同时注入了 X-Auth-Token)。</div>
|
||
""" % (tag, dl)
|
||
return PAGE.format(body=body)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# HTTP 处理
|
||
# ---------------------------------------------------------------------------
|
||
|
||
class Handler(BaseHTTPRequestHandler):
|
||
server_version = "demo-system/1.0"
|
||
|
||
def log_message(self, fmt, *args):
|
||
sys.stderr.write("[demo-system] %s %s\n" % (self.address_string(), fmt % args))
|
||
|
||
# -- 响应助手 ---------------------------------------------------------
|
||
def _send(self, status, body, ctype="application/json; charset=utf-8", extra=None):
|
||
raw = body if isinstance(body, bytes) else body.encode("utf-8")
|
||
self.send_response(status)
|
||
self.send_header("Content-Type", ctype)
|
||
self.send_header("Content-Length", str(len(raw)))
|
||
for k, v in (extra or {}).items():
|
||
self.send_header(k, v)
|
||
self.end_headers()
|
||
if self.command != "HEAD":
|
||
self.wfile.write(raw)
|
||
|
||
def _json(self, status, obj, extra=None):
|
||
self._send(status, json.dumps(obj, ensure_ascii=False, indent=2), extra=extra)
|
||
|
||
def _redirect(self, loc, extra=None):
|
||
self._send(302, b"", extra=dict({"Location": loc}, **(extra or {})))
|
||
|
||
def _html(self, status, html):
|
||
self._send(status, html, "text/html; charset=utf-8")
|
||
|
||
# -- 路由 -------------------------------------------------------------
|
||
def do_GET(self):
|
||
self._route("GET")
|
||
|
||
def do_POST(self):
|
||
self._route("POST")
|
||
|
||
def do_HEAD(self):
|
||
self._route("HEAD")
|
||
|
||
def _route(self, method):
|
||
parsed = urllib.parse.urlparse(self.path)
|
||
path = parsed.path.rstrip("/") or "/"
|
||
|
||
if path == "/healthz":
|
||
return self._json(200, {"ok": True, "style": STYLE,
|
||
"idp": IDP, "client_id": CLIENT_ID})
|
||
|
||
if path == "/":
|
||
ident, sess = current_identity(self)
|
||
return self._html(200, render_home(ident, sess))
|
||
|
||
if path == "/login":
|
||
qs = urllib.parse.parse_qs(parsed.query)
|
||
state = secrets.token_urlsafe(16)
|
||
url = build_authorize_url(state)
|
||
PENDING[state]["redirect"] = (qs.get("redirect") or ["/"])[0]
|
||
return self._redirect(url)
|
||
|
||
if path in ("/oauth2/callback", "/callback"):
|
||
return self._callback(parsed)
|
||
|
||
if path == "/api/me":
|
||
ident, sess = current_identity(self)
|
||
if not ident:
|
||
return self._json(401, {"code": 401, "msg": "未登录"})
|
||
return self._json(200, {"source": ident.get("via", "oauth2"),
|
||
"user": ident,
|
||
"has_access_token": bool(sess and sess.get("access_token"))})
|
||
|
||
if path == "/api/echo":
|
||
# 把收到的请求头原样回显 —— 用来证明「网关确实注入了身份头」
|
||
interesting = {k: v for k, v in self.headers.items()
|
||
if k.lower().startswith("x-auth-") or k.lower() in ("host", "x-real-ip")}
|
||
return self._json(200, {"injected_headers": interesting})
|
||
|
||
if path == "/logout":
|
||
sid = parse_cookie(self.headers.get("Cookie"), SESSION_COOKIE)
|
||
if sid:
|
||
SESSIONS.pop(sid, None)
|
||
return self._redirect("/", {"Set-Cookie": "%s=; Path=/; Max-Age=0" % SESSION_COOKIE})
|
||
|
||
return self._json(404, {"code": 404, "msg": "接口不存在:%s" % path})
|
||
|
||
# -- 授权码回调 -------------------------------------------------------
|
||
def _callback(self, parsed):
|
||
qs = urllib.parse.parse_qs(parsed.query)
|
||
err = (qs.get("error") or [""])[0]
|
||
if err:
|
||
return self._html(400, "<h3>授权失败</h3><p>%s: %s</p>" % (
|
||
err, (qs.get("error_description") or [""])[0]))
|
||
code = (qs.get("code") or [""])[0]
|
||
state = (qs.get("state") or [""])[0]
|
||
if not code:
|
||
return self._html(400, "<h3>缺少 code</h3>")
|
||
|
||
# state 校验(防 CSRF)——同时取回 PKCE verifier
|
||
entry = PENDING.pop(state, None) if state else None
|
||
if state and entry is None:
|
||
return self._html(400, "<h3>state 不匹配</h3><p>可能的 CSRF,已拒绝。</p>")
|
||
verifier = (entry or {}).get("verifier", "")
|
||
target = (entry or {}).get("redirect", "/")
|
||
|
||
try:
|
||
tok = exchange_code(code, verifier)
|
||
user = fetch_userinfo(tok["access_token"])
|
||
except Exception as e:
|
||
return self._html(502, "<h3>对接 IdP 失败</h3><pre>%s</pre>" % e)
|
||
|
||
sid = secrets.token_urlsafe(24)
|
||
SESSIONS[sid] = {
|
||
"user": user,
|
||
"access_token": tok.get("access_token", ""),
|
||
"refresh_token": tok.get("refresh_token", ""),
|
||
"token_type": tok.get("token_type", "Bearer"),
|
||
"expires_in": tok.get("expires_in", ""),
|
||
}
|
||
return self._redirect(target, {
|
||
"Set-Cookie": "%s=%s; Path=/; HttpOnly; SameSite=Lax" % (SESSION_COOKIE, sid)
|
||
})
|
||
|
||
|
||
def main():
|
||
srv = ThreadingHTTPServer(("0.0.0.0", PORT), Handler)
|
||
sys.stderr.write(
|
||
"[demo-system] listening :%d\n"
|
||
"[demo-system] style=%s idp=%s\n"
|
||
"[demo-system] client_id=%s secret=%s pkce=%s\n"
|
||
"[demo-system] redirect_uri=%s trust_iap=%s\n"
|
||
% (PORT, STYLE, IDP, CLIENT_ID,
|
||
"已配置" if CLIENT_SECRET else "无(公开客户端)",
|
||
"否" if CLIENT_SECRET else "S256",
|
||
REDIRECT_URI, TRUST_IAP)
|
||
)
|
||
try:
|
||
srv.serve_forever()
|
||
except KeyboardInterrupt:
|
||
pass
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|