feat(sso): MaxKey 迁移 P1/P2 —— SCIM/CAS/LDAP/同步连接器/自助密码重置/归属地

- 新增 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
This commit is contained in:
ssw committed 2026-09-14 18:51:37 +08:00
1 parent f3aabb3405
commit 4a780a4ce7
20 files changed
+1986 -37

No files matched your search

+21 -4
View File
@@ -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 再起
```
+49 -12
View File
@@ -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<user>` / `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)。
---
+32 -10
View File
@@ -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-<name>/`。钉钉/企微/飞书三个就是
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 读不到)。
+26
View File
@@ -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/<provider>` 手动触发,
标准库 `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。
+1 -1
View File
@@ -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
+3 -3
View File
@@ -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)"
+13 -1
View File
@@ -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"
+6
View File
@@ -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;
+10
View File
@@ -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;
}
+73
View File
@@ -152,6 +152,36 @@ pub fn params(r: *mut ngx_http_request_t) -> HashMap<String, String> {
map
}
/// 读取并解析请求体为 JSON(`Content-Type: application/json` 时)。
///
/// 非 JSON 体或解析失败返回 `None`——调用方据此回退到 `params` 或报错。
/// SCIM / CAS / 同步连接器 / 自助密码重置等需要嵌套 JSON(数组、对象)的
/// 端点用它取代 `params`(后者只认标量值)。
pub fn json_body(r: *mut ngx_http_request_t) -> Option<Value> {
let body = unsafe { collect_body(r) };
if body.is_empty() {
return None;
}
serde_json::from_slice::<Value>(&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();
+58 -6
View File
@@ -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();
@@ -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,
});
+161
View File
@@ -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:<ticket>`
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-<random>`。
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<String> {
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<user>` / `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!(
"<cas:serviceResponse xmlns:cas='http://www.yale.edu/tp/cas'>\n\
\x20 <cas:authenticationSuccess>\n\
\x20\x20 <cas:user>{user}</cas:user>\n\
\x20 </cas:authenticationSuccess>\n\
</cas:serviceResponse>\n"
);
http::send_ct(r, HTTPStatus::OK, &body, "application/xml; charset=utf-8")
}
None => {
let body = format!(
"<cas:serviceResponse xmlns:cas='http://www.yale.edu/tp/cas'>\n\
\x20 <cas:authenticationFailure code='INVALID_TICKET'>ticket 无效或已过期</cas:authenticationFailure>\n\
</cas:serviceResponse>\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)
}
+152
View File
@@ -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(""), "未知");
}
}
+252
View File
@@ -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::<u16>().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<u8> {
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<u8> {
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<u8> {
// 最小字节(补码),小正整数走一个字节
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<u8> {
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<u8> {
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<u8> {
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<u8> {
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()
}
+6
View File
@@ -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;
+130
View File
@@ -0,0 +1,130 @@
//! 自助密码重置(对齐 MaxKey 密码找回)。
//!
//! 两个公开端点,无需登录:
//!
//! * `POST /api/public/forgot-password` —— 凭账号名 / 邮箱申请重置,签发一次性
//! token(存共享内存,不落 `users.json`,避免出现在管理台视图里),并「发信」。
//! * `POST /api/public/reset-password` —— 凭 token + 新口令完成重置。
//!
//! token 用共享内存 `pwdrst:<token> → 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:<token> → 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::<i64>().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),
}
}
+602
View File
@@ -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::<Vec<_>>(),
"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::<Vec<_>>(),
"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<String>,
}
fn parse_user_body(body: &Value) -> Result<ScimUserInput, String> {
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<String> = 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<Value> = 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<Value> = 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<String> = None;
let mut email: Option<String> = None;
let mut mobile: Option<String> = None;
let mut add_groups: Vec<String> = Vec::new();
let mut remove_groups: Vec<String> = Vec::new();
let mut replace_groups: Option<Vec<String>> = 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<String> = 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<String, Vec<String>> {
let mut map: std::collections::BTreeMap<String, Vec<String>> = 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<Value> = 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<String> = 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<String> = 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<String> = 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<String> = map.get(&id).cloned().unwrap_or_default();
let add: Vec<String> = wanted.iter().filter(|w| !current.iter().any(|c| c == *w)).cloned().collect();
let remove: Vec<String> = 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, "不支持的方法")
}
}
+191
View File
@@ -0,0 +1,191 @@
//! 同步连接器(对齐 MaxKey `maxkey-synchronizer`:钉钉 / 企微 / 飞书)。
//!
//! **手动触发端点**:`POST /api/admin/sync/<provider>`,由外部 cron / 运维脚本调用,
//! 不引入后台进程(与「零常驻依赖」硬约束一致)。
//!
//! 流程:从配置好的用户目录源拉取成员列表 → 归一化为内部账号字段 → upsert 进
//! `users.json`。每个 provider 的拉取地址由 `SYNC_<PROVIDER>_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/<provider>`(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<String> {
// 仅支持 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::<u16>().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::<usize>().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<String> {
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::<Value>(&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<String> = 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<String> = 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}"),
)
}
+199
View File
@@ -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)<len(d) else None
else: d=None
if d is None: break
print('' if d is None else (d if isinstance(d,str) else json.dumps(d)))
" "$2"; }
# ===========================================================================
echo
echo "############ [A] SCIM 2.0 身份供给 ############"
# 唯一用户名(幂等:先删后建)
U="scim_e2e_$(head -c4 /dev/urandom | xxd -p)"
curl -s -o /dev/null -b "$JAR" -X DELETE "$BASE/scim/v2/Users/$U"
code="$(curl -s -o /dev/null -w '%{http_code}' -b "$JAR" "$BASE/scim/v2/ServiceProviderConfig")"
[ "$code" = "200" ] && ok "ServiceProviderConfig → 200" || bad "ServiceProviderConfig 应为 200,实际 $code"
BODY="{\"userName\":\"$U\",\"displayName\":\"SCIM E2E\",\"emails\":[{\"value\":\"$U@x.cn\"}],\"phoneNumbers\":[{\"value\":\"13800000000\"}],\"groups\":[{\"value\":\"scim_grp\"}]}"
code="$(curl -s -o /dev/null -w '%{http_code}' -b "$JAR" -X POST "$BASE/scim/v2/Users" \
-H 'Content-Type: application/json' -d "$BODY")"
[ "$code" = "201" ] && ok "POST /scim/v2/Users 创建 → 201" || bad "SCIM 创建应为 201,实际 $code"
resp="$(curl -s -b "$JAR" "$BASE/scim/v2/Users/$U")"
dn="$(jget "$resp" displayName)"
[ "$dn" = "SCIM E2E" ] && ok "GET 用户回显 displayName 正确" || bad "SCIM GET displayName 期望 SCIM E2E,实际 '$dn'"
pbody='{"Operations":[{"op":"replace","path":"displayName","value":"SCIM Renamed"}]}'
code="$(curl -s -o /dev/null -w '%{http_code}' -b "$JAR" -X PATCH "$BASE/scim/v2/Users/$U" \
-H 'Content-Type: application/json' -d "$pbody")"
[ "$code" = "200" ] && ok "PATCH 用户 → 200" || bad "SCIM PATCH 应为 200,实际 $code"
resp="$(curl -s -b "$JAR" "$BASE/scim/v2/Users/$U")"
dn2="$(jget "$resp" displayName)"
[ "$dn2" = "SCIM Renamed" ] && ok "PATCH 生效 displayName 更新" || bad "SCIM PATCH 未生效,displayName='$dn2'"
code="$(curl -s -o /dev/null -w '%{http_code}' -b "$JAR" -X DELETE "$BASE/scim/v2/Users/$U")"
[ "$code" = "204" ] && ok "DELETE 用户 → 204" || bad "SCIM DELETE 应为 204,实际 $code"
# ===========================================================================
echo
echo "############ [B] CAS 1.0 / 2.0 协议 ############"
SVC="http://app.example.com/cb"
loc="$(curl -s -o /dev/null -w '%{redirect_url}' -b "$JAR" "$BASE/cas/login?service=$SVC")"
if echo "$loc" | grep -q "ticket="; then ok "CAS /cas/login 签发 ST 并 302 回跳"; else bad "CAS login 未返回带 ticket 的 302,loc=$loc"; fi
TICKET="$(echo "$loc" | sed -n 's/.*[?&]ticket=\([^&]*\).*/\1/p')"
xml="$(curl -s -b "$JAR" "$BASE/cas/serviceValidate?service=$SVC&ticket=$TICKET")"
if echo "$xml" | grep -q "<cas:user>$ADMIN_USER</cas:user>"; then ok "CAS 2.0 serviceValidate 返回用户 XML"; else bad "serviceValidate 未含 <cas:user>$ADMIN_USER</cas: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":"[email protected]","mobile":"","department":"","groups":["synced"]}]}'
python3 - "$SYNC_MOCK_PORT" <<PY &
import sys, http.server
port=int(sys.argv[1]); data='$MOCK_DATA'.encode()
class H(http.server.BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200); self.send_header("Content-Type","application/json")
self.send_header("Content-Length",str(len(data))); self.end_headers(); self.wfile.write(data)
def log_message(self,*a): pass
http.server.HTTPServer(("127.0.0.1",port),H).serve_forever()
PY
MOCK_PID=$!
sleep 0.6
# 等 mock 就绪
for i in $(seq 1 20); do curl -sf "http://127.0.0.1:$SYNC_MOCK_PORT/users" >/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