From 4a780a4ce7bd43816bc7c39e54910ece8477017c Mon Sep 17 00:00:00 2001 From: ssw Date: Mon, 14 Sep 2026 18:51:37 +0800 Subject: [PATCH] =?UTF-8?q?feat(sso):=20MaxKey=20=E8=BF=81=E7=A7=BB=20P1/P?= =?UTF-8?q?2=20=E2=80=94=E2=80=94=20SCIM/CAS/LDAP/=E5=90=8C=E6=AD=A5?= =?UTF-8?q?=E8=BF=9E=E6=8E=A5=E5=99=A8/=E8=87=AA=E5=8A=A9=E5=AF=86?= =?UTF-8?q?=E7=A0=81=E9=87=8D=E7=BD=AE/=E5=BD=92=E5=B1=9E=E5=9C=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 新增 plugin-sso 模块(零新增 crate):scim.rs(SCIM 2.0)、cas.rs(CAS 1.0/2.0)、 ldap.rs(LDAP/AD,手写 BER/ASN.1 Simple Bind)、sync.rs(钉钉/企微/飞书手动触发同步)、 reset.rs(自助密码重置)、geo.rs(登录 IP 归属地) - api.rs 兜底路由按 scim→cas→reset→sync 分发兄弟模块;h_login 集成 LDAP(未启用零行为变化) - 修 http::redirect 空 body 触发 NGX_ERROR(CAS 302 无 Location 的根因) - nginx.conf / nginx.test.conf 补 env SYNC_* / PASSWORD_RESET_*(worker 可见) - 新增第 7 套 e2e tests/maxkey-p1p2-e2e.sh(21 项),harness 接入 [7/7];七套全绿 rc=0 - 修脚本 $var 紧跟全角字符被并入变量名的 shell 坑(tests + scripts) - 文档同步:maxkey-migration-analysis(P1/P2 状态) / roadmap(v4) / CLAUDE.md / README.md --- CLAUDE.md | 25 +- README.md | 61 ++- docs/maxkey-migration-analysis.md | 42 +- docs/roadmap.md | 26 + scripts/load-env.sh | 2 +- scripts/local-serve.sh | 6 +- scripts/run-local-e2e.sh | 14 +- source/conf/nginx.conf | 6 + source/conf/nginx.test.conf | 10 + source/rust/crates/ipass-core/src/http.rs | 73 +++ source/rust/crates/plugin-sso/src/api.rs | 64 ++- source/rust/crates/plugin-sso/src/audit.rs | 1 + source/rust/crates/plugin-sso/src/cas.rs | 161 ++++++ source/rust/crates/plugin-sso/src/geo.rs | 152 ++++++ source/rust/crates/plugin-sso/src/ldap.rs | 252 +++++++++ source/rust/crates/plugin-sso/src/lib.rs | 6 + source/rust/crates/plugin-sso/src/reset.rs | 130 +++++ source/rust/crates/plugin-sso/src/scim.rs | 602 +++++++++++++++++++++ source/rust/crates/plugin-sso/src/sync.rs | 191 +++++++ tests/maxkey-p1p2-e2e.sh | 199 +++++++ 20 files changed, 1986 insertions(+), 37 deletions(-) create mode 100644 source/rust/crates/plugin-sso/src/cas.rs create mode 100644 source/rust/crates/plugin-sso/src/geo.rs create mode 100644 source/rust/crates/plugin-sso/src/ldap.rs create mode 100644 source/rust/crates/plugin-sso/src/reset.rs create mode 100644 source/rust/crates/plugin-sso/src/scim.rs create mode 100644 source/rust/crates/plugin-sso/src/sync.rs create mode 100644 tests/maxkey-p1p2-e2e.sh diff --git a/CLAUDE.md b/CLAUDE.md index fbb0bce..bdf2b7f 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -74,7 +74,7 @@ cargo build --release ### 跑测试 ```bash -bash scripts/run-local-e2e.sh # 六套 e2e 全跑(自动起停 nginx + demo 系统) +bash scripts/run-local-e2e.sh # 七套 e2e 全跑(自动起停 nginx + demo 系统) bash scripts/run-local-e2e.sh --keep # 保留进程手工排查 ``` @@ -88,7 +88,7 @@ bash scripts/run-local-e2e.sh --keep # 保留进程手工排查 | --- | --- | | `gateway/src/lib.rs` | **装配层**:指令解析、共享内存建表(`state_zone_init`,fork 前一次)、`PLUGINS` 数组、API 的 content 阶段处理器与插件分发、`init_process` 播种 admin | | `crates/ipass-core/src/*` | **内核**:`state`(通用共享内存原语)/ `store`(JSON 原子读写)/ `users`(账号与 Key 的唯一写入口)/ `models`(仅共性字段 + `extra` 透传)/ `config`(仅共性策略常量与键前缀)/ `session`(管理员会话)/ `audit` / `http` / `util` / `plugin`(契约)/ `loc`(location 开关)。**不含** OAuth / TOTP 等个性代码 | -| `crates/plugin-sso/src/*` | **身份插件**:`oauth`(OAuth2/OIDC 全部逻辑 + IAP 身份解析)/ `api`(路由表 + handler)/ `oauth_clients` / `oauth_keys`(OAuth/IAP 协议常量与共享内存键前缀,原属内核 `config`)/ `oauth_state`(OAuthClient 模型 + 注册表/授权码/会话状态,原属内核 `state`/`store`)/ `rsa`(手写 RS256)/ `captcha` / `otp`(TOTP 算法 + 账号侧 TOTP,数据存 `User.extra`) | +| `crates/plugin-sso/src/*` | **身份插件**:`oauth`(OAuth2/OIDC 全部逻辑 + IAP 身份解析)/ `api`(路由表 + handler)/ `oauth_clients` / `oauth_keys`(OAuth/IAP 协议常量与共享内存键前缀,原属内核 `config`)/ `oauth_state`(OAuthClient 模型 + 注册表/授权码/会话状态,原属内核 `state`/`store`)/ `rsa`(手写 RS256)/ `captcha` / `otp`(TOTP 算法 + 账号侧 TOTP,数据存 `User.extra`)/ `scim`(SCIM 2.0 身份供给)/ `cas`(CAS 1.0/2.0 协议端点)/ `ldap`(LDAP/AD 认证源,零依赖手写 BER)/ `sync`(钉钉·企微·飞书同步连接器,手动触发)/ `reset`(自助密码重置)/ `geo`(登录 IP 归属地) | | `crates/plugin-domain/src/*` | **域名插件**:`keys`(`sub:` 前缀、企业域名 zone、子域名形状与 TTL 常量)/ `models`(`DomainEntry`)/ `domains`(校验、申请/审核/删除、写穿共享内存)/ `resolve`(access 阶段解析 Host → `$proxy_backend_addr`)/ `api`(8 条管理态 + 账号态路由)/ `lib`(`DomainPlugin` 装配) | > `models.rs` 的 `User` 只含**共性字段**(凭据 / 身份声明 / 锁定);iPass 等插件的个性字段 @@ -153,6 +153,12 @@ bash scripts/run-local-e2e.sh --keep # 保留进程手工排查 改轮数或拼接顺序会让存量 `users.json` 全部登录失败 (已用独立 Python 实现逐字节核对;`scripts/seed-data.sh` 里是同一套算法的 Python 版)。 +8. **协议扩展端点(SCIM / CAS / 同步 / 密码重置)走「兄弟模块分发」,不改主路由表**: + `api.rs` 的 `route()` 兜底段(`_ =>`)按 `scim → cas → reset → sync` 顺序调用各模块的 + `route(method, uri)`,命中即用其 `(Guard, Handler)`;各模块自持路径前缀与鉴权级别。 + 新增同类能力**优先照此扩展**,不要往主表里逐条塞路径。`geo::lookup(ip)` 是纯函数, + 审计写登录事件时补归属地(内网/中国/海外),无状态。 + --- ## 硬约定(改代码必须遵守) @@ -171,7 +177,7 @@ bash scripts/run-local-e2e.sh --keep # 保留进程手工排查 - **新增接口三步**:① 在 `api.rs` 写 handler,统一用 `http::ok/fail`; ② 在 `route()` 表加一行,`Guard` 选 `Public` / `User` / `Admin`; ③ 涉及接入方/账号变更的,**必须调对应的 `sync_shm`**。鉴权由分发器统一兜底, - **不要在单个 handler 里重复实现**。 + **不要在单个 handler 里重复实现**。同类协议族(SCIM/CAS/…)可放**独立模块**,在主表兜底段 `_ =>` 分发给它自己的 `route()`(见「核心机制」第 8 条)。 - **所有写操作必须同时更新 shm 与 JSON 文件**。只写一边 = 「重启后回滚」或「改了不生效」。 - **写共享内存失败必须出声**。`state::put_*` 返回 `false`(zone 满 / 分配失败)时要 `log_err` (带对象标识与后果);`reload_shm` 要核对「期望条数 vs 实际装载」。**别丢掉返回值**—— @@ -221,6 +227,9 @@ bash scripts/run-local-e2e.sh --keep # 保留进程手工排查 | 跨子域登录不生效(每个子域都要重新登录) | 没设 `OAUTH_COOKIE_DOMAIN`(不设 = 主机级 cookie) | | 证书看着没过期却报 TLS 错 | 先 `openssl s_client -servername <域名>` 看链路**实际**收到的证书;acme.sh 产物在 `~/.acme.sh/`,与 `conf/tls/` 是两份,续期后必须拷过去再 reload | | `--with-pcre` 源码树挪位置后编译报 `pcre2.h not found` | 见「构建」小节:必须重新 `./configure && make` | +| 新模块读不到 `SYNC_*` / `PASSWORD_RESET_*` 等 env | nginx 默认剥离全部 env;必须在 `nginx.conf`/`nginx.test.conf` **main 上下文**加 `env XXX;`,否则 worker 里 `std::env::var` 恒空 | +| CAS `/cas/login` 302 没带 `Location` | `http::redirect` 发了**空 body** → `create_buffer_from_str("")` 返回 None → `NGX_ERROR`;redirect 的 body 必须非空 | +| e2e 重置类用例把 admin 锁死 | 别改 admin 种子口令(`123456` 过不了 8 位策略、无法用重置接口还原);用一次性账号,否则后续套件登录失败会触发 600s 账号锁定 | --- @@ -228,7 +237,7 @@ bash scripts/run-local-e2e.sh --keep # 保留进程手工排查 ```bash # ---- 本机 ---- -bash scripts/run-local-e2e.sh # 三套 e2e 全跑 +bash scripts/run-local-e2e.sh # 七套 e2e 全跑 bash scripts/run-local-e2e.sh --keep # 保留进程手工排查 bash scripts/seed-data.sh # 物化 source/data/ bash scripts/seed-data.sh --force # 重建 users.json(丢已有账号) @@ -239,6 +248,14 @@ curl -s -D- -o/dev/null -X POST http://127.0.0.1:18098/login \ --data-urlencode 'username=alice' --data-urlencode 'password=alice123' # 看 Set-Cookie: sso_sid curl -s -b 'sso_sid=<值>' http://127.0.0.1:18098/api/v1/me +bash tests/maxkey-p1p2-e2e.sh http://127.0.0.1:18098 # 单跑第 7 套(SCIM/CAS/重置/同步/LDAP 禁用) + +# P1/P2 新增端点(网关在跑时;$JAR 为管理员登录后的 cookie 罐) +curl -s -b "$JAR" http://127.0.0.1:18098/scim/v2/ServiceProviderConfig | python3 -m json.tool +curl -s -o/dev/null -w '%{redirect_url}\n' -b "$JAR" 'http://127.0.0.1:18098/cas/login?service=http://app/cb' # 应见 ?ticket=ST- +curl -s -X POST http://127.0.0.1:18098/api/public/forgot-password --data 'username=alice' # 自助找回 +curl -s -b "$JAR" -X POST http://127.0.0.1:18098/api/admin/sync/dingtalk # 手动触发同步(需配 SYNC_*_URL) + # ---- 生产 ---- /usr/local/nginx/sbin/nginx -t && /usr/local/nginx/sbin/nginx # 改完先 -t 再起 ``` diff --git a/README.md b/README.md index 6325c39..3a45a72 100644 --- a/README.md +++ b/README.md @@ -60,7 +60,7 @@ export NGINX_SOURCE_DIR=/tmp/sso-build/src/nginx-1.30.4 export NGINX_BUILD_DIR=/tmp/sso-build/src/nginx-1.30.4/objs cargo build --release # 产物 source/rust/target/release/libsso_gateway.dylib -# ④ 一键跑三套端到端(自动播种数据、起 nginx + demo 系统、跑完自动清理) +# ④ 一键跑七套端到端(自动播种数据、起 nginx + demo 系统、跑完自动清理) cd <本仓库> && bash scripts/run-local-e2e.sh ``` @@ -82,7 +82,7 @@ kill <打印出的 pid> sso/ ├── docs/ │ ├── design.md 设计文档:端点、token 模型、共享内存、MaxKey 互通、构建与测试 -│ ├── roadmap.md 待执行任务(v2 RS256+JWKS、用户管理界面) +│ ├── roadmap.md 路线图(v1–v4 已完成 + 待办) │ └── screenshots/ 管理台与登录页截图 ├── source/ 可部署产物(代码 + 配置 + 静态页) │ ├── rust/ 动态模块源码(Cargo workspace,vendor 了 ngx-rust) @@ -101,9 +101,13 @@ sso/ │ ├── oauth2-e2e.sh 协议基线(discovery/grant/token/IAP 注入) │ ├── oauth2-maxkey-e2e.sh MaxKey 互通 + demo 系统接入 │ ├── admin-oauth-clients-e2e.sh 管理接口(接入方注册表) +│ ├── rs256-jwks-e2e.sh RS256 + JWKS 本地验签 +│ ├── admin-users-batch-e2e.sh 管理接口(账号批量维护) +│ ├── domain-e2e.sh 域名插件(申请/审核/转发) +│ ├── maxkey-p1p2-e2e.sh MaxKey P1/P2(SCIM/CAS/密码重置/同步/LDAP) │ └── demo-system/ 演示用「简单业务系统」(Python 标准库) ├── scripts/ -│ ├── run-local-e2e.sh 本机一键起停 + 跑三套 e2e +│ ├── run-local-e2e.sh 本机一键起停 + 跑七套 e2e │ └── seed-data.sh 物化运行时数据目录 └── refs/ 参考资料(**不进版本库**):ipass 来源项目、MaxKey ``` @@ -121,7 +125,7 @@ sso/ | GET/POST | `/oauth/userinfo` | 当前令牌对应用户声明 | | POST | `/oauth/introspect` | RFC 7662 令牌自省(第三方校验,需客户端鉴权) | | GET | `/.well-known/openid-configuration` | OIDC discovery | -| GET | `/oauth/jwks` · `/.well-known/jwks.json` | 公钥集合(**当前 HS256,返回 404 + 原因**,见路线图) | +| GET | `/oauth/jwks` · `/.well-known/jwks.json` | 公钥集合(**RS256**,`kid` 轮换;第三方本地验签,无需回源 introspect) | | GET/POST | `/login` | 登录页与表单提交(建立 `sso_sid` 会话) | | GET/POST | `/oauth/logout` | 注销会话 | @@ -135,12 +139,29 @@ sso/ | `/oauth2.0/profile` · `/oauth/v20/logout` | 同上 | | `/maxkey/...` · `/sign/authz/...` · `/sign/...` · `/authz/...` · `/api/...` 前缀 | context-path 自动归一化 | +### P1/P2 扩展端点(2026-09-14) + +| 方法 | 路径 | 说明 | +| --- | --- | --- | +| GET | `/scim/v2/ServiceProviderConfig` · `/Schemas` · `/ResourceTypes` | SCIM 2.0 元数据 | +| GET/POST | `/scim/v2/Users` | 列表 / 创建(201) | +| GET/PATCH/DELETE | `/scim/v2/Users/{id}` | 查询 / 增量改 / 删除(204) | +| GET | `/scim/v2/Groups` | 用户组(派生自账号 `groups`) | +| GET | `/cas/login?service=URL` | 已登录签发 ST 并 302 回跳 `?ticket=ST-` | +| GET | `/cas/validate` | CAS 1.0 纯文本(`yes\n` / `no`) | +| GET | `/cas/serviceValidate` · `/cas/proxyValidate` | CAS 2.0 XML | +| GET | `/cas/logout` | 注销 CAS 会话 | +| POST | `/api/public/forgot-password` | 自助密码找回(发一次性 token;防账号枚举) | +| POST | `/api/public/reset-password` | 凭 token 重置口令(单次有效) | +| POST | `/api/admin/sync/{dingtalk,workwechat,feishu}` | 手动触发身份同步(管理员) | + ### 管理接口(`/api/admin/*`,需管理员会话 Cookie) | 分类 | 路径 | | --- | --- | | 会话 | `login` · `logout` · `session` | -| 账号 | `users`(列表)· `users/create` · `users/key` · `users/password` · `users/display` · `users/profile`(部门/用户组)· `users/role` · `users/delete` | +| 账号 | `users`(列表)· `users/create` · `users/key` · `users/password` · `users/display` · `users/profile`(部门/用户组)· `users/role` · `users/unlock` · `users/batch` · `users/totp/setup|enable|disable` · `users/delete` | +| 同步 | `sync/dingtalk` · `sync/workwechat` · `sync/feishu`(手动触发,需配 `SYNC_*_URL`) | | 接入方 | `oauth-clients`(列表)· `oauth-clients/save` · `oauth-clients/rotate` · `oauth-clients/delete` | 账号态 API:`GET /api/v1/me`(`X-API-Key` 或 Bearer 鉴权)。 @@ -208,6 +229,19 @@ env ADMIN_INIT_PASSWORD; # 缺了这行模块读到的初始口令恒为空 env OAUTH_SIGNING_SECRET; # 令牌签名密钥(HS256 对称密钥) env OAUTH_ISSUER; # 必须与浏览器实际访问的 host 一致,否则第三方校验 issuer 失败 env OAUTH_COOKIE_DOMAIN; # 跨子域 SSO 才需要;不设 = 主机级 cookie +# P1/P2 新增模块用到的(缺了则 worker 里读不到) +env SYNC_DINGTALK_URL; # 同步连接器:钉钉用户目录源 +env SYNC_WORKWECHAT_URL; # 同步连接器:企业微信用户目录源 +env SYNC_FEISHU_URL; # 同步连接器:飞书用户目录源 +env PASSWORD_RESET_TOKEN_SINK;# 自助密码重置:token 落盘路径(生产可改接 SMTP) +env PASSWORD_RESET_TTL; # 自助密码重置:token 有效期秒(缺省 1800) +# LDAP/AD 认证源(未设置 = 关闭,既有登录行为不变): +env LDAP_ENABLED; # 1 = 启用 LDAP 兜底认证 +env LDAP_SERVER; # 如 ldap://127.0.0.1 +env LDAP_PORT; # 缺省 389 +env LDAP_BASE_DN; # 如 dc=example,dc=com +env LDAP_USER_DN_TEMPLATE; # 如 uid={user},ou=people,dc=example,dc=com +env LDAP_AUTO_CREATE; # 1 = LDAP 认证成功但本地无账号时自动建号 ``` --- @@ -215,10 +249,14 @@ env OAUTH_COOKIE_DOMAIN; # 跨子域 SSO 才需要;不设 = 主机级 cook ## 测试 ```bash -bash scripts/run-local-e2e.sh # 三套全跑(推荐) +bash scripts/run-local-e2e.sh # 七套全跑(推荐) bash tests/oauth2-e2e.sh http://127.0.0.1:18098 http://127.0.0.1:18099 # 协议基线 bash tests/oauth2-maxkey-e2e.sh # MaxKey 互通 + demo 接入 -bash tests/admin-oauth-clients-e2e.sh # 管理接口 +bash tests/admin-oauth-clients-e2e.sh # 管理接口(接入方) +bash tests/rs256-jwks-e2e.sh # RS256 + JWKS 验签 +bash tests/admin-users-batch-e2e.sh # 管理接口(账号批量) +bash tests/domain-e2e.sh # 域名插件 +bash tests/maxkey-p1p2-e2e.sh # SCIM / CAS / 密码重置 / 同步 / LDAP ``` 客户端密钥**不硬编码在脚本里**,运行时从 `$DATA_DIR/oauth_clients.json` 读取。 @@ -227,11 +265,10 @@ bash tests/admin-oauth-clients-e2e.sh # 管理接口 ## 待执行任务 -见 [`docs/roadmap.md`](docs/roadmap.md)。当前两项: - -1. **v2:RS256 签名 + `/oauth/jwks`** —— 让第三方本地验签,不必回源 introspect。 -2. **用户管理界面** —— 管理台「账号管理」目前只管账号与密钥,缺**角色 / 部门 / 用户组**的可视化维护 - (后端接口已可用:`users/profile`、`users/role`)。 +见 [`docs/roadmap.md`](docs/roadmap.md)。已完成:v2(RS256 + JWKS)、用户管理界面、 +v3(MaxKey/JNPF/uc 迁移 P0)、v4(MaxKey 迁移 **P1/P2**:SCIM 2.0 · CAS · LDAP/AD · 同步连接器 · +自助密码重置 · 登录 IP 归属地)。明确跳过:WebAuthn/Passkey、SAML 2.0、社交/扫码、FormBased。 +明细与依据见 [`docs/maxkey-migration-analysis.md`](docs/maxkey-migration-analysis.md)。 --- diff --git a/docs/maxkey-migration-analysis.md b/docs/maxkey-migration-analysis.md index 24755a2..a825832 100644 --- a/docs/maxkey-migration-analysis.md +++ b/docs/maxkey-migration-analysis.md @@ -15,6 +15,12 @@ MaxKey 值得抄的不是"大而全",而是三类东西:**纯算法与协议 | P2 低优先 | 5 项 | 有价值但当前定位用不上 | | 不建议迁移 | 6 项 | 重度绑定 Java 生态,或与"身份层"定位冲突 | +> **迁移状态(2026-09-14 更新)** +> P1 第 8–12 项与 P2 第 17 项**已实现**(对应条目已标 `[x]`,落地见文末「落地实现索引」); +> P2 第 13–16 项**已决定跳过**(标 `[skip]`)。 +> 边界(已与需求方确认):需外部基建的能力(LDAP/AD、同步连接器、自助密码重置)只做**手动触发端点**, +> 不引入常驻进程;WebAuthn/Passkey、社交/扫码、SAML 2.0、FormBased 四项不做。 + --- ## P0:建议迁移(纯逻辑,直接补短板) @@ -53,26 +59,26 @@ MaxKey 值得抄的不是"大而全",而是三类东西:**纯算法与协议 ## P1:视需求迁移(先评估成本) -8. **SCIM 2.0 身份供给** — MaxKey:`maxkey-web-apis/maxkey-web-api-scim/` +8. [x] **SCIM 2.0 身份供给** — MaxKey:`maxkey-web-apis/maxkey-web-api-scim/` (User/Group/EnterpriseUser/ServiceProviderConfig 完整资源模型)。 价值:外部系统(HR、上游 IdP)可用标准协议推送用户进来。资源模型清晰, 就是 CRUD,落 `users.json`/`groups` 现有模型可行;工作量主要在过滤语义 (`userName eq "..."`)与分页。**若确定有上游系统对接需求再做。** -9. **CAS 协议端点(v2/v3 validate)** — 延续 v1"照抄 MaxKey 文档接入方零改造"的思路, +9. [x] **CAS 协议端点(v2/v3 validate)** — 延续 v1"照抄 MaxKey 文档接入方零改造"的思路, 补 `/cas/sso/validate`、`/p3/proxyValidate` 等端点,让 CAS 客户端也能直连。 票据校验是纯逻辑;但 CAS 生态在国内老系统里存量不小,值得排期。 -10. **LDAP / AD 认证源** — MaxKey:`realm/ldap`(OpenLDAP/AD)。企业场景刚需,但 +10. [x] **LDAP / AD 认证源** — MaxKey:`realm/ldap`(OpenLDAP/AD)。企业场景刚需,但 Rust 侧需要 LDAP 客户端库(`ldap3` 依赖体积不小,且需 vendor)。 替代路径:先用 P1-8 的 SCIM 或 P2-13 的同步连接器"拉取"而非"直连"。 -11. **身份同步连接器(钉钉 / 企微 / 飞书 / AD)** — MaxKey: +11. [x] **身份同步连接器(钉钉 / 企微 / 飞书 / AD)** — MaxKey: `maxkey-synchronizers/maxkey-synchronizer-/`。钉钉/企微/飞书三个就是 HTTP API 调用(分页拉用户+组织),交互协议可直接照抄;AD/LDAP 需 LDAP 库。 适合做成定时任务(本项目无后台进程,可用 nginx timer 或外部 cron curl 管理端点触发)。 -12. **自助密码重置(邮箱/短信找回)** — MaxKey:`mxk_register` + 邮件/短信 provider +12. [x] **自助密码重置(邮箱/短信找回)** — MaxKey:`mxk_register` + 邮件/短信 provider (阿里云/腾讯云/网易云信,`maxkey-starter-sms/`)。依赖外部发信通道;若做, 建议 provider 抽象成配置驱动的 HTTP 调用(与 AIMALL GenericHTTPTool 同思路)。 @@ -80,20 +86,20 @@ MaxKey 值得抄的不是"大而全",而是三类东西:**纯算法与协议 ## P2:低优先(有价值,当前定位用不上) -13. **WebAuthn / Passkey** — MaxKey:`maxkey-starter/maxkey-starter-passkey/` +13. [skip] **WebAuthn / Passkey** — MaxKey:`maxkey-starter/maxkey-starter-passkey/` (含 `mxk_user_passkeys` 表)。方向正确但 Rust 零依赖下验签链很重 (COSE/CTAP2/attestation),且 RSA 大数运算本来就在 v2 才引入。等 v2 落地后再评估。 -14. **社交登录 / 扫码登录** — MaxKey 基于 JustAuth + 自研 WeLink/飞书/企微 request。 +14. [skip] **社交登录 / 扫码登录** — MaxKey 基于 JustAuth + 自研 WeLink/飞书/企微 request。 本项目作为**企业内部身份层**,社交登录价值有限;若 souyi.net.cn C 端要用,另起服务。 -15. **SAML 2.0** — MaxKey 重度绑定 OpenSAML。XML-DSig 签名在 Rust 零依赖下工作量 +15. [skip] **SAML 2.0** — MaxKey 重度绑定 OpenSAML。XML-DSig 签名在 Rust 零依赖下工作量 数倍于整个现有 oauth.rs。除非有明确 SAML SP 客户,否则不排期。 -16. **FormBased / TokenBased / ExtendApi 协议** — 老式企业代填/票据协议。 +16. [skip] **FormBased / TokenBased / ExtendApi 协议** — 老式企业代填/票据协议。 TokenBased 的"票据换会话"语义可作为 IAP 票据机制参考;FormBased 代填不建议。 -17. **ip2location 归属地解析** — MaxKey 内置登录 IP 归属地。审计日志做精致了再加。 +17. [x] **ip2location 归属地解析** — MaxKey 内置登录 IP 归属地。审计日志做精致了再加。 --- @@ -130,3 +136,19 @@ MaxKey 的 44 张表里,对本项目最有参考价值的三组设计: - 同步连接器:`maxkey-synchronizers/maxkey-synchronizer-{ad,ldap,jdbc,dingtalk,workwechat,feishu}/` - OTP 算法:`maxkey-starter/maxkey-starter-otp/` - 全量表结构:`sql/v4.2.0/maxkey.sql` + +--- + +## 落地实现索引(2026-09-14) + +| 能力 | 模块 | 端点 / 要点 | 回归 | +| --- | --- | --- | --- | +| SCIM 2.0 | `plugin-sso/src/scim.rs` | `/scim/v2/{ServiceProviderConfig,Schemas,ResourceTypes,Users,Groups}`(Users 全 CRUD + PATCH;Groups 派生自账号 `groups`) | `tests/maxkey-p1p2-e2e.sh` §A | +| CAS 1.0/2.0 | `plugin-sso/src/cas.rs` | `/cas/login`(302 签发 ST)、`/cas/validate`(纯文本)、`/cas/serviceValidate` + `/cas/proxyValidate`(XML);ST 共享内存 30s、单次有效、绑定 service | §B | +| LDAP / AD | `plugin-sso/src/ldap.rs` | **零新增依赖**:手工 BER/ASN.1 Simple Bind;env:`LDAP_ENABLED`/`LDAP_SERVER`/`LDAP_PORT`/`LDAP_BASE_DN`/`LDAP_USER_DN_TEMPLATE`/`LDAP_AUTO_CREATE`;未启用零行为变化 | §E(禁用回归) | +| 同步连接器 | `plugin-sso/src/sync.rs` | `POST /api/admin/sync/{dingtalk,workwechat,feishu}`(管理员,手动触发);标准库 TcpStream 拉取,归一化 `{users:[...]}` → upsert | §D(钉钉 mock) | +| 自助密码重置 | `plugin-sso/src/reset.rs` | `POST /api/public/forgot-password`、`/reset-password`;token 共享内存、单次有效、防账号枚举;发信可配置(日志 / `PASSWORD_RESET_TOKEN_SINK` 文件 / 生产 SMTP-webhook) | §C | +| ip2location | `plugin-sso/src/geo.rs` | 内嵌代表性 CN IPv4 CIDR 表 + 内网/保留段判定,零依赖粗判「内网/中国/海外」 | 审计日志 | + +> 环境变量白名单:nginx 默认剥离全部 env,`nginx.conf` / `nginx.test.conf` 已加 +> `env SYNC_*`、`env PASSWORD_RESET_*`(未声明则 worker 读不到)。 diff --git a/docs/roadmap.md b/docs/roadmap.md index ba5a87b..ee84788 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -189,3 +189,29 @@ - [x] 单点注销:`/logout`、`/sign/logout` 别名 + `redirect_uri` 302 回跳(client 白名单,未登记 400;302 同时清会话 cookie) - [x] 管理员重置密码入口统一过 `check_password`(原可绕过插件层 8 位策略) - [x] e2e:互通套新增 A2b/A2c/A2d/A2e/A8b 六条断言,六套 rc=0 + +## [x] v4:MaxKey 迁移 P1/P2 补齐(2026-09-14 完成) + +> 逐项依据:`docs/maxkey-migration-analysis.md`(P1 第 8–12 项、P2 第 17 项)。 +> 边界(已与需求方确认):需外部基建的能力只做**手动触发端点**,不引入常驻进程; +> WebAuthn/Passkey、SAML 2.0、社交/扫码、FormBased/TokenBased 四项**明确跳过**。 + +- [x] **SCIM 2.0 身份供给**(`plugin-sso/src/scim.rs`):ServiceProviderConfig / Schemas / + ResourceTypes / Users(全 CRUD + PATCH)/ Groups(派生自账号 `groups`) +- [x] **CAS 1.0 / 2.0 端点**(`cas.rs`):`/cas/login`(签发 ST 并 302 回跳)、`/cas/validate`(纯文本)、 + `/cas/serviceValidate` + `/cas/proxyValidate`(XML);ST 存共享内存、30s TTL、单次有效、绑定 service +- [x] **LDAP / AD 认证源**(`ldap.rs`):**零新增依赖**——手工 BER/ASN.1 Simple Bind; + env 配置,本地口令失败时兜底尝试、可选自动建号;**未启用零行为变化**(不破坏既有登录) +- [x] **同步连接器(钉钉/企微/飞书)**(`sync.rs`):`POST /api/admin/sync/` 手动触发, + 标准库 `TcpStream` 拉取 + 归一化契约 upsert;由外部 cron 调用,不引入后台进程 +- [x] **自助密码重置**(`reset.rs`):`POST /api/public/forgot-password` + `/reset-password`, + token 共享内存、单次有效、防账号枚举;发信可配置(日志 / SINK 文件 / 生产接 SMTP-webhook) +- [x] **ip2location 登录 IP 归属地**(`geo.rs`):内嵌 CN CIDR 精简版,审计记录归属地 +- [x] 新增第 7 套 e2e `tests/maxkey-p1p2-e2e.sh`(SCIM / CAS / 密码重置 / 同步 / LDAP 禁用回归,21 项); + **七套全绿 rc=0** +- [x] 修复 `http::redirect` 空 body 触发 `NGX_ERROR`(CAS 302 失效根因);全仓修 `$var` 紧跟全角字符的 shell 坑 + +> 踩坑留档:① nginx 默认剥离 env,新模块用到的 `SYNC_*` / `PASSWORD_RESET_*` 必须在 conf 里显式 `env`; +> ② 重置类 e2e 不得改 admin 种子口令(`123456` 过不了 8 位策略、无法还原),改用一次性账号闭环; +> ③ 同步 mock 端口避开 nginx 已占用的 18097。 + diff --git a/scripts/load-env.sh b/scripts/load-env.sh index 367f499..45abb01 100755 --- a/scripts/load-env.sh +++ b/scripts/load-env.sh @@ -44,7 +44,7 @@ if [ -f "$_LOAD_ENV_FILE" ]; then done < "$_LOAD_ENV_FILE" unset _line _kv _k _v else - echo " [env] 未找到 $_LOAD_ENV_FILE(可选):cp .env.example .env 后按需修改" >&2 + echo " [env] 未找到 ${_LOAD_ENV_FILE}(可选):cp .env.example .env 后按需修改" >&2 fi unset _LOAD_ENV_DIR _LOAD_ENV_ROOT _LOAD_ENV_FILE diff --git a/scripts/local-serve.sh b/scripts/local-serve.sh index 24d68fc..2b0f969 100755 --- a/scripts/local-serve.sh +++ b/scripts/local-serve.sh @@ -53,10 +53,10 @@ case "${1:-start}" in esac [ -x "$NGINX_BIN" ] || { echo "!! nginx 二进制缺失:$NGINX_BIN" >&2; exit 1; } -[ -f "$MODULE" ] || { echo "!! Rust 模块缺失:$MODULE(先 cargo build --release)" >&2; exit 1; } +[ -f "$MODULE" ] || { echo "!! Rust 模块缺失:${MODULE}(先 cargo build --release)" >&2; exit 1; } [ -f "$CONF" ] || { # 没现成配置就复用 run-local-e2e.sh 的生成逻辑(它会连带物化种子数据) - echo "## 没有 $CONF,先跑一次 run-local-e2e.sh 生成配置 ..." + echo "## 没有 ${CONF},先跑一次 run-local-e2e.sh 生成配置 ..." bash "$HERE/run-local-e2e.sh" --keep > /dev/null 2>&1 || true if [ -f "$PID" ]; then kill "$(cat "$PID")" 2>/dev/null || true; fi pkill -f "demo-system/app.py" 2>/dev/null || true @@ -73,7 +73,7 @@ for i in $(seq 1 20); do done code="$(curl -s -o /dev/null -w '%{http_code}' "${OAUTH_ISSUER}/.well-known/openid-configuration" || true)" if [ "$code" != "200" ]; then - echo "!! 网关未就绪(HTTP $code),日志:" >&2; tail -30 "$ERR_LOG" >&2; exit 1 + echo "!! 网关未就绪(HTTP ${code}),日志:" >&2; tail -30 "$ERR_LOG" >&2; exit 1 fi echo "started: $OAUTH_ISSUER (discovery=$code)" diff --git a/scripts/run-local-e2e.sh b/scripts/run-local-e2e.sh index 589f973..4f048f5 100755 --- a/scripts/run-local-e2e.sh +++ b/scripts/run-local-e2e.sh @@ -148,6 +148,13 @@ export ADMIN_USER="${ADMIN_USER:-admin}" export ADMIN_PASSWORD="${ADMIN_PASSWORD:-123456}" export ALICE_PASSWORD="${ALICE_PASSWORD:-alice123}" +# P1/P2 新增能力的本地联调开关(缺省值即可离线跑通,无需真实目录/邮件服务): +# - 同步连接器拉取的目录源地址(e2e 起本地 mock 服务在该端口;注意 18097 已被 +# echo-backend 占用,故 mock 用 18088,避免端口冲突导致 nginx 回显后端吞掉同步拉取) +export SYNC_DINGTALK_URL="${SYNC_DINGTALK_URL:-http://127.0.0.1:18088/users}" +# - 自助密码重置:把一次性 token 落到本地文件(e2e 取用,不含 PII) +export PASSWORD_RESET_TOKEN_SINK="${PASSWORD_RESET_TOKEN_SINK:-/tmp/sso-pwdreset-token.txt}" + # 关掉可能残留的旧实例 if [ -f "$PID" ]; then kill "$(cat "$PID")" 2>/dev/null || true; sleep 0.5; fi pkill -f "demo-system/app.py" 2>/dev/null || true @@ -235,6 +242,10 @@ echo echo "############### [6/6] 域名插件:申请 / 审核 / 转发 ###############" bash "$ROOT/tests/domain-e2e.sh" "$HOST_IDP" "$HOST_DOMAIN" "$DATA_DIR" RC6=$? +echo +echo "############### [7/7] MaxKey P1/P2 新增能力(SCIM/CAS/密码重置/同步/LDAP) ###############" +bash "$ROOT/tests/maxkey-p1p2-e2e.sh" "$HOST_IDP" "$DATA_DIR" +RC7=$? set -e [ "$RC1" != "0" ] && RC=1 [ "$RC2" != "0" ] && RC=1 @@ -242,9 +253,10 @@ set -e [ "$RC4" != "0" ] && RC=1 [ "$RC5" != "0" ] && RC=1 [ "$RC6" != "0" ] && RC=1 +[ "$RC7" != "0" ] && RC=1 echo -echo "## [summary] 基线 rc=$RC1 互通/接入 rc=$RC2 管理接口 rc=$RC3 RS256/JWKS rc=$RC4 账号批量维护 rc=$RC5 域名插件 rc=$RC6" +echo "## [summary] 基线 rc=$RC1 互通/接入 rc=$RC2 管理接口 rc=$RC3 RS256/JWKS rc=$RC4 账号批量维护 rc=$RC5 域名插件 rc=$RC6 P1/P2 新增 rc=$RC7" if [ "$KEEP" = "1" ]; then echo "## [done] 测试完成 (rc=$RC);进程保留,手动排查:" echo " kill $NGX_PID $DEMO_PID" diff --git a/source/conf/nginx.conf b/source/conf/nginx.conf index 3ebfbb0..3778ce2 100644 --- a/source/conf/nginx.conf +++ b/source/conf/nginx.conf @@ -25,6 +25,12 @@ env ADMIN_INIT_PASSWORD; # 播种管理员口令,仅首次启动用 env OAUTH_SIGNING_SECRET; # HS256 对称密钥;不设则每次重启令牌全失效 env OAUTH_ISSUER; # 令牌 iss 与 discovery 的 issuer,必须等于对外访问地址 env OAUTH_COOKIE_DOMAIN; # 跨子域 SSO 用,如 .example.com +# P1/P2 新增模块的 worker 可见环境变量(nginx 默认剥离全部 env,必须显式白名单) +env SYNC_DINGTALK_URL; # 同步连接器:钉钉用户目录源地址 +env SYNC_WORKWECHAT_URL; # 同步连接器:企业微信用户目录源地址 +env SYNC_FEISHU_URL; # 同步连接器:飞书用户目录源地址 +env PASSWORD_RESET_TOKEN_SINK;# 自助密码重置:token 落盘路径(不设则仅日志输出) +env PASSWORD_RESET_TTL; # 自助密码重置:token 有效期秒(可选,缺省 1800) events { worker_connections 2048; diff --git a/source/conf/nginx.test.conf b/source/conf/nginx.test.conf index 3dd73e1..bf8eeb3 100644 --- a/source/conf/nginx.test.conf +++ b/source/conf/nginx.test.conf @@ -33,6 +33,16 @@ env OAUTH_SIGNING_SECRET; env OAUTH_ISSUER; env OAUTH_COOKIE_DOMAIN; +# P1/P2 新增模块的 worker 可见环境变量(nginx 默认剥离全部 env,必须显式白名单)。 +# 同步连接器:各 provider 的用户目录 URL(未声明则走各平台默认开放端点)。 +env SYNC_DINGTALK_URL; +env SYNC_WORKWECHAT_URL; +env SYNC_FEISHU_URL; +# 自助密码重置:token 落盘路径(未声明则仅在日志输出,不落盘)。 +env PASSWORD_RESET_TOKEN_SINK; +# 自助密码重置:token 有效期秒(可选,缺省 1800)。 +env PASSWORD_RESET_TTL; + events { worker_connections 1024; } diff --git a/source/rust/crates/ipass-core/src/http.rs b/source/rust/crates/ipass-core/src/http.rs index 14878e3..ada3ff2 100644 --- a/source/rust/crates/ipass-core/src/http.rs +++ b/source/rust/crates/ipass-core/src/http.rs @@ -152,6 +152,36 @@ pub fn params(r: *mut ngx_http_request_t) -> HashMap { map } +/// 读取并解析请求体为 JSON(`Content-Type: application/json` 时)。 +/// +/// 非 JSON 体或解析失败返回 `None`——调用方据此回退到 `params` 或报错。 +/// SCIM / CAS / 同步连接器 / 自助密码重置等需要嵌套 JSON(数组、对象)的 +/// 端点用它取代 `params`(后者只认标量值)。 +pub fn json_body(r: *mut ngx_http_request_t) -> Option { + let body = unsafe { collect_body(r) }; + if body.is_empty() { + return None; + } + serde_json::from_slice::(&body).ok() +} + +/// 合并 query 与 JSON 请求体为单一 `Value::Object`: +/// JSON 体的嵌套结构原样保留,query 的标量覆盖同名顶层键。 +/// +/// SCIM/PATCH 等既可能走 form 也可能走 JSON 的场景统一入口。 +pub fn body_object(r: *mut ngx_http_request_t) -> Value { + let mut obj = serde_json::Map::new(); + for (k, v) in util::parse_kv(&args_raw(r)) { + obj.insert(k, Value::String(v)); + } + if let Some(Value::Object(b)) = json_body(r) { + for (k, v) in b { + obj.insert(k, v); + } + } + Value::Object(obj) +} + // =========================================================================== // 响应 // =========================================================================== @@ -198,6 +228,49 @@ pub fn send(r: *mut ngx_http_request_t, status: HTTPStatus, body: &str) -> Statu send_with(r, status, body, &[]) } +/// 发送带自定义 Content-Type 的响应体(CAS 的 `text/plain` / `application/xml` +/// 等不走 JSON 信封的场景用)。 +pub fn send_ct( + r: *mut ngx_http_request_t, + status: HTTPStatus, + body: &str, + content_type: &str, +) -> Status { + // SAFETY: r 有效 + unsafe { + let request = Request::from_ngx_http_request(r); + let pool = request.pool(); + + let mut buf = match pool.create_buffer_from_str(body) { + Some(b) => b, + None => return Status::NGX_ERROR, + }; + buf.set_last_buf(true); + + let mut chain = ngx_chain_t { buf: buf.as_ngx_buf_mut(), next: ptr::null_mut() }; + + request.set_status(status); + request.add_header_out("Content-Type", content_type); + request.add_header_out("Cache-Control", "no-store"); + request.set_content_length_n(body.len()); + + let st = request.send_header(); + if st != Status::NGX_OK { + return st; + } + request.output_filter(&mut chain) + } +} + +/// 302 重定向(CAS `/cas/login` 签发 ST 后跳回 service)。 +/// +/// **注意**:body 必须非空——`pool.create_buffer_from_str("")` 在 nginx 内存池里 +/// 分配 0 长度 buffer 会返回 `None`,使 `send_with` 返回 `NGX_ERROR`,导致 302 +/// 根本不发出(curl 拿不到 `Location`)。所以这里给一个单空格占位 body。 +pub fn redirect(r: *mut ngx_http_request_t, location: &str) -> Status { + send_with(r, HTTPStatus::MOVED_TEMPORARILY, " ", &[("Location", location)]) +} + /// 统一成功响应:`{code:200, msg, data}` pub fn ok(r: *mut ngx_http_request_t, data: Value, msg: &str) -> Status { let body = json!({ "code": 200, "msg": msg, "data": data }).to_string(); diff --git a/source/rust/crates/plugin-sso/src/api.rs b/source/rust/crates/plugin-sso/src/api.rs index c5ecbd3..c6b6c40 100644 --- a/source/rust/crates/plugin-sso/src/api.rs +++ b/source/rust/crates/plugin-sso/src/api.rs @@ -46,7 +46,7 @@ pub enum Actor { impl Actor { /// 操作者名称:审计日志用 - fn admin_name(&self) -> &str { + pub(crate) fn admin_name(&self) -> &str { match self { Actor::Admin(u) => &u.username, Actor::User(u) => &u.username, @@ -56,13 +56,13 @@ impl Actor { } #[derive(Clone, Copy, PartialEq)] -enum Guard { +pub(crate) enum Guard { Public, User, Admin, } -type Handler = fn(*mut ngx_http_request_t, Actor) -> Status; +pub(crate) type Handler = fn(*mut ngx_http_request_t, Actor) -> Status; /// 路由表。刻意用精确匹配而非正则——接口路径是固定的, /// 正则只会引入「写错锚点导致前缀误匹配」的风险。 @@ -144,7 +144,25 @@ fn route(method: &str, uri: &str) -> Option<(Guard, Handler)> { ("POST", "/oauth2.0/accessToken") => (Guard::Public, h_oauth_token_v20), ("GET", "/oauth2.0/profile") => (Guard::Public, h_oauth_me_v20), ("POST", "/oauth2.0/profile") => (Guard::Public, h_oauth_me_v20), - _ => return None, + + // ---- SCIM 2.0 身份供给(路径含 {id} 变量,走前缀匹配)---------- + // ---- CAS 1.0/2.0 协议端点(精确 GET,走独立路由)---------------- + // ---- 自助密码重置(公开端点,精确 POST)------------------------ + _ => { + if let Some(e) = crate::scim::route(method, uri) { + return Some(e); + } + if let Some(e) = crate::cas::route(method, uri) { + return Some(e); + } + if let Some(e) = crate::reset::route(method, uri) { + return Some(e); + } + if let Some(e) = crate::sync::route(method, uri) { + return Some(e); + } + return None; + } }; Some(entry) } @@ -323,7 +341,41 @@ fn h_login(r: *mut ngx_http_request_t, _actor: Actor) -> Status { } } - let Some(user) = users::get(&username) else { + let mut user = users::get(&username); + let local_ok = match &user { + Some(u) => util::verify_password(&password, &u.salt, &u.pwd_hash), + None => false, + }; + + // 本地口令失败时,若启用 LDAP 认证源则尝试目录绑定(口令不落本网关) + let mut ldap_ok = false; + if !local_ok && crate::ldap::should_try() { + if crate::ldap::authenticate(&username, &password) { + ldap_ok = true; + // LDAP 认证成功但本地无账号:按需自动建账号 + if user.is_none() { + if crate::ldap::auto_create() { + match accounts::create(&username, "", &util::gen_key(), "user", "", "", "", "") { + Ok(u) => user = Some(u), + Err(e) => { + audit_login!(&username, false, &format!("LDAP 自动建账号失败:{e}")); + return http::fail(r, HTTPStatus::UNAUTHORIZED, "账号或密码错误"); + } + } + } else { + audit_login!(&username, false, "LDAP 认证成功但本地无账号且不自动建"); + return http::fail(r, HTTPStatus::UNAUTHORIZED, "账号或密码错误"); + } + } + // LDAP 认证成功:清空本地失败计数(避免本地误累计) + state::clear_login_fail(&ip); + let _ = accounts::clear_login_failure(&username); + } + } + + let authenticated = local_ok || ldap_ok; + + let Some(user) = user else { state::bump_login_fail(&ip, now); util::log_warn(&format!("[api] 登录失败 user={username} client={ip}")); audit_login!(&username, false, "账号不存在"); @@ -343,7 +395,7 @@ fn h_login(r: *mut ngx_http_request_t, _actor: Actor) -> Status { ); } - if !util::verify_password(&password, &user.salt, &user.pwd_hash) { + if !authenticated { state::bump_login_fail(&ip, now); // 账号维度累计:达到阈值即锁定(用户必然存在,失败只可能是锁不可用) let mut detail = "密码错误".to_owned(); diff --git a/source/rust/crates/plugin-sso/src/audit.rs b/source/rust/crates/plugin-sso/src/audit.rs index 75f6994..2ea8c05 100644 --- a/source/rust/crates/plugin-sso/src/audit.rs +++ b/source/rust/crates/plugin-sso/src/audit.rs @@ -51,6 +51,7 @@ pub fn log(action: &str, actor: &str, target: &str, ok: bool, ip: &str, ua: &str "target": target, "ok": ok, "ip": ip, + "region": crate::geo::lookup(ip), "ua": ua, "detail": detail, }); diff --git a/source/rust/crates/plugin-sso/src/cas.rs b/source/rust/crates/plugin-sso/src/cas.rs new file mode 100644 index 0000000..ba4e7c5 --- /dev/null +++ b/source/rust/crates/plugin-sso/src/cas.rs @@ -0,0 +1,161 @@ +//! CAS 1.0 / 2.0 协议端点(对齐 MaxKey `maxkey-cas`)。 +//! +//! 让既有的 CAS 客户端(老 Java 应用、Confluence、Jenkins 等)用标准 CAS 协议 +//! 接入本网关做单点登录,无需改写客户端。本实现为**精简版**: +//! +//! * 身份来源复用本网关的 SSO 会话(管理台 session / 终端用户 sso session 都认); +//! * ST(Service Ticket)签发后存共享内存,单次有效、短 TTL; +//! * `/cas/serviceValidate` 走 CAS 2.0 XML,`/cas/validate` 走 CAS 1.0 纯文本, +//! `/cas/proxyValidate` 与 serviceValidate 同形(忽略代理链)。 +//! +//! 鉴权全部 `Guard::Public`:login 自己读会话、validate 靠 ticket,都不依赖调用方会话。 + +use ngx::ffi::ngx_http_request_t; + +use ipass_core::http; +use ipass_core::session; +use ipass_core::state; +use ipass_core::util; +use ngx::core::Status; +use ngx::http::HTTPStatus; + +use crate::audit; + +/// ST 有效期(秒)。CAS 票据本就单次、短时,30s 足够客户端拿到后立刻来校验。 +const CAS_TICKET_TTL: i64 = 30; +/// ST 共享内存键前缀:`cas:st:` +const KEY_CAS_ST: &[u8] = b"cas:st:"; + +/// 路由:CAS 端点路径固定,精确匹配。 +pub fn route(method: &str, uri: &str) -> Option<(crate::api::Guard, crate::api::Handler)> { + if method != "GET" { + return None; + } + let g = crate::api::Guard::Public; + match uri { + "/cas/login" => Some((g, h_cas_login)), + "/cas/logout" => Some((g, h_cas_logout)), + "/cas/validate" => Some((g, h_cas_validate)), + "/cas/serviceValidate" => Some((g, h_cas_service_validate)), + "/cas/proxyValidate" => Some((g, h_cas_proxy_validate)), + _ => None, + } +} + +/// 生成 ST:`ST-`。 +fn new_ticket() -> String { + format!("ST-{}", util::gen_key()) +} + +/// 把 ticket 与服务绑定写入共享内存:payload = `username\nservice`。 +fn issue_ticket(ticket: &str, username: &str, service: &str, now: i64) -> bool { + let payload = format!("{username}\n{service}"); + state::put(KEY_CAS_ST, ticket.as_bytes(), payload.as_bytes(), now + CAS_TICKET_TTL) +} + +/// 消费 ticket:校验存在、未过期、service 匹配,返回用户名(一次性)。 +fn consume_ticket(ticket: &str, service: &str, now: i64) -> Option { + let (payload, exp) = state::get(KEY_CAS_ST, ticket.as_bytes())?; + if exp > 0 && exp <= now { + state::remove(KEY_CAS_ST, ticket.as_bytes()); + return None; + } + let (user, bound) = payload.split_once('\n')?; + if bound != service { + // service 不匹配:票据不可跨服务使用(防 fixation) + return None; + } + // 单次有效:消费即删 + state::remove(KEY_CAS_ST, ticket.as_bytes()); + Some(user.to_owned()) +} + +/// `/cas/login?service=URL`:已登录则签发 ST 并 302 回 service?ticket=ST; +/// 未登录则 302 到本网关登录页。无 service 时直接返回 ST(供程序化握手)。 +fn h_cas_login(r: *mut ngx_http_request_t, _actor: crate::api::Actor) -> Status { + let p = http::params(r); + let service = p.get("service").map(String::as_str).unwrap_or("").to_owned(); + let ip = http::remote_addr(r); + let ua = http::header(r, "user-agent").unwrap_or_default(); + + let cookie = http::header(r, "cookie"); + let Some(user) = session::authenticate(cookie.as_deref()) else { + // 未登录:跳登录页(浏览器走完登录后会带着会话回来重放本请求)。 + // 无 service 时无法回跳,直接 401 让调用方先建会话。 + if service.is_empty() { + return http::fail(r, HTTPStatus::UNAUTHORIZED, "未登录或会话已过期,请先登录"); + } + audit::log("cas.login.deny", "", "", false, &ip, &ua, "no session"); + return http::redirect(r, "/login"); + }; + + let ticket = new_ticket(); + let now = util::now(); + if !issue_ticket(&ticket, &user, &service, now) { + return http::fail(r, HTTPStatus::INTERNAL_SERVER_ERROR, "票据签发失败"); + } + audit::log("cas.login", &user, &user, true, &ip, &ua, &service); + + if service.is_empty() { + // 程序化握手:直接回 ST(JSON 信封,便于脚本取出) + return http::ok(r, serde_json::json!({ "ticket": ticket, "user": user }), "ok"); + } + // 回跳 service?ticket= / &ticket= + let sep = if service.contains('?') { '&' } else { '?' }; + let location = format!("{service}{sep}ticket={ticket}"); + http::redirect(r, &location) +} + +/// `/cas/logout`:销毁本会话,返回 200。 +fn h_cas_logout(r: *mut ngx_http_request_t, _actor: crate::api::Actor) -> Status { + let cookie = http::header(r, "cookie"); + session::destroy(cookie.as_deref()); + http::ok(r, serde_json::json!({}), "已退出 CAS 单点登录") +} + +/// `/cas/validate`:CAS 1.0 纯文本 `yes\n` / `no\n`。 +fn h_cas_validate(r: *mut ngx_http_request_t, _actor: crate::api::Actor) -> Status { + let p = http::params(r); + let service = p.get("service").map(String::as_str).unwrap_or("").to_owned(); + let ticket = p.get("ticket").map(String::as_str).unwrap_or("").to_owned(); + let now = util::now(); + + match consume_ticket(&ticket, &service, now) { + Some(user) => http::send_ct(r, HTTPStatus::OK, &format!("yes\n{user}\n"), "text/plain; charset=utf-8"), + None => http::send_ct(r, HTTPStatus::OK, "no\n", "text/plain; charset=utf-8"), + } +} + +/// `/cas/serviceValidate`:CAS 2.0 XML。 +fn h_cas_service_validate(r: *mut ngx_http_request_t, _actor: crate::api::Actor) -> Status { + let p = http::params(r); + let service = p.get("service").map(String::as_str).unwrap_or("").to_owned(); + let ticket = p.get("ticket").map(String::as_str).unwrap_or("").to_owned(); + let now = util::now(); + + match consume_ticket(&ticket, &service, now) { + Some(user) => { + let body = format!( + "\n\ + \x20 \n\ + \x20\x20 {user}\n\ + \x20 \n\ + \n" + ); + http::send_ct(r, HTTPStatus::OK, &body, "application/xml; charset=utf-8") + } + None => { + let body = format!( + "\n\ + \x20 ticket 无效或已过期\n\ + \n" + ); + http::send_ct(r, HTTPStatus::OK, &body, "application/xml; charset=utf-8") + } + } +} + +/// `/cas/proxyValidate`:与 serviceValidate 同形(本项目不发放 PT,忽略代理链)。 +fn h_cas_proxy_validate(r: *mut ngx_http_request_t, _actor: crate::api::Actor) -> Status { + h_cas_service_validate(r, _actor) +} diff --git a/source/rust/crates/plugin-sso/src/geo.rs b/source/rust/crates/plugin-sso/src/geo.rs new file mode 100644 index 0000000..98928ab --- /dev/null +++ b/source/rust/crates/plugin-sso/src/geo.rs @@ -0,0 +1,152 @@ +//! 登录 IP 归属地(ip2location 精简版)。 +//! +//! MaxKey 内置登录 IP 归属地(ip2location)。完整 ip2location 需要商业 GeoIP +//! 数据库文件(数 MB ~ 数十 MB),与本项目「零外部依赖 / 单容器」约束冲突, +//! 因此这里做**内嵌精简版**: +//! +//! * 内网 / 保留地址(RFC 1918、loopback、link-local 等)直接归类为「内网」; +//! * 内嵌一份**代表性**的 CN IPv4 CIDR 表(非全量),命中即标「中国」; +//! * 其余归「海外」。 +//! +//! 这是「归属地做精致了再加」的第一步:后续若要精确,把 DB 文件放 `data_dir` +//! 下、在此处替换为查表即可,调用方(audit)无需改动。 + +/// 内嵌的 CN IPv4 CIDR 表(代表性片段,非全量 APNIC 分配)。 +/// 形如 `"1.2.3.0/24"`。仅用于"是否在中国"的粗判。 +const CN_CIDRS: &[&str] = &[ + "1.0.1.0/24", "1.0.2.0/23", "1.2.4.0/22", "1.8.0.0/16", "1.24.0.0/13", + "1.56.0.0/13", "1.68.0.0/14", "1.80.0.0/13", "1.92.0.0/14", "1.116.0.0/14", + "1.180.0.0/14", "1.188.0.0/14", "1.192.0.0/13", "1.202.0.0/15", "1.204.0.0/14", + "14.0.0.0/8", "27.0.0.0/10", "36.0.0.0/8", "39.0.0.0/8", "42.0.0.0/8", + "43.0.0.0/8", "45.0.0.0/8", "49.0.0.0/8", "58.0.0.0/7", "59.32.0.0/11", + "60.0.0.0/8", "61.0.0.0/8", "101.0.0.0/8", "103.0.0.0/8", "106.0.0.0/8", + "110.0.0.0/7", "111.0.0.0/8", "112.0.0.0/7", "113.0.0.0/8", "114.0.0.0/8", + "115.0.0.0/8", "116.0.0.0/8", "117.0.0.0/8", "118.0.0.0/8", "119.0.0.0/8", + "120.0.0.0/8", "121.0.0.0/8", "122.0.0.0/8", "123.0.0.0/8", "124.0.0.0/8", + "125.0.0.0/8", "129.0.0.0/8", "130.0.0.0/8", "131.0.0.0/8", "132.0.0.0/8", + "133.0.0.0/8", "134.0.0.0/8", "135.0.0.0/8", "136.0.0.0/8", "137.0.0.0/8", + "138.0.0.0/8", "139.0.0.0/8", "140.0.0.0/8", "144.0.0.0/8", "149.0.0.0/8", + "150.0.0.0/8", "151.0.0.0/8", "152.0.0.0/8", "153.0.0.0/8", "154.0.0.0/8", + "155.0.0.0/8", "156.0.0.0/8", "157.0.0.0/8", "159.0.0.0/8", "160.0.0.0/8", + "161.0.0.0/8", "162.0.0.0/8", "163.0.0.0/8", "164.0.0.0/8", "166.0.0.0/8", + "167.0.0.0/8", "168.0.0.0/8", "169.0.0.0/8", "170.0.0.0/8", "171.0.0.0/8", + "172.0.0.0/8", "175.0.0.0/8", "180.0.0.0/8", "182.0.0.0/8", "183.0.0.0/8", + "184.0.0.0/8", "185.0.0.0/8", "186.0.0.0/8", "189.0.0.0/8", "190.0.0.0/8", + "192.0.0.0/8", "193.0.0.0/8", "196.0.0.0/8", "198.0.0.0/8", "202.0.0.0/8", + "203.0.0.0/8", "210.0.0.0/7", "211.0.0.0/8", "218.0.0.0/7", "219.0.0.0/8", + "220.0.0.0/8", "221.0.0.0/8", "222.0.0.0/8", "223.0.0.0/8", +]; + +/// 把一个 IPv4 地址按 `.` 拆成 4 个 u8;非法返回 None。 +fn parse_v4(ip: &str) -> Option<[u8; 4]> { + let mut parts = [0u8; 4]; + let mut i = 0; + for seg in ip.split('.') { + if i >= 4 { + return None; + } + let n: u8 = seg.parse().ok()?; + parts[i] = n; + i += 1; + } + if i == 4 { + Some(parts) + } else { + None + } +} + +/// 判断 `ip` 是否属于 CIDR `a.b.c.d/n`。 +fn in_cidr(ip: [u8; 4], cidr: &str) -> bool { + let Some((net, plen)) = cidr.split_once('/') else { + return false; + }; + let prefix = match parse_v4(net) { + Some(p) => p, + None => return false, + }; + let bits: u32 = match plen.parse().ok() { + Some(b) => b, + None => return false, + }; + if bits > 32 { + return false; + } + let ip_u32 = u32::from_be_bytes(ip); + let net_u32 = u32::from_be_bytes(prefix); + let mask: u32 = if bits == 0 { + 0 + } else { + (!0u32) << (32 - bits) + }; + (ip_u32 & mask) == (net_u32 & mask) +} + +/// 是否为内网 / 保留地址(命中即"内网",无需查表)。 +fn is_private(ip: [u8; 4]) -> bool { + match ip { + [10, ..] => true, + [127, ..] => true, + [169, 254, ..] => true, + [172, 16..=31, ..] => true, + [192, 168, ..] => true, + [0, ..] => true, + [100, 64..=127, ..] => true, // CGNAT + _ => false, + } +} + +/// 解析登录 IP,返回归属地文本(如「中国」「内网」「海外」「未知」)。 +/// +/// 设计上**不依赖任何外部库**:IPv4 字符串解析 + CIDR 匹配即可。 +/// IPv6 暂统一回「海外」(精简版不做 v6 GeoIP)。 +pub fn lookup(ip: &str) -> String { + let ip = ip.trim(); + // 去掉可能的端口后缀(remote_addr 有时带端口) + let ip = ip.split(':').next().unwrap_or(ip); + match parse_v4(ip) { + Some(addr) => { + if is_private(addr) { + return "内网".to_owned(); + } + if CN_CIDRS.iter().any(|c| in_cidr(addr, c)) { + return "中国".to_owned(); + } + "海外".to_owned() + } + None => { + if ip.is_empty() || ip == "-" { + "未知".to_owned() + } else { + "海外".to_owned() + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn private_ranges() { + assert_eq!(lookup("127.0.0.1"), "内网"); + assert_eq!(lookup("192.168.1.50"), "内网"); + assert_eq!(lookup("10.0.0.1"), "内网"); + assert_eq!(lookup("172.16.5.5"), "内网"); + } + + #[test] + fn cn_range() { + // 36.0.0.0/8 在表中 + assert_eq!(lookup("36.110.0.1"), "中国"); + assert_eq!(lookup("116.204.0.1"), "中国"); + } + + #[test] + fn foreign() { + assert_eq!(lookup("8.8.8.8"), "海外"); + assert_eq!(lookup("-"), "未知"); + assert_eq!(lookup(""), "未知"); + } +} diff --git a/source/rust/crates/plugin-sso/src/ldap.rs b/source/rust/crates/plugin-sso/src/ldap.rs new file mode 100644 index 0000000..2690e18 --- /dev/null +++ b/source/rust/crates/plugin-sso/src/ldap.rs @@ -0,0 +1,252 @@ +//! LDAP / AD 认证源(对齐 MaxKey `maxkey-ldap`)。 +//! +//! 把企业目录(Active Directory / OpenLDAP)作为**认证源**接入:用户用目录里的 +//! 账号密码登录管理台,口令不在本网关落地(由 AD 校验)。 +//! +//! **零外部依赖**:不引 ldap3(其 async/tokio 模型与 nginx 单线程 FFI 冲突), +//! 这里手工编码 LDAP 的 BER/ASN.1 简单绑定(Simple Bind)——只够做「bind 成功 / +//! 失败」判定,不拉属性。属性同步走 [`crate::sync`] 连接器。 +//! +//! 配置(env,全部可选): +//! LDAP_ENABLED=1 开启 +//! LDAP_SERVER=ldap.corp.com 目录服务器 +//! LDAP_PORT=389 端口(仅明文 389;TLS 由上层终结) +//! LDAP_BASE_DN=dc=corp,dc=com 基准 DN +//! LDAP_USER_DN_TEMPLATE=uid={user},{base} 用户 DN 模板 +//! LDAP_AUTO_CREATE=1 目录认证成功但本地无账号时自动建账号 +//! +//! 安全性:连接超时 3s,任何错误都降级为「认证失败」(绝不 panic、绝不放行)。 + +use std::io::{Read, Write}; +use std::net::TcpStream; +use std::time::Duration; + +use ipass_core::util; + +/// 配置读取 +fn enabled() -> bool { + std::env::var("LDAP_ENABLED").map(|v| v.trim() == "1").unwrap_or(false) +} + +pub(crate) fn auto_create() -> bool { + std::env::var("LDAP_AUTO_CREATE").map(|v| v.trim() == "1").unwrap_or(false) +} + +fn server() -> String { + std::env::var("LDAP_SERVER").unwrap_or_default() +} + +fn port() -> u16 { + std::env::var("LDAP_PORT") + .ok() + .and_then(|v| v.trim().parse::().ok()) + .unwrap_or(389) +} + +fn user_dn(username: &str) -> String { + let base = std::env::var("LDAP_BASE_DN").unwrap_or_default(); + let tpl = std::env::var("LDAP_USER_DN_TEMPLATE") + .unwrap_or_else(|_| "uid={user},{base}".to_owned()); + tpl.replace("{user}", username).replace("{base}", &base) +} + +// =========================================================================== +// BER / ASN.1 极简编解码 +// =========================================================================== + +/// 定长 TLV:tag + 长度 + 内容。长度 < 128 用单字节,否则长形式。 +fn ber_len(n: usize) -> Vec { + if n < 128 { + vec![n as u8] + } else { + let mut bytes = Vec::new(); + let mut v = n; + while v > 0 { + bytes.push((v & 0xff) as u8); + v >>= 8; + } + bytes.reverse(); + let mut out = vec![0x80 | bytes.len() as u8]; + out.extend_from_slice(&bytes); + out + } +} + +fn ber_seq(content: &[u8]) -> Vec { + let mut v = vec![0x30]; + v.extend_from_slice(&ber_len(content.len())); + v.extend_from_slice(content); + v +} + +fn ber_int(n: i64) -> Vec { + // 最小字节(补码),小正整数走一个字节 + let mut b = (n as i64).to_be_bytes().to_vec(); + while b.len() > 1 && b[0] == 0 { + b.remove(0); + } + let mut v = vec![0x02]; + v.extend_from_slice(&ber_len(b.len())); + v.extend_from_slice(&b); + v +} + +fn ber_octet(s: &[u8]) -> Vec { + let mut v = vec![0x04]; + v.extend_from_slice(&ber_len(s.len())); + v.extend_from_slice(s); + v +} + +/// [APPLICATION n] 构造(如 BindRequest=0x60, BindResponse=0x61) +fn ber_app(app: u8, content: &[u8]) -> Vec { + let mut v = vec![0x60 | app]; + v.extend_from_slice(&ber_len(content.len())); + v.extend_from_slice(content); + v +} + +/// [CONTEXT n] 构造(如 simple 认证 = 0x80) +fn ber_ctx(ctx: u8, content: &[u8]) -> Vec { + let mut v = vec![0x80 | ctx]; + v.extend_from_slice(&ber_len(content.len())); + v.extend_from_slice(content); + v +} + +/// 解析一个 TLV,返回 (tag, 内容起始, 内容结束) +fn read_tlv(buf: &[u8], pos: usize) -> Option<(u8, usize, usize)> { + let tag = *buf.get(pos)?; + let mut p = pos + 1; + let first = *buf.get(p)? as usize; + let len = if first & 0x80 == 0 { + p += 1; + first + } else { + let nbytes = first & 0x7f; + p += 1; + let mut l = 0usize; + for _ in 0..nbytes { + l = (l << 8) | *buf.get(p)? as usize; + p += 1; + } + l + }; + let start = p; + let end = start + len; + if end > buf.len() { + return None; + } + Some((tag, start, end)) +} + +/// 从 BindResponse 里取 resultCode(ENUMERATED,tag 0x0A)。 +/// 简单做法:在整条消息里找第一个 0x0A,读其整数值(BindResponse 中唯一 ENUMERATED)。 +fn result_code(msg: &[u8]) -> Option { + let mut i = 0; + while i < msg.len() { + if msg[i] == 0x0a { + // 长度(单字节即可,resultCode 很小) + let l = *msg.get(i + 1)? as usize; + let val_pos = i + 2; + if val_pos + l <= msg.len() { + let mut v: u32 = 0; + for k in 0..l { + v = (v << 8) | (*msg.get(val_pos + k)? as u32); + } + return Some(v as u8); + } + } + i += 1; + } + None +} + +/// 解析整条 LDAPMessage(外层 SEQUENCE 长度可能跨多个 read)。 +fn take_message(buf: &[u8]) -> Option<&[u8]> { + let (_, _start, end) = read_tlv(buf, 0)?; + if end <= buf.len() { + Some(&buf[..end]) + } else { + None + } +} + +// =========================================================================== +// 绑定 +// =========================================================================== + +/// 与目录服务器做一次 Simple Bind。成功返回 Ok(()),否则 Err。 +fn bind(dn: &str, password: &str) -> Result<(), String> { + let server = server(); + if server.is_empty() { + return Err("LDAP_SERVER 未配置".to_owned()); + } + let mut stream = TcpStream::connect((server.as_str(), port())) + .map_err(|e| format!("连接目录服务器失败:{e}"))?; + stream.set_read_timeout(Some(Duration::from_secs(3))).ok(); + stream.set_write_timeout(Some(Duration::from_secs(3))).ok(); + + // BindRequest 内容 = version(INT 3) + name(OCTET DN) + authentication(ctx[0]=simple, password) + let mut content = ber_int(3); + content.extend_from_slice(&ber_octet(dn.as_bytes())); + content.extend_from_slice(&ber_ctx(0, password.as_bytes())); + let bindreq = ber_app(0, &content); + // LDAPMessage = SEQUENCE { messageID INT 1, bindRequest } + let mut msg = ber_seq(&ber_int(1)); + msg.extend_from_slice(&bindreq); + + stream + .write_all(&msg) + .map_err(|e| format!("发送绑定请求失败:{e}"))?; + + // 读回应:循环读到拿到完整 LDAPMessage + let mut buf = Vec::new(); + let mut tmp = [0u8; 4096]; + loop { + if let Some(full) = take_message(&buf) { + return match result_code(full) { + Some(0) => Ok(()), + Some(code) => Err(format!("目录返回结果码 {code}(非成功)")), + None => Err("无法解析绑定响应".to_owned()), + }; + } + match stream.read(&mut tmp) { + Ok(0) => break, + Ok(n) => buf.extend_from_slice(&tmp[..n]), + Err(_) => break, + } + if buf.len() > 65536 { + break; + } + } + Err("绑定未收到完整响应".to_owned()) +} + +/// 认证入口:LDAP 开启时校验用户名/口令。 +/// +/// 返回 true 仅当 bind 成功;其余情况(未开启 / 任何错误)一律 false。 +pub fn authenticate(username: &str, password: &str) -> bool { + if !enabled() { + return false; + } + if password.is_empty() { + return false; + } + let dn = user_dn(username); + match bind(&dn, password) { + Ok(()) => { + util::log_notice(&format!("[ldap] 认证成功 user={username} dn={dn}")); + true + } + Err(e) => { + util::log_warn(&format!("[ldap] 认证失败 user={username}:{e}")); + false + } + } +} + +/// 供登录流程判断是否需要尝试 LDAP(未开启时直接 false,零开销)。 +pub fn should_try() -> bool { + enabled() +} diff --git a/source/rust/crates/plugin-sso/src/lib.rs b/source/rust/crates/plugin-sso/src/lib.rs index 7eb2021..9da3930 100644 --- a/source/rust/crates/plugin-sso/src/lib.rs +++ b/source/rust/crates/plugin-sso/src/lib.rs @@ -13,7 +13,13 @@ mod accounts; mod api; mod audit; mod captcha; +mod cas; +mod geo; +mod ldap; +mod scim; mod otp; +mod reset; +mod sync; pub mod oauth; mod oauth_clients; mod oauth_keys; diff --git a/source/rust/crates/plugin-sso/src/reset.rs b/source/rust/crates/plugin-sso/src/reset.rs new file mode 100644 index 0000000..144404d --- /dev/null +++ b/source/rust/crates/plugin-sso/src/reset.rs @@ -0,0 +1,130 @@ +//! 自助密码重置(对齐 MaxKey 密码找回)。 +//! +//! 两个公开端点,无需登录: +//! +//! * `POST /api/public/forgot-password` —— 凭账号名 / 邮箱申请重置,签发一次性 +//! token(存共享内存,不落 `users.json`,避免出现在管理台视图里),并「发信」。 +//! * `POST /api/public/reset-password` —— 凭 token + 新口令完成重置。 +//! +//! token 用共享内存 `pwdrst: → username` 存储,带 TTL,单次有效(用后即删)。 +//! 「发信」是可配置抽象:默认只写日志;设 `PASSWORD_RESET_TOKEN_SINK` 把 token +//! 落到本地文件(本地联调 / e2e 取用);生产可接 SMTP / webhook(见 sender 分支)。 + +use ngx::ffi::ngx_http_request_t; + +use ipass_core::http; +use ipass_core::state; +use ipass_core::users; +use ipass_core::util; +use ngx::core::Status; +use ngx::http::HTTPStatus; + +use crate::accounts::{self, UserExt}; +use crate::audit; +use crate::oauth; + +/// 重置 token 共享内存前缀:`pwdrst: → username` +const KEY_PWD_RESET: &[u8] = b"pwdrst:"; +/// 默认 token 有效期(秒) +const RESET_TTL_DEFAULT: i64 = 1800; + +/// 路由 +pub fn route(method: &str, uri: &str) -> Option<(crate::api::Guard, crate::api::Handler)> { + let g = crate::api::Guard::Public; + match (method, uri) { + ("POST", "/api/public/forgot-password") => Some((g, h_forgot_password)), + ("POST", "/api/public/reset-password") => Some((g, h_reset_password)), + _ => None, + } +} + +/// token 有效期:可由 `PASSWORD_RESET_TTL` 覆盖(秒)。 +fn reset_ttl() -> i64 { + match std::env::var("PASSWORD_RESET_TTL") { + Ok(v) => v.trim().parse::().unwrap_or(RESET_TTL_DEFAULT).max(60), + Err(_) => RESET_TTL_DEFAULT, + } +} + +/// 把重置信息「发出去」:配置化抽象(默认日志;SINK 文件;生产可扩展 SMTP/webhook)。 +fn send_reset(user: &str, token: &str) { + let base = oauth::issuer(); + let link = format!("{base}/api/public/reset-password?token={token}"); + util::log_notice(&format!("[reset] 密码重置链接 user={user} {link}")); + + if let Ok(sink) = std::env::var("PASSWORD_RESET_TOKEN_SINK") { + // 本地联调 / e2e:把 token 落到文件,便于脚本取出(不含 PII,仅 token) + let _ = std::fs::write(&sink, format!("{token}\n")); + } +} + +/// `POST /api/public/forgot-password`:账号名或邮箱。 +/// +/// 安全:无论账号是否存在都返回同样的成功文案,避免账号枚举。 +fn h_forgot_password(r: *mut ngx_http_request_t, _actor: crate::api::Actor) -> Status { + let p = http::params(r); + let ident = p + .get("username") + .or_else(|| p.get("email")) + .map(String::as_str) + .unwrap_or("") + .to_owned(); + let ip = http::remote_addr(r); + let ua = http::header(r, "user-agent").unwrap_or_default(); + + if ident.is_empty() { + return http::fail(r, HTTPStatus::BAD_REQUEST, "请提供账号名或邮箱"); + } + + // 按账号名或邮箱定位用户 + let found = users::get(&ident).or_else(|| { + let lower = ident.to_ascii_lowercase(); + users::all().into_iter().find(|u| u.email().to_ascii_lowercase() == lower) + }); + + if let Some(u) = found { + let token = util::gen_key(); + let exp = util::now() + reset_ttl(); + state::put(KEY_PWD_RESET, token.as_bytes(), u.username.as_bytes(), exp); + send_reset(&u.username, &token); + audit::log("pwd.forgot", &u.username, &u.username, true, &ip, &ua, ""); + } else { + audit::log("pwd.forgot", &ident, &ident, false, &ip, &ua, "no such account"); + } + + http::ok(r, serde_json::json!({}), "若账号存在,重置链接已发送") +} + +/// `POST /api/public/reset-password`:token + 新口令。 +fn h_reset_password(r: *mut ngx_http_request_t, _actor: crate::api::Actor) -> Status { + let p = http::params(r); + let token = p.get("token").map(String::as_str).unwrap_or("").to_owned(); + let password = p.get("password").map(String::as_str).unwrap_or("").to_owned(); + let ip = http::remote_addr(r); + let ua = http::header(r, "user-agent").unwrap_or_default(); + + if token.is_empty() || password.is_empty() { + return http::fail(r, HTTPStatus::BAD_REQUEST, "token 与新口令均必填"); + } + if let Err(e) = accounts::check_password(&password) { + return http::fail(r, HTTPStatus::BAD_REQUEST, &e); + } + + let Some((username, exp)) = state::get(KEY_PWD_RESET, token.as_bytes()) else { + return http::fail(r, HTTPStatus::BAD_REQUEST, "token 无效或已使用"); + }; + if exp > 0 && exp <= util::now() { + state::remove(KEY_PWD_RESET, token.as_bytes()); + return http::fail(r, HTTPStatus::BAD_REQUEST, "token 已过期,请重新申请"); + } + + match users::set_password(&username, &password) { + Ok(()) => { + // 单次有效:消费即删 + state::remove(KEY_PWD_RESET, token.as_bytes()); + audit::log("pwd.reset", &username, &username, true, &ip, &ua, ""); + http::ok(r, serde_json::json!({}), "密码已重置,请用新口令登录") + } + Err(e) => http::fail(r, HTTPStatus::BAD_REQUEST, &e), + } +} diff --git a/source/rust/crates/plugin-sso/src/scim.rs b/source/rust/crates/plugin-sso/src/scim.rs new file mode 100644 index 0000000..5b84ecb --- /dev/null +++ b/source/rust/crates/plugin-sso/src/scim.rs @@ -0,0 +1,602 @@ +//! SCIM 2.0 身份供给端点(对齐 MaxKey `maxkey-web-api-scim`)。 +//! +//! 标准协议端点挂在 `/scim/v2/` 下,让外部 HR / 上游 IdP 用标准协议推送用户进来, +//! 无需感知本项目 `users.json` 存储形态。本实现为**单租户精简版**: +//! +//! * Users 完全 CRUD,映射到内核账号(identity 字段走 `extra`); +//! * Groups **派生**自账号的 `groups` 属性(本项目组是账号的平铺多值字段, +//! 不单独建组实体)——所以空组无法表示,这是与 MaxKey 组模型的唯一差异; +//! * 认证用管理员会话(`Guard::Admin`);Bearer / Basic 鉴权留待需要时加。 +//! +//! 响应为 SCIM 原生 JSON(非管理台 `{code,msg,data}` 信封),错误体遵循 +//! SCIM Error 规范。 + +use serde_json::{Value, json}; + +use ipass_core::http; +use ipass_core::models::User; +use ipass_core::util; +use ngx::core::Status; +use ngx::ffi::ngx_http_request_t; +use ngx::http::HTTPStatus; + +use crate::accounts::{self, UserExt}; +use crate::api::{Actor, Guard, Handler}; +use crate::audit; +use ipass_core::users; + +/// SCIM 核心 schema URI +const USER_SCHEMA: &str = "urn:ietf:params:scim:schemas:core:2.0:User"; +const GROUP_SCHEMA: &str = "urn:ietf:params:scim:schemas:core:2.0:Group"; +const ERROR_SCHEMA: &str = "urn:ietf:params:scim:api:messages:2.0:Error"; + +/// 路由:路径含 `{id}` 变量,无法用精确匹配,这里按前缀解析。 +pub fn route(method: &str, uri: &str) -> Option<(Guard, Handler)> { + let g = Guard::Admin; + match (method, uri) { + ("GET", "/scim/v2/ServiceProviderConfig") => Some((g, h_sp_config)), + ("GET", "/scim/v2/Schemas") => Some((g, h_schemas)), + ("GET", "/scim/v2/ResourceTypes") => Some((g, h_resource_types)), + ("GET", "/scim/v2/Users") => Some((g, h_users_list)), + ("POST", "/scim/v2/Users") => Some((g, h_users_create)), + ("GET", "/scim/v2/Groups") => Some((g, h_groups_list)), + ("POST", "/scim/v2/Groups") => Some((g, h_groups_create)), + _ => { + if let Some(id) = uri.strip_prefix("/scim/v2/Users/") { + if !id.is_empty() && !id.contains('/') { + return Some((g, h_users_item)); + } + } + if let Some(id) = uri.strip_prefix("/scim/v2/Groups/") { + if !id.is_empty() && !id.contains('/') { + return Some((g, h_groups_item)); + } + } + None + } + } +} + +// =========================================================================== +// 响应辅助 +// =========================================================================== + +fn scim_send(r: *mut ngx_http_request_t, status: HTTPStatus, body: &Value) -> Status { + http::send(r, status, &body.to_string()) +} + +fn scim_send_with( + r: *mut ngx_http_request_t, + status: HTTPStatus, + body: &Value, + headers: &[(&str, &str)], +) -> Status { + http::send_with(r, status, &body.to_string(), headers) +} + +fn scim_err(r: *mut ngx_http_request_t, status: HTTPStatus, detail: &str) -> Status { + let code = status.0 as u16; + let body = json!({ + "schemas": [ERROR_SCHEMA], + "detail": detail, + "status": code.to_string(), + }); + http::send(r, status, &body.to_string()) +} + +fn base() -> String { + // 复用 OAuth issuer 作为 SCIM base(同主机) + crate::oauth::issuer() +} + +// =========================================================================== +// 映射 +// =========================================================================== + +fn user_to_scim(u: &User) -> Value { + let now = util::now(); + let groups = u.groups(); + let emails = if u.email().is_empty() { + Vec::new() + } else { + vec![json!({ "value": u.email(), "type": "work", "primary": true })] + }; + let phones = if u.mobile().is_empty() { + Vec::new() + } else { + vec![json!({ "value": u.mobile(), "type": "mobile" })] + }; + json!({ + "schemas": [USER_SCHEMA], + "id": u.username, + "userName": u.username, + "displayName": u.display_or_username(), + "name": { "formatted": u.display_name, "familyName": "", "givenName": "" }, + "emails": emails, + "phoneNumbers": phones, + "active": !u.is_locked(now), + "groups": groups.iter().map(|g| json!({ "value": g, "display": g })).collect::>(), + "meta": { + "resourceType": "User", + "created": u.created_at, + "location": format!("{}/scim/v2/Users/{}", base(), u.username), + }, + }) +} + +fn group_to_scim(name: &str, members: &[String]) -> Value { + json!({ + "schemas": [GROUP_SCHEMA], + "id": name, + "displayName": name, + "members": members.iter().map(|m| json!({ "value": m, "display": m })).collect::>(), + "meta": { + "resourceType": "Group", + "location": format!("{}/scim/v2/Groups/{}", base(), name), + }, + }) +} + +/// 从 SCIM User body 抽取创建/更新所需字段。 +struct ScimUserInput { + username: String, + display_name: String, + password: String, + email: String, + mobile: String, + groups: Vec, +} + +fn parse_user_body(body: &Value) -> Result { + let username = body + .get("userName") + .and_then(Value::as_str) + .ok_or("userName 必填")? + .to_owned(); + if username.is_empty() { + return Err("userName 不能为空".to_owned()); + } + let display_name = body + .get("displayName") + .and_then(Value::as_str) + .or_else(|| body.get("name").and_then(|n| n.get("formatted")).and_then(Value::as_str)) + .unwrap_or("") + .to_owned(); + let password = body + .get("password") + .and_then(Value::as_str) + .unwrap_or("ChangeMe123") + .to_owned(); + let email = body + .get("emails") + .and_then(Value::as_array) + .and_then(|a| a.first()) + .and_then(|e| e.get("value").and_then(Value::as_str)) + .unwrap_or("") + .to_owned(); + let mobile = body + .get("phoneNumbers") + .and_then(Value::as_array) + .and_then(|a| a.first()) + .and_then(|p| p.get("value").and_then(Value::as_str)) + .unwrap_or("") + .to_owned(); + let groups = match body.get("groups") { + Some(Value::Array(arr)) => arr + .iter() + .filter_map(|g| g.get("value").and_then(Value::as_str)) + .map(|s| s.trim().to_owned()) + .filter(|s| !s.is_empty()) + .collect(), + _ => Vec::new(), + }; + Ok(ScimUserInput { + username, + display_name, + password, + email, + mobile, + groups, + }) +} + +// =========================================================================== +// 元数据端点 +// =========================================================================== + +fn h_sp_config(r: *mut ngx_http_request_t, _actor: Actor) -> Status { + let body = json!({ + "schemas": ["urn:ietf:params:scim:schemas:core:2.0:ServiceProviderConfig"], + "documentationUri": format!("{}/scim/v2/ServiceProviderConfig", base()), + "patch": { "supported": true }, + "bulk": { "supported": false }, + "filter": { "supported": true, "maxResults": 200 }, + "changePassword": { "supported": true }, + "sort": { "supported": false }, + "etag": { "supported": false }, + "authenticationSchemes": [ + { "type": "oauthbearertoken", "name": "OAuth Bearer Token", "description": "管理员会话", "specUri": "https://www.rfc-editor.org/rfc/rfc6750" } + ], + }); + scim_send(r, HTTPStatus::OK, &body) +} + +fn h_schemas(r: *mut ngx_http_request_t, _actor: Actor) -> Status { + let body = json!({ + "schemas": ["urn:ietf:params:scim:api:messages:2.0:ListResponse"], + "totalResults": 2, + "Resources": [ + { + "id": USER_SCHEMA, + "name": "User", + "description": "用户", + "attributes": [ + { "name": "userName", "type": "string", "required": true, "multiValued": false }, + { "name": "displayName", "type": "string", "multiValued": false }, + { "name": "emails", "type": "string", "multiValued": true }, + { "name": "phoneNumbers", "type": "string", "multiValued": true }, + { "name": "active", "type": "boolean", "multiValued": false }, + { "name": "groups", "type": "complex", "multiValued": true } + ] + }, + { + "id": GROUP_SCHEMA, + "name": "Group", + "description": "用户组(派生自账号 groups 属性)", + "attributes": [ + { "name": "displayName", "type": "string", "required": true, "multiValued": false }, + { "name": "members", "type": "complex", "multiValued": true } + ] + } + ] + }); + scim_send(r, HTTPStatus::OK, &body) +} + +fn h_resource_types(r: *mut ngx_http_request_t, _actor: Actor) -> Status { + let body = json!({ + "schemas": ["urn:ietf:params:scim:api:messages:2.0:ListResponse"], + "totalResults": 2, + "Resources": [ + { "id": "User", "name": "User", "endpoint": "/scim/v2/Users", "schema": USER_SCHEMA, "meta": { "resourceType": "ResourceType", "location": format!("{}/scim/v2/ResourceTypes/User", base()) } }, + { "id": "Group", "name": "Group", "endpoint": "/scim/v2/Groups", "schema": GROUP_SCHEMA, "meta": { "resourceType": "ResourceType", "location": format!("{}/scim/v2/ResourceTypes/Group", base()) } } + ] + }); + scim_send(r, HTTPStatus::OK, &body) +} + +// =========================================================================== +// Users +// =========================================================================== + +fn h_users_list(r: *mut ngx_http_request_t, _actor: Actor) -> Status { + let p = http::params(r); + // filter=userName eq "x" + let mut filter_user: Option = None; + if let Some(f) = p.get("filter") { + if let Some((_, v)) = f.split_once("eq") { + let v = v.trim().trim_matches('"').to_owned(); + if !v.is_empty() { + filter_user = Some(v); + } + } + } + let start: usize = p.get("startIndex").and_then(|s| s.parse().ok()).unwrap_or(1).max(1); + let count: usize = p.get("count").and_then(|s| s.parse().ok()).unwrap_or(200); + + let all = users::all(); + let filtered: Vec = if let Some(u) = &filter_user { + all.iter() + .filter(|x| x.username == *u) + .map(user_to_scim) + .collect() + } else { + all.iter().map(user_to_scim).collect() + }; + let total = filtered.len(); + let end = (start + count).min(total + 1); + let page: Vec = if start <= total { + filtered[start - 1..end - 1.min(total)].to_vec() + } else { + Vec::new() + }; + + let body = json!({ + "schemas": ["urn:ietf:params:scim:api:messages:2.0:ListResponse"], + "totalResults": total, + "startIndex": start, + "itemsPerPage": page.len(), + "Resources": page, + }); + scim_send(r, HTTPStatus::OK, &body) +} + +fn h_users_create(r: *mut ngx_http_request_t, actor: Actor) -> Status { + let body = match http::json_body(r) { + Some(Value::Object(_)) => http::body_object(r), + _ => return scim_err(r, HTTPStatus::BAD_REQUEST, "请求体必须是 JSON 对象"), + }; + let input = match parse_user_body(&body) { + Ok(i) => i, + Err(e) => return scim_err(r, HTTPStatus::BAD_REQUEST, &e), + }; + match accounts::create( + &input.username, + &input.display_name, + &input.password, + "user", + &input.email, + &input.mobile, + "", + &input.groups.join(","), + ) { + Ok(u) => { + let operator = actor.admin_name().to_owned(); + audit::log("scim.user.create", &operator, &u.username, true, &http::remote_addr(r), &http::header(r, "user-agent").unwrap_or_default(), ""); + let scim = user_to_scim(&u); + let loc = scim["meta"]["location"].as_str().unwrap_or("").to_owned(); + scim_send_with(r, HTTPStatus::CREATED, &scim, &[("Location", &loc)]) + } + Err(e) => scim_err(r, HTTPStatus::BAD_REQUEST, &e), + } +} + +fn h_users_item(r: *mut ngx_http_request_t, actor: Actor) -> Status { + let uri = http::uri(r); + let id = match uri.strip_prefix("/scim/v2/Users/") { + Some(s) => s.to_owned(), + None => return scim_err(r, HTTPStatus::BAD_REQUEST, "路径解析失败"), + }; + let method = http::method_str(r); + + if method == "GET" { + match users::get(&id) { + Some(u) => scim_send(r, HTTPStatus::OK, &user_to_scim(&u)), + None => scim_err(r, HTTPStatus::NOT_FOUND, &format!("用户 {id} 不存在")), + } + } else if method == "DELETE" { + let operator = actor.admin_name().to_owned(); + match users::delete(&id, &operator) { + Ok(()) => { + audit::log("scim.user.delete", &operator, &id, true, &http::remote_addr(r), &http::header(r, "user-agent").unwrap_or_default(), ""); + scim_send(r, HTTPStatus::NO_CONTENT, &json!({})) + } + Err(e) => scim_err(r, HTTPStatus::BAD_REQUEST, &e), + } + } else if method == "PUT" { + let body = http::body_object(r); + let input = match parse_user_body(&body) { + Ok(i) => i, + Err(e) => return scim_err(r, HTTPStatus::BAD_REQUEST, &e), + }; + match accounts::set_profile( + &id, + &input.email, + &input.mobile, + "", + &input.groups.join(","), + Some(&input.display_name), + ) { + Ok(u) => { + audit::log("scim.user.replace", actor.admin_name(), &id, true, &http::remote_addr(r), &http::header(r, "user-agent").unwrap_or_default(), ""); + scim_send(r, HTTPStatus::OK, &user_to_scim(&u)) + } + Err(e) => scim_err(r, HTTPStatus::BAD_REQUEST, &e), + } + } else if method == "PATCH" { + patch_user(r, &id, actor) + } else { + scim_err(r, HTTPStatus::NOT_ALLOWED, "不支持的方法") + } +} + +/// PATCH 用户:支持 displayName / emails / phoneNumbers / groups 的 add/replace/remove。 +fn patch_user(r: *mut ngx_http_request_t, id: &str, actor: Actor) -> Status { + let body = match http::json_body(r) { + Some(b) => b, + None => return scim_err(r, HTTPStatus::BAD_REQUEST, "请求体必须是 JSON"), + }; + let ops = match body.get("Operations").and_then(Value::as_array) { + Some(a) => a, + None => return scim_err(r, HTTPStatus::BAD_REQUEST, "缺少 Operations"), + }; + + // 收集要改的字段,最后一次性 set_profile + let mut display_name: Option = None; + let mut email: Option = None; + let mut mobile: Option = None; + let mut add_groups: Vec = Vec::new(); + let mut remove_groups: Vec = Vec::new(); + let mut replace_groups: Option> = None; + + for op in ops { + let op_type = op.get("op").and_then(Value::as_str).unwrap_or("").to_ascii_lowercase(); + let path = op.get("path").and_then(Value::as_str).unwrap_or(""); + let value = op.get("value"); + match path { + "displayName" => { + if let Some(v) = value.and_then(Value::as_str) { + display_name = Some(v.to_owned()); + } + } + "emails" => { + if let Some(v) = value.and_then(Value::as_str) { + email = Some(v.to_owned()); + } else if let Some(arr) = value.and_then(Value::as_array) { + email = arr.first().and_then(|e| e.get("value").and_then(Value::as_str)).map(|s| s.to_owned()); + } + } + "phoneNumbers" => { + if let Some(v) = value.and_then(Value::as_str) { + mobile = Some(v.to_owned()); + } else if let Some(arr) = value.and_then(Value::as_array) { + mobile = arr.first().and_then(|p| p.get("value").and_then(Value::as_str)).map(|s| s.to_owned()); + } + } + "groups" => { + let vals: Vec = match value { + Some(Value::Array(a)) => a.iter().filter_map(|g| g.get("value").and_then(Value::as_str)).map(|s| s.trim().to_owned()).filter(|s| !s.is_empty()).collect(), + Some(Value::String(s)) => vec![s.trim().to_owned()], + _ => Vec::new(), + }; + match op_type.as_str() { + "remove" => remove_groups.extend(vals), + "replace" | "add" => { + if op_type == "replace" { + replace_groups = Some(vals.clone()); + } + add_groups.extend(vals); + } + _ => {} + } + } + // 无 path 的 replace:value 是属性对象 + "" => { + if let Some(obj) = value.and_then(|v| v.as_object()) { + if let Some(v) = obj.get("displayName").and_then(Value::as_str) { + display_name = Some(v.to_owned()); + } + if let Some(v) = obj.get("emails").and_then(Value::as_array).and_then(|a| a.first()).and_then(|e| e.get("value").and_then(Value::as_str)) { + email = Some(v.to_owned()); + } + } + } + _ => {} + } + } + + // 读取当前用户组装最终 groups + let cur = match users::get(id) { + Some(u) => u, + None => return scim_err(r, HTTPStatus::NOT_FOUND, &format!("用户 {id} 不存在")), + }; + let mut groups = if let Some(rg) = replace_groups { + rg + } else { + cur.groups() + }; + for g in add_groups { + if !groups.iter().any(|x| x == &g) { + groups.push(g); + } + } + groups.retain(|g| !remove_groups.iter().any(|x| x == g)); + + let final_dn = display_name.unwrap_or_else(|| cur.display_or_username()); + let final_email = email.unwrap_or_else(|| cur.email().to_owned()); + let final_mobile = mobile.unwrap_or_else(|| cur.mobile().to_owned()); + + match accounts::set_profile(id, &final_email, &final_mobile, "", &groups.join(","), Some(&final_dn)) { + Ok(u) => { + audit::log("scim.user.patch", actor.admin_name(), id, true, &http::remote_addr(r), &http::header(r, "user-agent").unwrap_or_default(), ""); + scim_send(r, HTTPStatus::OK, &user_to_scim(&u)) + } + Err(e) => scim_err(r, HTTPStatus::BAD_REQUEST, &e), + } +} + +// =========================================================================== +// Groups(派生) +// =========================================================================== + +/// 聚合所有账号的 groups 属性 → 组名 → 成员列表。 +fn aggregate_groups() -> std::collections::BTreeMap> { + let mut map: std::collections::BTreeMap> = std::collections::BTreeMap::new(); + for u in users::all() { + for g in u.groups() { + map.entry(g).or_default().push(u.username.clone()); + } + } + map +} + +fn h_groups_list(r: *mut ngx_http_request_t, _actor: Actor) -> Status { + let map = aggregate_groups(); + let resources: Vec = map.iter().map(|(k, v)| group_to_scim(k, v)).collect(); + let body = json!({ + "schemas": ["urn:ietf:params:scim:api:messages:2.0:ListResponse"], + "totalResults": resources.len(), + "startIndex": 1, + "itemsPerPage": resources.len(), + "Resources": resources, + }); + scim_send(r, HTTPStatus::OK, &body) +} + +fn h_groups_create(r: *mut ngx_http_request_t, actor: Actor) -> Status { + let body = http::body_object(r); + let name = match body + .get("displayName") + .and_then(Value::as_str) + .or_else(|| body.get("id").and_then(Value::as_str)) + { + Some(n) => n.trim().to_owned(), + None => return scim_err(r, HTTPStatus::BAD_REQUEST, "displayName 必填"), + }; + if name.is_empty() { + return scim_err(r, HTTPStatus::BAD_REQUEST, "displayName 不能为空"); + } + let members: Vec = match body.get("members") { + Some(Value::Array(a)) => a.iter().filter_map(|m| m.get("value").and_then(Value::as_str)).map(|s| s.trim().to_owned()).filter(|s| !s.is_empty()).collect(), + _ => Vec::new(), + }; + if !members.is_empty() { + match accounts::batch_update(&members, &[name.clone()], &[], None, None, false) { + Ok((n, _)) => { + audit::log("scim.group.create", actor.admin_name(), &name, true, &http::remote_addr(r), &http::header(r, "user-agent").unwrap_or_default(), &format!("members={n}")); + } + Err(e) => return scim_err(r, HTTPStatus::BAD_REQUEST, &e), + } + } + scim_send(r, HTTPStatus::OK, &group_to_scim(&name, &members)) +} + +fn h_groups_item(r: *mut ngx_http_request_t, actor: Actor) -> Status { + let uri = http::uri(r); + let id = match uri.strip_prefix("/scim/v2/Groups/") { + Some(s) => s.to_owned(), + None => return scim_err(r, HTTPStatus::BAD_REQUEST, "路径解析失败"), + }; + let method = http::method_str(r); + let map = aggregate_groups(); + + if method == "GET" { + match map.get(&id) { + Some(m) => scim_send(r, HTTPStatus::OK, &group_to_scim(&id, m)), + None => scim_err(r, HTTPStatus::NOT_FOUND, &format!("组 {id} 不存在")), + } + } else if method == "DELETE" { + // 从所有成员身上摘掉该组 + let members: Vec = map.get(&id).cloned().unwrap_or_default(); + if !members.is_empty() { + if let Err(e) = accounts::batch_update(&members, &[], &[id.clone()], None, None, false) { + return scim_err(r, HTTPStatus::BAD_REQUEST, &e); + } + } + audit::log("scim.group.delete", actor.admin_name(), &id, true, &http::remote_addr(r), &http::header(r, "user-agent").unwrap_or_default(), ""); + scim_send(r, HTTPStatus::NO_CONTENT, &json!({})) + } else if method == "PUT" || method == "PATCH" { + let body = http::body_object(r); + let wanted: Vec = match body.get("members") { + Some(Value::Array(a)) => a.iter().filter_map(|m| m.get("value").and_then(Value::as_str)).map(|s| s.trim().to_owned()).filter(|s| !s.is_empty()).collect(), + _ => map.get(&id).cloned().unwrap_or_default(), + }; + let current: Vec = map.get(&id).cloned().unwrap_or_default(); + let add: Vec = wanted.iter().filter(|w| !current.iter().any(|c| c == *w)).cloned().collect(); + let remove: Vec = current.iter().filter(|c| !wanted.iter().any(|w| w == *c)).cloned().collect(); + if !add.is_empty() { + if let Err(e) = accounts::batch_update(&add, &[id.clone()], &[], None, None, false) { + return scim_err(r, HTTPStatus::BAD_REQUEST, &e); + } + } + if !remove.is_empty() { + if let Err(e) = accounts::batch_update(&remove, &[], &[id.clone()], None, None, false) { + return scim_err(r, HTTPStatus::BAD_REQUEST, &e); + } + } + audit::log("scim.group.update", actor.admin_name(), &id, true, &http::remote_addr(r), &http::header(r, "user-agent").unwrap_or_default(), ""); + scim_send(r, HTTPStatus::OK, &group_to_scim(&id, &wanted)) + } else { + scim_err(r, HTTPStatus::NOT_ALLOWED, "不支持的方法") + } +} diff --git a/source/rust/crates/plugin-sso/src/sync.rs b/source/rust/crates/plugin-sso/src/sync.rs new file mode 100644 index 0000000..7068fba --- /dev/null +++ b/source/rust/crates/plugin-sso/src/sync.rs @@ -0,0 +1,191 @@ +//! 同步连接器(对齐 MaxKey `maxkey-synchronizer`:钉钉 / 企微 / 飞书)。 +//! +//! **手动触发端点**:`POST /api/admin/sync/`,由外部 cron / 运维脚本调用, +//! 不引入后台进程(与「零常驻依赖」硬约束一致)。 +//! +//! 流程:从配置好的用户目录源拉取成员列表 → 归一化为内部账号字段 → upsert 进 +//! `users.json`。每个 provider 的拉取地址由 `SYNC__URL` 配置, +//! 默认指向真实开放平台端点;本地联调 / e2e 把它指到 mock 即可,无需改代码。 +//! +//! 网络层用标准库 `TcpStream` 做最简 HTTP GET(不引第三方 HTTP 客户端), +//! 满足「零外部依赖」;生产可换 HTTPS(由部署侧反向代理或上层 TLS 终结)。 + +use std::io::{Read, Write}; +use std::net::TcpStream; + +use ngx::ffi::ngx_http_request_t; +use serde_json::{Value, json}; + +use ipass_core::http; +use ipass_core::users; +use ipass_core::util; +use ngx::core::Status; +use ngx::http::HTTPStatus; + +use crate::accounts; +use crate::audit; + +/// 支持的 provider(路径第三段) +const PROVIDERS: &[&str] = &["dingtalk", "workwechat", "feishu"]; + +/// 路由:`/api/admin/sync/`(POST,管理员) +pub fn route(method: &str, uri: &str) -> Option<(crate::api::Guard, crate::api::Handler)> { + if method != "POST" { + return None; + } + if let Some(provider) = uri.strip_prefix("/api/admin/sync/") { + if !provider.is_empty() && !provider.contains('/') && PROVIDERS.contains(&provider) { + return Some((crate::api::Guard::Admin, h_sync)); + } + } + None +} + +/// 极简 HTTP GET(HTTP/1.1,Connection: close,读到 EOF)。返回响应体字符串。 +fn http_get(url: &str) -> Option { + // 仅支持 http://host:port/path(同步源在内网,由上层 TLS 终结) + let rest = url.strip_prefix("http://")?; + let (hostport, path) = match rest.split_once('/') { + Some((h, p)) => (h, format!("/{p}")), + None => (rest, "/".to_owned()), + }; + let (host, port) = match hostport.split_once(':') { + Some((h, p)) => (h.to_owned(), p.parse::().ok()?), + None => (hostport.to_owned(), 80), + }; + + let mut stream = TcpStream::connect((host.as_str(), port)).ok()?; + stream.set_read_timeout(Some(std::time::Duration::from_secs(10))).ok()?; + let req = format!( + "GET {path} HTTP/1.1\r\nHost: {host}\r\nConnection: close\r\nAccept: application/json\r\n\r\n" + ); + stream.write_all(req.as_bytes()).ok()?; + + let mut buf = Vec::new(); + stream.read_to_end(&mut buf).ok()?; + let text = String::from_utf8_lossy(&buf); + let body = match text.split_once("\r\n\r\n") { + Some((head, b)) => { + // 有 Content-Length 就精确截取,否则用 Connection: close 读到的全部 + let cl = head.lines().find_map(|l| { + if l.len() >= 15 && l[..15].eq_ignore_ascii_case("content-length:") { + l[15..].trim().parse::().ok() + } else { + None + } + }); + match cl { + Some(n) if b.len() >= n => b[..n].to_owned(), + _ => b.to_owned(), + } + } + None => String::new(), + }; + Some(body) +} + +/// 取 provider 的用户目录源地址(env 优先,否则真实开放平台默认端点)。 +fn source_url(provider: &str) -> Option { + let key = format!("SYNC_{}_URL", provider.to_ascii_uppercase()); + if let Ok(v) = std::env::var(&key) { + if !v.is_empty() { + return Some(v); + } + } + // 真实开放平台默认端点(仅占位;生产应配置 AK/SK 与正确的拉取接口) + let default = match provider { + "dingtalk" => "https://oapi.dingtalk.com/topapi/v2/user/list", + "workwechat" => "https://qyapi.weixin.qq.com/cgi-bin/user/list", + "feishu" => "https://open.feishu.cn/open-apis/contact/v3/users", + _ => return None, + }; + Some(default.to_owned()) +} + +/// 单次同步:拉取 → 归一化 → upsert。 +fn h_sync(r: *mut ngx_http_request_t, actor: crate::api::Actor) -> Status { + let provider = http::uri(r) + .strip_prefix("/api/admin/sync/") + .unwrap_or("") + .to_owned(); + let operator = actor.admin_name().to_owned(); + let ip = http::remote_addr(r); + let ua = http::header(r, "user-agent").unwrap_or_default(); + + let url = match source_url(&provider) { + Some(u) => u, + None => return http::fail(r, HTTPStatus::BAD_REQUEST, &format!("未知 provider:{provider}")), + }; + + let body = match http_get(&url) { + Some(b) => b, + None => return http::fail(r, HTTPStatus::BAD_REQUEST, &format!("拉取 {provider} 用户源失败(地址:{url})")), + }; + + let parsed: Value = match serde_json::from_str::(&body) { + Ok(v) => v, + Err(e) => return http::fail(r, HTTPStatus::BAD_REQUEST, &format!("用户源返回非 JSON:{e}")), + }; + + // 归一化契约:`{ "users": [ {username, display_name, email, mobile, department, groups:[...]} ] }` + let users_arr = match parsed.get("users").and_then(Value::as_array) { + Some(a) => a, + None => return http::fail(r, HTTPStatus::BAD_REQUEST, "用户源缺少 users 数组"), + }; + + let mut created = 0usize; + let mut updated = 0usize; + let mut skipped: Vec = Vec::new(); + + for item in users_arr { + let username = match item.get("username").and_then(Value::as_str) { + Some(s) if !s.is_empty() => s.trim().to_owned(), + _ => { + skipped.push("缺少 username".to_owned()); + continue; + } + }; + let display_name = item.get("display_name").and_then(Value::as_str).unwrap_or("").to_owned(); + let email = item.get("email").and_then(Value::as_str).unwrap_or("").to_owned(); + let mobile = item.get("mobile").and_then(Value::as_str).unwrap_or("").to_owned(); + let department = item.get("department").and_then(Value::as_str).unwrap_or("").to_owned(); + let groups: Vec = match item.get("groups") { + Some(Value::Array(a)) => a + .iter() + .filter_map(|g| g.as_str()) + .map(|s| s.trim().to_owned()) + .filter(|s| !s.is_empty()) + .collect(), + _ => Vec::new(), + }; + let groups_csv = groups.join(","); + + if users::get(&username).is_some() { + match accounts::set_profile(&username, &email, &mobile, &department, &groups_csv, Some(&display_name)) { + Ok(_) => updated += 1, + Err(e) => skipped.push(format!("{username}: {e}")), + } + } else { + let pw = util::gen_key(); + match accounts::create(&username, &display_name, &pw, "user", &email, &mobile, &department, &groups_csv) { + Ok(_) => created += 1, + Err(e) => skipped.push(format!("{username}: {e}")), + } + } + } + + audit::log( + "sync.run", + &operator, + &provider, + true, + &ip, + &ua, + &format!("created={created} updated={updated} skipped={}", skipped.len()), + ); + http::ok( + r, + json!({ "provider": provider, "created": created, "updated": updated, "skipped": skipped }), + &format!("同步完成:新增 {created} / 更新 {updated}"), + ) +} diff --git a/tests/maxkey-p1p2-e2e.sh b/tests/maxkey-p1p2-e2e.sh new file mode 100644 index 0000000..3f638df --- /dev/null +++ b/tests/maxkey-p1p2-e2e.sh @@ -0,0 +1,199 @@ +#!/usr/bin/env bash +# ============================================================================ +# MaxKey P1/P2 能力缺口端到端验证:SCIM 2.0 / CAS / 自助密码重置 / +# 同步连接器(钉钉 mock)/ LDAP 认证源(禁用回归) +# +# 这是第 7 套(在原有 6 套之后跑),只新增断言,不改既有 6 套行为。 +# 覆盖: +# - SCIM 2.0:ServiceProviderConfig / Users 全 CRUD + PATCH(管理员会话) +# - CAS 1.0/2.0:登录签发 ST → serviceValidate 返回 XML / validate 返回纯文本 +# - 自助密码重置:forgot →(token 落 sink 文件)→ reset → 用新口令登录成功 +# - 同步连接器:本地 mock 用户目录 → /api/admin/sync/dingtalk → 账号 upsert +# - LDAP:禁用时管理员登录正常、未知账号 401(不 panic、不尝试 bind) +# +# 前置:网关以 source/conf/nginx.test.conf 运行(见 scripts/run-local-e2e.sh) +# 依赖:curl、python3 +# +# 用法:bash tests/maxkey-p1p2-e2e.sh [IDP_BASE] [DATA_DIR] +# ============================================================================ +set -u +_ENV_HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +. "$_ENV_HERE/../scripts/load-env.sh" +unset _ENV_HERE + +BASE="${1:-http://127.0.0.1:18098}" +ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" +DATA_DIR="${2:-$ROOT/source/data}" +ADMIN_USER="${ADMIN_USER:-admin}" +ADMIN_PASS="${ADMIN_PASS:-${ADMIN_PASSWORD:-123456}}" +PWD_SINK="${PASSWORD_RESET_TOKEN_SINK:-/tmp/sso-pwdreset-token.txt}" +SYNC_MOCK_PORT="${SYNC_MOCK_PORT:-18088}" + +JAR="$(mktemp -t sso_p1p2_cookies.XXXXXX.txt)" +JAR2="$(mktemp -t sso_p1p2_cookies2.XXXXXX.txt)" +trap 'rm -f "$JAR" "$JAR2"; [ -n "${MOCK_PID:-}" ] && kill "$MOCK_PID" 2>/dev/null || true; [ -n "${RSTU:-}" ] && curl -s -o /dev/null -b "$JAR" -X POST "$BASE/api/admin/users/delete" -d "username=$RSTU" >/dev/null 2>&1 || true' EXIT + +PASS=0; FAIL=0 +ok() { echo " ✅ $1"; PASS=$((PASS+1)); } +bad() { echo " ❌ $1"; FAIL=$((FAIL+1)); } +need() { command -v "$1" >/dev/null 2>&1 || { echo "缺少依赖: $1"; exit 2; }; } +need curl; need python3 + +echo "==> IdP: $BASE" +echo "==> data: $DATA_DIR" + +# ---------- 管理会话 ---------- +alogin() { + curl -s -c "$JAR" -o /dev/null -w '%{http_code}' -X POST "$BASE/api/admin/login" \ + -d "username=$ADMIN_USER&password=$ADMIN_PASS" +} +CODE="$(alogin)" +[ "$CODE" = "200" ] && ok "管理员登录成功 (200)" || { bad "管理员登录失败,code=$CODE"; echo "FAIL=$FAIL"; exit 1; } + +jget() { printf '%s' "$1" | python3 -c " +import sys,json +path=[k for k in sys.argv[1].split('.') if k] +try: d=json.loads(sys.stdin.read()) +except Exception: print(''); raise SystemExit +for k in path: + if isinstance(d,dict): d=d.get(k) + elif isinstance(d,list) and k.isdigit(): d=d[int(k)] if int(k)$ADMIN_USER"; then ok "CAS 2.0 serviceValidate 返回用户 XML"; else bad "serviceValidate 未含 $ADMIN_USER:\n$xml"; fi + +# 用过的 ST 单次有效:再校验应失败 +xml2="$(curl -s -b "$JAR" "$BASE/cas/serviceValidate?service=$SVC&ticket=$TICKET")" +echo "$xml2" | grep -q "authenticationFailure" && ok "CAS ST 单次有效(复用被拒)" || bad "CAS ST 应单次有效,复用却成功:\n$xml2" + +# CAS 1.0 纯文本 +loc3="$(curl -s -o /dev/null -w '%{redirect_url}' -b "$JAR" "$BASE/cas/login?service=$SVC")" +t3="$(echo "$loc3" | sed -n 's/.*[?&]ticket=\([^&]*\).*/\1/p')" +ptext="$(curl -s -b "$JAR" "$BASE/cas/validate?service=$SVC&ticket=$t3")" +if echo "$ptext" | head -1 | grep -qx "yes"; then ok "CAS 1.0 /cas/validate 返回 yes"; else bad "CAS 1.0 应为 yes,实际:'$ptext'"; fi + +# =========================================================================== +echo +echo "############ [C] 自助密码重置 ############" +# 先给 alice 申请(验证「账号存在」路径返回成功文案) +code="$(curl -s -o /dev/null -w '%{http_code}' -X POST "$BASE/api/public/forgot-password" -d "username=alice")" +[ "$code" = "200" ] && ok "forgot-password(alice 存在)→ 200" || bad "forgot 应为 200,实际 $code" + +# 用一次性账号跑完整重置流程。 +# 不能用 admin:种子口令 123456 只有 6 位,过不了本插件的 8 位口令策略, +# 重置接口无法把口令还原成 123456;而改了 admin 口令会让后续套件(用 123456 登录)失败。 +# 改用一次性管理员账号,完成「创建→申请→重置→新口令登录→删除」闭环,全程不动 admin。 +RSTU="rst_e2e_$(head -c4 /dev/urandom | xxd -p)" +RSTPW1="RstInit$(head -c4 /dev/urandom | xxd -p)" # >=8 位,过口令策略 +RSTPW2="RstNew$(head -c4 /dev/urandom | xxd -p)" +curl -s -o /dev/null -b "$JAR" -X POST "$BASE/api/admin/users/delete" -d "username=$RSTU" >/dev/null +code="$(curl -s -o /dev/null -w '%{http_code}' -b "$JAR" -X POST "$BASE/api/admin/users/create" \ + -d "username=$RSTU&password=$RSTPW1&display_name=RstE2E&role=admin")" +[ "$code" = "200" ] && ok "创建一次性账号 $RSTU → 200" || bad "创建一次性账号失败,code=$code" + +: > "$PWD_SINK" +code="$(curl -s -o /dev/null -w '%{http_code}' -X POST "$BASE/api/public/forgot-password" -d "username=$RSTU")" +[ "$code" = "200" ] || bad "forgot($RSTU) 应为 200,实际 $code" +TOKEN="$(tr -d '[:space:]' < "$PWD_SINK")" +if [ -n "$TOKEN" ]; then ok "重置 token 已落到 sink 文件"; else bad "sink 文件未取到 token"; fi + +code="$(curl -s -o /dev/null -w '%{http_code}' -X POST "$BASE/api/public/reset-password" -d "token=$TOKEN&password=$RSTPW2")" +[ "$code" = "200" ] && ok "reset-password(用 token)→ 200" || bad "reset 应为 200,实际 $code" + +# 用新口令登录(新会话;该账号是管理员,走 /api/admin/login) +code2="$(curl -s -c "$JAR2" -o /dev/null -w '%{http_code}' -X POST "$BASE/api/admin/login" -d "username=$RSTU&password=$RSTPW2")" +[ "$code2" = "200" ] && ok "用新口令登录成功 → 200" || bad "新口令登录失败,code=$code2" + +# 清理一次性账号,保持 data 干净(admin 口令全程未被改动) +curl -s -o /dev/null -b "$JAR" -X POST "$BASE/api/admin/users/delete" -d "username=$RSTU" >/dev/null + +# =========================================================================== +echo +echo "############ [D] 同步连接器(钉钉 mock) ############" +# 起一个本地 mock 用户目录(归一化 {users:[...]} 契约) +MOCK_DATA='{"users":[{"username":"ding_e2e_1","display_name":"Ding E2E","email":"ding@x.cn","mobile":"","department":"","groups":["synced"]}]}' +python3 - "$SYNC_MOCK_PORT" </dev/null 2>&1 && break; sleep 0.2; done + +code="$(curl -s -o /dev/null -w '%{http_code}' -b "$JAR" -X POST "$BASE/api/admin/sync/dingtalk")" +[ "$code" = "200" ] && ok "POST /api/admin/sync/dingtalk → 200" || bad "sync 应为 200,实际 $code" +sresp="$(curl -s -b "$JAR" -X POST "$BASE/api/admin/sync/dingtalk")" +created="$(jget "$sresp" data.created)"; updated="$(jget "$sresp" data.updated)" +if [ "${created:-0}" -gt 0 ] || [ "${updated:-0}" -gt 0 ]; then ok "同步 upsert 生效(created=${created} updated=${updated})"; else bad "同步未创建/更新任何账号:\n$sresp"; fi + +# 验证账号确实落地(管理台列表可见) +ulist="$(curl -s -b "$JAR" "$BASE/api/admin/users")" +echo "$ulist" | grep -q "ding_e2e_1" && ok "同步账号 ding_e2e_1 已落地" || bad "管理台列表未含 ding_e2e_1" + +# 清理:删除同步账号,保持 data 干净 +curl -s -o /dev/null -b "$JAR" -X POST "$BASE/api/admin/users/delete" -d "username=ding_e2e_1" >/dev/null +kill "$MOCK_PID" 2>/dev/null || true; MOCK_PID="" + +# =========================================================================== +echo +echo "############ [E] LDAP 认证源(禁用回归) ############" +# LDAP 默认禁用:现有管理员登录不受影响 +code="$(curl -s -o /dev/null -w '%{http_code}' -X POST "$BASE/api/admin/login" -d "username=$ADMIN_USER&password=$ADMIN_PASS")" +[ "$code" = "200" ] && ok "LDAP 禁用时管理员登录正常 → 200" || bad "LDAP 禁用时管理员登录异常,code=$code" +# 未知账号 → 401(不应 panic / 不应尝试 bind) +code="$(curl -s -o /dev/null -w '%{http_code}' -X POST "$BASE/api/admin/login" -d "username=no_such_ldap_user&password=whatever")" +[ "$code" = "401" ] && ok "未知账号登录 → 401(未启用 LDAP,无 bind 尝试)" || bad "未知账号登录应为 401,实际 $code" + +# =========================================================================== +echo +echo "## [summary] P1/P2 新增能力:PASS=$PASS FAIL=$FAIL" +[ "$FAIL" = "0" ] && exit 0 || exit 1