@autional/shared 0.0.0-stage → 0.1.0-rc.33

package/src/auth/oauth-client-id-store.ts

@@ -0,0 +1,41 @@
+/**
+ * OAuth client_id 持久化（TASK-09 / D8）。
+ *
+ * 门户的 client_id 平时由 slug 实时解析（`oauth-client-from-slug.ts`）或 env 固定；
+ * 但刷新（`AuthService.refreshToken`）与登出吊销（`AuthService.logout`）不在 React
+ * 上下文里，拿不到 slug 解析结果 —— 故 OAuth 交棒时把已解析的 client_id 落 localStorage，
+ * 两处按「会话值（持久化）→ env → 空」顺序读取（`resolveClientIdForSession`）。
+ *
+ * 该值属于「本部署用哪个 OAuth 客户端」，非用户私有数据 ⇒ 登出不清除。
+ */
+
+const STORAGE_KEY = 'oauth_client_id';
+
+/** OAuth 交棒（PKCE 发起 / 回调兑换成功）时落库 */
+export function persistOAuthClientId(clientId: string): void {
+	if (typeof window === 'undefined' || !clientId) return;
+	try {
+		localStorage.setItem(STORAGE_KEY, clientId);
+	} catch {
+		/* 存储不可用（隐私模式）时静默：刷新回落 env，行为与接线前一致 */
+	}
+}
+
+export function getPersistedOAuthClientId(): string {
+	if (typeof window === 'undefined') return '';
+	try {
+		return localStorage.getItem(STORAGE_KEY) || '';
+	} catch {
+		return '';
+	}
+}
+
+/** 刷新/登出用：会话内已解析值优先，env 兜底 */
+export function resolveClientIdForSession(): string {
+	const persisted = getPersistedOAuthClientId();
+	if (persisted) return persisted;
+	if (typeof window !== 'undefined') {
+		return (window as any).__APP_CONFIG__?.VITE_OAUTH_CLIENT_ID || '';
+	}
+	return '';
+}

package/src/auth/oauth-login.ts

@@ -0,0 +1,388 @@
+/**
+ * Dev-mode OAuth PKCE login utilities
+ *
+ * Used by RequireAuth when VITE_OAUTH_CLIENT_ID is configured.
+ * Supports 3 profiles:
+ *   - dev:   API=localhost, OAuth=off (password login, no OAuth)
+ *   - oauth: API=localhost, OAuth=on  (local Docker API, tianv.local OAuth)
+ *   - prod:  API=production, OAuth=on (production API, iam.tianv.com OAuth)
+ */
+
+import { apiClient } from '../api/client';
+import { loginWithTokens } from './store';
+import { AuthService } from './service';
+import { generatePKCE } from './pkce';
+import { getPortalUrl } from '../config';
+import { persistOAuthClientId } from './oauth-client-id-store';
+import { traceRedirect } from './auth-trace';
+import { decodeJwtPayload } from './jwt-payload';
+import type { User } from '../types';
+
+function getAppConfig(): Record<string, string> | undefined {
+	if (typeof window !== 'undefined') {
+		return (window as any).__APP_CONFIG__;
+	}
+	return undefined;
+}
+
+const SK = {
+	PKCE: 'oauth_pkce_verifier',
+	STATE: 'oauth_state',
+	INIT_TS: 'oauth_init_ts',
+	CID: 'oauth_client_id',
+};
+
+export interface OAuthInitiateOptions {
+	/** 「停留」取消本次跳转时回调（AUTH-03，调用方据此恢复 UI）；内部已先清预置物 |
+	 *  与待重试定时器（AUTH-08），再次交互可全新发起。 */
+	onStay?: () => void;
+	/** 跳过 10s 防重入窗口（用户显式点「前往登录」重试时用，AUTH-03）。 */
+	force?: boolean;
+}
+
+/**
+ * AUTH-46②：OAuth 回调失败错误——携稳定 code，消费方（OAuthCallbackPage 等）按 code
+ * 映射本地化文案；message 保留英文原文供 console/诊断。此前直接 throw 英文裸句
+ * （"State mismatch — possible CSRF attack" 等）落用户屏。
+ */
+export class OAuthCallbackError extends Error {
+	readonly code: string;
+	constructor(code: string, message: string) {
+		super(message);
+		this.name = 'OAuthCallbackError';
+		this.code = code;
+	}
+}
+
+// 防重入拦截后的一次性重试 timer（避免 10 秒窗口内快速刷新导致 OAuth 跳转被吞、页面卡住）
+let retryTimer: ReturnType<typeof setTimeout> | null = null;
+
+/**
+ * 丢弃未完成的 OAuth 发起留下的全部预置物（AUTH-08 会话卫生）：
+ * 取消待重试定时器 + 清 sessionStorage 四键（state/verifier/client_id/init_ts）。
+ * 「停留」（handleStay）与登出（AuthService.logout）共用——两者都意味着
+ * 「本次发起已作废」：不清则 ① 窗口过期后自动重试仍会把用户弹走；
+ * ② 明文 verifier 与 state 跨登出残留在 tab 里。
+ */
+export function discardPendingOAuthLogin(): void {
+	if (typeof window === 'undefined') return;
+	if (retryTimer) {
+		clearTimeout(retryTimer);
+		retryTimer = null;
+	}
+	sessionStorage.removeItem(SK.STATE);
+	sessionStorage.removeItem(SK.PKCE);
+	sessionStorage.removeItem(SK.CID);
+	sessionStorage.removeItem(SK.INIT_TS);
+}
+
+function parseUserFromToken(token?: string, apiUser?: unknown): User {
+	if (token) {
+		const p = decodeJwtPayload(token);
+		if (p) {
+			return {
+				id: (p.sub || p.user_id) as string,
+				username: ((p as any).custom?.username || (p as any).username) as string,
+				email: p.email as string,
+				status: 'active',
+				avatarUrl: p.picture as string,
+			} as unknown as User;
+		}
+	}
+	return apiUser as User;
+}
+
+function envVar(key: string): string {
+	const cfg = getAppConfig();
+	if (cfg && cfg[key]) return cfg[key];
+	try {
+		return (import.meta as any).env?.[key] || '';
+	} catch {
+		return '';
+	}
+}
+
+function getConfig() {
+	const base = getPortalUrl('auth');
+	const callbackPath = (window as any).__APP_CONFIG__?.BASE_PATH || '/';
+	const origin = window.location.origin;
+	return {
+		clientId: envVar('VITE_OAUTH_CLIENT_ID'),
+		authorizeUrl: `${base}/oauth/api/v1/oauth/authorize`,
+		redirectUri:
+			callbackPath === '/' ? `${origin}/oauth/callback` : `${origin}${callbackPath}/oauth/callback`,
+		scope: 'openid profile email offline_access',
+	};
+}
+
+export function isOAuthEnabled(): boolean {
+	return !!envVar('VITE_OAUTH_CLIENT_ID');
+}
+
+function randomState(): string {
+	if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+		try {
+			return crypto.randomUUID();
+		} catch {
+			/* fall through to getRandomValues */
+		}
+	}
+	// crypto.getRandomValues is available in non-secure contexts too (unlike
+	// randomUUID, which requires HTTPS/localhost). This value is used as the
+	// OAuth state CSRF token — never degrade to a state-recoverable, predictable
+	// PRNG or a timestamp (both are attackable for CSRF forgery). Fail loud.
+	if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+		const bytes = new Uint8Array(16);
+		crypto.getRandomValues(bytes);
+		return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+	}
+	throw new Error('No CSPRNG available — cannot generate secure OAuth state');
+}
+
+export async function initiateOAuthLogin(
+	clientId?: string,
+	redirectTarget?: string,
+	opts?: OAuthInitiateOptions,
+): Promise<void> {
+	const ts = sessionStorage.getItem(SK.INIT_TS);
+	if (!opts?.force && ts && Date.now() - parseInt(ts, 10) < 10000) {
+		// 防重入：10 秒内已有一次 OAuth 初始化（如快速刷新/重复导航）。
+		// 直接 return 会吞掉跳转导致 RequireAuth 卡在空白页（无 re-render 不会重试），
+		// 因此在窗口过期后安排一次自动重试，保证最终完成跳转。
+		const wait = 10000 - (Date.now() - parseInt(ts, 10)) + 100;
+		if (!retryTimer) {
+			retryTimer = setTimeout(() => {
+				retryTimer = null;
+				void initiateOAuthLogin(clientId, redirectTarget);
+			}, wait);
+		}
+		return;
+	}
+	// 本次发起取代任何待重试定时器（含 force 绕过窗口时的遗留）
+	if (retryTimer) {
+		clearTimeout(retryTimer);
+		retryTimer = null;
+	}
+	sessionStorage.setItem(SK.INIT_TS, String(Date.now()));
+
+	// Determine the URL to redirect to after successful OAuth
+	const target = redirectTarget || window.location.href;
+
+	// Derive OAuth config (redirectUri computed from BASE_PATH, consistent with handleOAuthCallback)
+	const cfg = getConfig();
+	const cid = clientId || cfg.clientId;
+	if (!cid) throw new Error('OAuth client_id is not available');
+
+	// Always encode state as JSON with CSRF token + redirect target
+	const csrf = randomState();
+	const state = JSON.stringify({ csrf, redirect: target });
+
+	sessionStorage.setItem(SK.STATE, csrf);
+	sessionStorage.setItem(SK.CID, cid);
+	// 交棒时落持久层：刷新/登出在 React 上下文外，拿不到 slug 解析结果（TASK-09 / D8）
+	persistOAuthClientId(cid);
+
+	// 「停留」= 放弃本次发起：清预置物 + 取消待重试定时器，防止窗口过期后
+	// 自动重试再把用户弹走；随后通知调用方恢复 UI（AUTH-03/08）。
+	const handleStay = () => {
+		discardPendingOAuthLogin();
+		opts?.onStay?.();
+	};
+
+	try {
+		const pkce = await generatePKCE();
+		sessionStorage.setItem(SK.PKCE, pkce.verifier);
+		const params = new URLSearchParams({
+			response_type: 'code',
+			client_id: cid,
+			redirect_uri: cfg.redirectUri,
+			scope: cfg.scope,
+			code_challenge: pkce.challenge,
+			code_challenge_method: 'S256',
+			state,
+		});
+		// interstitial：未认证深链被动弹去登录 → authTrace 提示（可停留）。
+		traceRedirect(`${cfg.authorizeUrl}?${params}`, {
+			reason: 'oauth-initiate',
+			kind: 'interstitial',
+			assign: true,
+			onStay: handleStay,
+		});
+	} catch {
+		const params = new URLSearchParams({
+			response_type: 'code',
+			client_id: cid,
+			redirect_uri: cfg.redirectUri,
+			scope: cfg.scope,
+			state,
+		});
+		traceRedirect(`${cfg.authorizeUrl}?${params}`, {
+			reason: 'oauth-initiate',
+			kind: 'interstitial',
+			assign: true,
+			onStay: handleStay,
+		});
+	}
+}
+
+export async function handleOAuthCallback(): Promise<void> {
+	const q = new URLSearchParams(window.location.search);
+
+	const err = q.get('error');
+	if (err) {
+		throw new OAuthCallbackError(
+			'oauth.provider_error',
+			q.get('error_description') || `OAuth error: ${err}`,
+		);
+	}
+
+	const code = q.get('code');
+	if (!code) throw new OAuthCallbackError('oauth.missing_code', 'Missing authorization code');
+
+	const storedState = sessionStorage.getItem(SK.STATE) || '';
+	const verifier = sessionStorage.getItem(SK.PKCE) || '';
+	const cid = sessionStorage.getItem(SK.CID) || '';
+
+	// State is always JSON: { csrf, redirect }
+	let oauthRedirectTarget: string | null = null;
+	const rawState = q.get('state');
+	if (rawState) {
+		try {
+			const parsed = JSON.parse(rawState);
+			if (parsed.csrf && parsed.csrf === storedState) {
+				oauthRedirectTarget = parsed.redirect || null;
+			} else if (parsed.csrf) {
+				throw new OAuthCallbackError(
+					'oauth.state_mismatch',
+					'State mismatch — possible CSRF attack',
+				);
+			}
+		} catch (e) {
+			if (e instanceof OAuthCallbackError) throw e;
+			// Backward compat: plain string state (should not happen after Fix 3)
+			if (rawState !== storedState) {
+				throw new OAuthCallbackError(
+					'oauth.state_mismatch',
+					'State mismatch — possible CSRF attack',
+				);
+			}
+		}
+	}
+
+	if (!verifier) {
+		throw new OAuthCallbackError(
+			'oauth.pkce_cleared',
+			'Missing PKCE verifier — page reload may have cleared storage',
+		);
+	}
+
+	// Derive redirectUri from getConfig() for consistency with initiateOAuthLogin
+	const cbCfg = getConfig();
+	const redirectUri = cbCfg.redirectUri;
+
+	const res = await apiClient.post(
+		'/oauth/api/v1/oauth/token', // @generated-api-exempt
+		new URLSearchParams({
+			grant_type: 'authorization_code',
+			code,
+			client_id: cid,
+			client_secret: '',
+			redirect_uri: redirectUri,
+			code_verifier: verifier,
+		}).toString(),
+		{ headers: { 'Content-Type': 'application/x-www-form-urlencoded' } },
+	);
+
+	// 用毕即焚（AUTH-08）：兑换请求已消费 code_verifier/state/client_id，立即清除；
+	// 原清理点在 userinfo、/auth/me 多次 await 之后，明文 verifier 驻留窗口被无谓拉长。
+	sessionStorage.removeItem(SK.PKCE);
+	sessionStorage.removeItem(SK.STATE);
+	sessionStorage.removeItem(SK.CID);
+
+	const t = res.data as any;
+	const accessToken = t.access_token;
+	const refreshToken = t.refresh_token || null;
+
+	// Prefer id_token for user info, fallback to /auth/me.
+	// IMPORTANT: loginWithTokens (which populates the auth store) runs AFTER this block,
+	// so the interceptor would send NO Authorization header here. Attach the freshly
+	// exchanged access_token explicitly — otherwise /auth/me 401s and the apiClient
+	// interceptor routes it through onUnauthorized (no refresh token yet) → bounce back
+	// to the login page with the now-consumed code → infinite redirect loop.
+	// oauth 服务的 id_token（oidc_signer.go SignIDToken）只含 sub/aud/iss/exp 等标准 claim，
+	// 不含 email/username。若直接采信，/auth/me 兜底被短路 → store 落残缺 user →
+	// UserMenu 等消费方显示「未登录」。缺身份字段的解析结果视为信息不足，交棒 /auth/me。
+	let user: User | null = parseUserFromToken(t.id_token);
+	if (user && !user.username && !user.email) {
+		user = null;
+	}
+	if (!user && accessToken) {
+		try {
+			const me = await apiClient.get('/identity/api/v1/auth/me', {
+				// @generated-api-exempt
+				headers: { Authorization: `Bearer ${accessToken}` },
+			});
+			user = parseUserFromToken(undefined, me.data);
+		} catch {
+			// /auth/me may fail; loginWithTokens will still succeed with partial user
+		}
+	}
+	if (!user && accessToken) {
+		// 最后兜底：/auth/me 也失败时用 access_token JWT 解析 user
+		// (identity 签发，payload 实测含 sub/tenant_id/custom.*，可能无 email/username)
+		user = parseUserFromToken(accessToken);
+	}
+	if (!user) {
+		user = { id: '', username: '', email: '' } as User;
+	}
+
+	// OIDC userinfo（oauth 服务经 BFF：/bff/oauth/api/v1/oauth/userinfo）补充展示身份：
+	// id_token 与 /auth/me 都不含展示名（name/nickname/picture）。同样须显式带 access_token
+	// （loginWithTokens 尚未执行，拦截器无 token 可用）。失败静默降级——缺 displayName 时
+	// 消费方按 displayName → username → email 链回落，不影响登录。
+	if (accessToken) {
+		try {
+			const res = await apiClient.get('/oauth/api/v1/oauth/userinfo', {
+				// @generated-api-exempt
+				headers: { Authorization: `Bearer ${accessToken}` },
+			});
+			const info = res.data as { nickname?: string; name?: string; picture?: string };
+			const displayName = (info?.nickname || '').trim() || (info?.name || '').trim();
+			if (displayName) user.displayName = displayName;
+			if (info?.picture) user.avatarUrl = info.picture;
+		} catch {
+			// userinfo 失败不阻断登录（同上，按缺省链回落）
+		}
+	}
+
+	// 兑换成功后落持久层（同 TASK-09 / D8；兑换前的持久值可能来自旧租户）
+	persistOAuthClientId(cid);
+
+	// Persist to Zustand store (in-memory).
+	// Zustand persist subscriber will automatically write to localStorage
+	// via partialize — no manual localStorage.setItem needed.
+	loginWithTokens(accessToken, refreshToken, user);
+
+	// OAuth access_token 由身份服务签发，payload 含 tenant_id claim。
+	// 登录成功后初始化 currentTenantId，供 useTenantId()/useTenantIdOr() 等
+	// 页面使用真实租户（否则 fallback 'default-tenant' 导致 data-classification 等 404）。
+	const parsedToken = accessToken ? decodeJwtPayload(accessToken) : null;
+	const tokenTenantId = parsedToken?.tenant_id || (parsedToken as any)?.tenantId;
+	if (tokenTenantId) {
+		AuthService.updateCurrentTenant(tokenTenantId as string);
+	}
+
+	// Compute navigation target
+	let target: string;
+	if (oauthRedirectTarget) {
+		target = oauthRedirectTarget;
+	} else {
+		// Fallback to BASE_PATH from app config or root
+		const fallbackBase = (window as any).__APP_CONFIG__?.BASE_PATH || '/';
+		target = fallbackBase === '/' ? '/' : `${window.location.origin}${fallbackBase}/`;
+	}
+
+	// Full page navigation to the target (auth gateway will route to dashboard)
+	// funnel：登录成功回跳（预期行为，静默直跳，assign 保持原语义）；仅记 trace。
+	traceRedirect(target, { reason: 'oauth-callback', assign: true });
+}

package/src/auth/pkce.ts

@@ -0,0 +1,141 @@
+/**
+ * RFC 7636 — OAuth2 PKCE (Proof Key for Code Exchange)
+ *
+ * Uses Web Crypto API (crypto.subtle) when available.
+ * Falls back to a compact, verified pure-JS SHA-256 implementation for non-secure contexts (HTTP).
+ */
+
+function base64URLEncode(buffer: ArrayBuffer): string {
+	const bytes = new Uint8Array(buffer);
+	let binary = '';
+	for (let i = 0; i < bytes.length; i++) {
+		binary += String.fromCharCode(bytes[i]);
+	}
+	return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+
+function generateRandomString(length: number): string {
+	const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~'; // 66 chars
+	if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
+		// Never silently degrade to a weak, state-recoverable PRNG — the PKCE
+		// verifier is a security credential. Fail loud instead.
+		throw new Error('crypto.getRandomValues is unavailable — cannot generate PKCE verifier');
+	}
+	// Rejection sampling to remove modulo bias: 256 % 66 = 58, so a naive
+	// `byte % 66` makes chars 0-57 ~3% likelier than chars 58-65. Instead we
+	// build a 198-char lookup table (chars repeated 3×, each char exactly 3
+	// times) and only accept bytes < 198 — pool[byte] is then perfectly
+	// uniform (every char has probability 3/198 = 1/66).
+	const maxAccepted = Math.floor(256 / chars.length) * chars.length; // 198
+	const pool = chars.repeat(maxAccepted / chars.length); // 66 × 3 = 198 chars
+	let result = '';
+	while (result.length < length) {
+		const array = new Uint8Array(length - result.length);
+		crypto.getRandomValues(array);
+		for (const byte of array) {
+			if (byte < maxAccepted) {
+				result += pool[byte];
+			}
+		}
+	}
+	return result;
+}
+
+export interface PKCEPair {
+	verifier: string;
+	challenge: string;
+}
+
+export async function generatePKCE(): Promise<PKCEPair> {
+	const verifier = generateRandomString(64);
+	const challenge = await sha256Base64URL(verifier);
+	return { verifier, challenge };
+}
+
+async function sha256Base64URL(input: string): Promise<string> {
+	const encoder = new TextEncoder();
+	const data = encoder.encode(input);
+	try {
+		const hash = await crypto.subtle.digest('SHA-256', data);
+		return base64URLEncode(hash);
+	} catch {
+		return sha256PureJS(input);
+	}
+}
+
+/**
+ * Pure-JS SHA-256 — verified against NIST test vectors.
+ * Based on a minimal, audited implementation.
+ */
+function sha256PureJS(input: string): string {
+	const msg = new TextEncoder().encode(input);
+	const msgBits = msg.length * 8;
+	const buf = new Uint8Array(((msg.length + 9 + 63) >>> 6) << 6);
+	buf.set(msg);
+	buf[msg.length] = 0x80;
+	const view = new DataView(buf.buffer);
+	view.setUint32(buf.length - 4, msgBits);
+
+	const K = new Uint32Array([
+		0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+		0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+		0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+		0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+		0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+		0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+		0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+		0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+	]);
+
+	const H = new Uint32Array([
+		0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+	]);
+	const W = new Uint32Array(64);
+
+	for (let off = 0; off < buf.length; off += 64) {
+		for (let i = 0; i < 16; i++) {
+			W[i] = view.getUint32(off + i * 4);
+		}
+		for (let i = 16; i < 64; i++) {
+			const s0 = ror(W[i - 15], 7) ^ ror(W[i - 15], 18) ^ (W[i - 15] >>> 3);
+			const s1 = ror(W[i - 2], 17) ^ ror(W[i - 2], 19) ^ (W[i - 2] >>> 10);
+			W[i] = (W[i - 16] + s0 + W[i - 7] + s1) | 0;
+		}
+		let [a, b, c, d, e, f, g, h] = H;
+		for (let i = 0; i < 64; i++) {
+			const S1 = ror(e, 6) ^ ror(e, 11) ^ ror(e, 25);
+			const ch = (e & f) ^ (~e & g);
+			const t1 = (h + S1 + ch + K[i] + W[i]) | 0;
+			const S0 = ror(a, 2) ^ ror(a, 13) ^ ror(a, 22);
+			const maj = (a & b) ^ (a & c) ^ (b & c);
+			const t2 = (S0 + maj) | 0;
+			h = g;
+			g = f;
+			f = e;
+			e = (d + t1) | 0;
+			d = c;
+			c = b;
+			b = a;
+			a = (t1 + t2) | 0;
+		}
+		H[0] = (H[0] + a) | 0;
+		H[1] = (H[1] + b) | 0;
+		H[2] = (H[2] + c) | 0;
+		H[3] = (H[3] + d) | 0;
+		H[4] = (H[4] + e) | 0;
+		H[5] = (H[5] + f) | 0;
+		H[6] = (H[6] + g) | 0;
+		H[7] = (H[7] + h) | 0;
+	}
+
+	const digest = new Uint8Array(32);
+	const dv = new DataView(digest.buffer);
+	for (let i = 0; i < 8; i++) dv.setUint32(i * 4, H[i]);
+	return base64URLEncode(digest.buffer);
+}
+
+function ror(x: number, n: number): number {
+	return (x >>> n) | (x << (32 - n));
+}
+
+export { generatePKCE as generateCodeChallenge };

package/src/auth/portal-config.ts

@@ -0,0 +1,68 @@
+/**
+ * PortalAuthConfig — Portal 认证配置注册表
+ *
+ * 集中管理所有 Portal 的角色定义和 Guard 配置，
+ * 消除跨 Portal 的角色常量重复定义。
+ *
+ * 用法:
+ *   import { ADMIN_GUARDS, AdminGuard } from '@autional/shared';
+ *   // 路由中: <AdminGuard><Page /></AdminGuard>
+ *   替代: <RequireAuth allowedRoles={['super_admin', 'admin']}><Page /></RequireAuth>
+ *
+ * @see docs/architecture/auth-next-issues-analysis.md
+ */
+
+// ============ Role Sets ============
+
+/** 超级管理员（系统级） */
+export const ROLE_SUPER_ADMIN = ['super_admin', 'admin'] as const;
+/** 用户管理 */
+export const ROLE_USER_MGMT = ['super_admin', 'admin', 'user_manager'] as const;
+/** 安全只读（含 admin，用于 admin-console 路由守卫） */
+export const ROLE_SECURITY_READ = ['super_admin', 'admin', 'security_admin'] as const;
+/** security-dashboard 基础准入（不含 admin — admin 不直接登录 security-dashboard） */
+export const ROLE_SECURITY_ENTRY = ['super_admin', 'security_admin', 'auditor'] as const;
+/** 审计安全（含 auditor 只读，不含 admin — admin 审计经 admin-console + sod_mode 控制） */
+export const ROLE_AUDIT_READ = ['super_admin', 'security_admin', 'auditor'] as const;
+/** 安全操作（含配置权限，不含 auditor） */
+export const ROLE_SECURITY_FULL = ['super_admin', 'security_admin'] as const;
+
+// ============ Portal Guards ============
+
+/**
+ * Portal Guard 配置。
+ * 如需新增 Guard，在此添加 role 集即可。
+ */
+export const ADMIN_GUARDS = {
+	admin: { roles: ROLE_SUPER_ADMIN },
+	userMgmt: { roles: ROLE_USER_MGMT },
+	securityRead: { roles: ROLE_SECURITY_READ },
+	auditRead: { roles: ROLE_AUDIT_READ }, // admin-console 审计证据路由
+	securityAdmin: { roles: ROLE_SECURITY_FULL }, // admin-console 安全配置管理
+} as const;
+
+export const PLATFORM_GUARDS = {
+	superAdmin: { roles: ROLE_SUPER_ADMIN },
+} as const;
+
+export const SECURITY_GUARDS = {
+	security: { roles: ROLE_SECURITY_ENTRY }, // 基础准入（不含 admin）
+	auditRead: { roles: ROLE_AUDIT_READ }, // 审计证据页（auditor 只读）
+	securityAdmin: { roles: ROLE_SECURITY_FULL }, // 安全配置/平台级操作
+	auditor: { roles: ['auditor'] }, // 仅 auditor
+} as const;
+
+// ============ Portal Config ============
+
+/** 所有 Portal 的认证配置映射 */
+export const PORTAL_AUTH_CONFIG = {
+	'admin-console': { guards: ADMIN_GUARDS },
+	'platform-console': { guards: PLATFORM_GUARDS },
+	'security-dashboard': { guards: SECURITY_GUARDS },
+	'end-user-portal': { guards: null }, // 仅需 token，无角色限制
+	// developer-portal removed — merged into admin per ADR-006
+	'authenticator-app': { guards: null }, // 仅需 token，无角色限制
+	'auth-pages': { guards: null }, // 混合（大部分公开）
+} as const;
+
+export type PortalName = keyof typeof PORTAL_AUTH_CONFIG;