`)。
+- **坑**:Tomcat 复用工作线程;若 filter 只 set 不 clear,下一请求会**继承上一请求身份**(跨请求泄漏)。
+- **对策**:`JwtAuthFilter` 在 `try` 中 `EngineContextBinder.bind`,`finally` 中**无条件 `clear`**(即便下游抛异常)。并发隔离由 `EngineContextIsolationTest`(16 线程×200 次不同令牌)断言零串号 + 收尾零残留。`ROLES` 必须 `put(List)` 不可 `setProperty`,否则引擎强转 ClassCastException。
+
+### 5.31 客户库 SYS_USER 口令哈希=无盐小写十六进制 MD5(侦察结论)[NEW 2026-06-11]
+
+- **侦察证据**(读 framework 源码核实):`com.dsasp.server.common.util.EncryptUtil.encodeMD5String` = `MessageDigest("MD5").digest(str.getBytes())` 逐字节小写十六进制(`b<16` 补前导 0),32 字符,**无盐、无迭代**;登录比对为 `hash.equals(SYS_USER.PASSWORD)` 纯字符串相等(见 `AuthConstroller#login`、`ChangePasswordView`、`LoginWindow`→`SYS_USER_SEARCH` 流按 ACCOUNT+PASSWORD 查)。
+- **落地**:platform-auth 在 `com.eip4` 侧**逐字节复刻** `PasswordHasher.md5Hex`(保真层 EncryptUtil 一行不改),用平台默认字符集 `getBytes()` 与旧系统一致;比对用 `MessageDigest.isEqual` 常量时间防时序侧信道。验证:`MD5("123456")=e10adc3949ba59abbe56e057f20f883e` 单测断言。
+- **注意**:无盐 MD5 是**待现代化项**(口令存储弱),但本任务目标是兼容验证既有客户库口令,口令强化属后续独立议题(可在改密路径渐进迁移)。角色解析复刻 `RoleServiceImpl#findRolesByUserId`(`sys_usergrouprole ⋈ sys_usergroupuser`),org 表未移植时降级空角色不阻断登录。
+
## 六、Flowable 升级三坑
> 来源:eip4-poc WS4 实测,flowable-poc / flowable5-poc 工程(2026-06-10)
diff --git a/platform-app/src/main/resources/application-local.yml b/platform-app/src/main/resources/application-local.yml
index fd90cca..3f1f0df 100644
--- a/platform-app/src/main/resources/application-local.yml
+++ b/platform-app/src/main/resources/application-local.yml
@@ -17,6 +17,15 @@ spring:
server:
port: 8084
+# 认证(P2):本地自举默认 JWT 密钥。仅本地/对拍用,生产须经
+# EIP4_AUTH_JWT_SECRET 覆盖 + profile=prod 启严格链。详见 application.yml 注释。
+eip4:
+ auth:
+ jwt:
+ secret: ${EIP4_AUTH_JWT_SECRET:dev-only-eip4-jwt-secret-change-me-in-production-0123456789}
+ expire-seconds: 28800 # 8h
+ issuer: eip4-platform
+
logging:
level:
com.dsasp: INFO
diff --git a/platform-app/src/main/resources/application.yml b/platform-app/src/main/resources/application.yml
index 6d23e72..91fed98 100644
--- a/platform-app/src/main/resources/application.yml
+++ b/platform-app/src/main/resources/application.yml
@@ -1,6 +1,10 @@
spring:
application:
name: eip4-poc
+ autoconfigure:
+ # 认证走 JWT(非表单/Basic),排除默认内存用户管理:免生成误导性 dev 口令、免无用 AuthManager
+ exclude:
+ - org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration
datasource:
url: jdbc:postgresql://192.168.20.68:5435/postgres?currentSchema=eip3
username: ceshi
@@ -13,6 +17,19 @@ spring:
server:
port: 8084
+# ============================================================================
+# 认证(P2):无状态 JWT。HS256 对称密钥配置化,严禁硬编码进 Java 代码。
+# 下方为「非生产默认值」——供 default/local/ci profile 自举开箱即用。
+# 生产部署务必经环境变量 EIP4_AUTH_JWT_SECRET 覆盖为强随机密钥(≥32 字节),
+# 并以 -Dspring.profiles.active=prod 启用严格安全链(其余 /api/** 强制认证)。
+# ============================================================================
+eip4:
+ auth:
+ jwt:
+ secret: ${EIP4_AUTH_JWT_SECRET:dev-only-eip4-jwt-secret-change-me-in-production-0123456789}
+ expire-seconds: 28800 # 8h
+ issuer: eip4-platform
+
logging:
level:
com.dsasp: DEBUG
diff --git a/platform-auth/P2认证实测报告.md b/platform-auth/P2认证实测报告.md
new file mode 100644
index 0000000..cfe8d95
--- /dev/null
+++ b/platform-auth/P2认证实测报告.md
@@ -0,0 +1,183 @@
+# EIP4 P2-2 任务 实测报告 —— Spring Security + 无状态 JWT + UserSession 适配
+
+> 工程:eip4-platform · 环境:本地 PG 15(`localhost:5433`),实测端口 8086/8087,连本地库自举
+> 时间:2026-06-11 · 通过标准:登录签发 JWT + 带/不带/伪造/过期令牌行为正确 + JWT roles 驱动行级过滤 + 单测 ≥8
+> **保真层 `com.dsasp` 一行未改**,适配全部在 `com.eip4.platform.auth.security`。
+
+## 一、结论速览
+
+| 项 | 结果 |
+|----|------|
+| 密码哈希侦察(读 framework 源码) | ✅ **无盐小写十六进制 MD5**,纯字符串相等比对 |
+| JWT 选型 | ✅ **jjwt 0.12.6**(HS256 对称密钥,理由见 §三) |
+| POST /api/auth/login 签发 JWT | ✅ 账号口令校验 SYS_USER → 签发含 userId/账号/姓名/depart/org/roles |
+| JwtAuthFilter 填充引擎 ctx + 请求级清理 | ✅ set/clear,**并发隔离单测断言零泄漏** |
+| SecurityConfig 双链按 profile | ✅ 非 prod 保留 permitAll+asUser/roles 测试通道;**prod 严格,无旁路** |
+| 实测 401(无/伪造/过期令牌) | ✅ 全部 401 |
+| 实测 JWT roles 驱动行级过滤 | ✅ 带 alice 令牌读 3 受控实体各 **16 行**(=alice 的行,非全量 50) |
+| 单测 | ✅ **16 用例全过**(要求 ≥8) |
+| CI 兼容(`scripts/ci.sh`,含 parity) | ✅ **全绿**:21/21 实体 1108 行 + C2 9/9 正例 + 3/3 负例 |
+
+---
+
+## 二、密码哈希侦察(证据)
+
+侦察对象:`/Users/zhengwr/workspace/eip3/framework`(旧系统源码)。读到的口径逐条:
+
+1. **哈希函数**:`com.dsasp.server.common.util.EncryptUtil.encodeMD5String`:
+ ```java
+ MessageDigest md5 = MessageDigest.getInstance("MD5");
+ byte[] bytes = md5.digest(str.getBytes()); // 平台默认字符集
+ // 逐字节小写十六进制,b<16 补前导 0 → 32 字符
+ ```
+ → **标准小写十六进制 MD5,无盐、无迭代**。
+2. **登录比对(服务端,`AuthConstroller#login`)**:按 `SYS_USER_SEARCH` 服务流,
+ `P.ACCOUNT = '<账号>'` + `PASSWORD = EncryptUtil.encodeMD5String(明文)`,纯相等命中。
+3. **改密(`ChangePasswordView`)**:`oldPwd.equals(entity.get_Value("PASSWORD"))`、
+ `map.put("PASSWORD", encodeMD5String(新明文))` 落库 → 印证存储即该 MD5、比对即 `equals`。
+4. **UI 登录(`LoginWindow`)**:同走 `SYS_USER_SEARCH`(按 ACCOUNT)取用户行;ctx 构建口径
+ (注释段)= `CURRENTUSER=pojo.get_ID()`、`CURRENTDEPART=MASTERDEPART`、`CURRENTORG=USERORGID`、
+ `ROLES=roleService.findRolesByUserId(userId)`——**这就是我适配引擎 ctx 的精确契约**。
+
+**复刻**:`com.eip4.platform.auth.security.PasswordHasher.md5Hex` 逐字节复刻(保真层不动),
+比对用 `MessageDigest.isEqual` 常量时间。单测断言 `MD5("123456")=e10adc3949ba59abbe56e057f20f883e`。
+
+> 已同步《迁移手册》§5.31。
+
+---
+
+## 三、JWT 选型(jjwt vs spring-security-oauth2-jose)
+
+**选 jjwt 0.12.6**,理由:
+- 本系统是**自签自验**的单一签发方,不与外部 IdP 联邦、无需 JWKS/非对称密钥轮转 →
+ HS256 + 配置化对称密钥即足够;oauth2-jose/资源服务器栈面向 OAuth2 联邦,在此属过度设计。
+- jjwt API 精简,0.12.x 强制安全默认(密钥长度校验、算法绑定),契合「最小可用」。
+- 与架构选型表「Spring Security + 无状态 JWT,免 session 共享」一致。
+
+**密钥不硬编码进仓库**:`JwtService` 构造期校验密钥存在且 ≥32 字节(HS256),缺失/过短直接启动失败。
+本地默认值仅放 `application.yml`/`application-local.yml`(`${EIP4_AUTH_JWT_SECRET:dev-only-...}`,
+注明生产须替换);生产经环境变量 `EIP4_AUTH_JWT_SECRET` 覆盖。
+> 注:CI 用 default profile,故 default 配置须有可启动的非生产默认密钥(已加注释强标「生产须替换」)。
+
+JWT claims:`iss/sub(账号)/userId/account/name/depart/org/roles(List)/iat/exp`;有效期默认 8h(可配)。
+
+---
+
+## 四、组件清单(全部 com.eip4.platform.auth.security)
+
+| 类 | 职责 |
+|----|------|
+| `JwtProperties` | `eip4.auth.jwt.*` 配置(secret/expireSeconds/issuer),无内置默认密钥 |
+| `JwtService` | HS256 签发/校验(过期/签名/issuer 校验);启动期密钥强度校验 |
+| `PasswordHasher` | 复刻 EncryptUtil 的无盐 MD5 + 常量时间比对 |
+| `SysUserService` | 只读 SELECT 校验 SYS_USER(按 ACCOUNT)+ 角色解析(复刻 RoleServiceImpl join,参数化) |
+| `AuthPrincipal` | JWT claims 不可变载体(record),映射 SYS_USER 列与 LoggedInUser 契约 |
+| `AuthController` | `POST /api/auth/login`,失败统一 401 含糊文案(防账号枚举) |
+| `EngineContextBinder` | 把 AuthPrincipal 写入引擎 UserSession(ROLES 用 put(List));bind/clear |
+| `JwtAuthFilter` | 校验 Bearer → SecurityContext + 引擎 ctx;**finally 无条件 clear** |
+| `SecurityConfig` | 双链按 profile:prod 严格(未认证 401),非 prod permitAll 测试通道 |
+| `AuthConfig` | `@EnableConfigurationProperties(JwtProperties)` |
+
+**EntityController 适配(platform-metadata)**:`buildCtx` 三级优先(asUser 参 > JWT 绑定 ctx > ADMIN),
+使 JWT roles 替代 asUser/roles 驱动行级过滤,且 C2 对拍旁路零回归。详见《迁移手册》§5.29。
+
+---
+
+## 五、实测证据(curl)
+
+### 5.1 登录签发 JWT(8086,连 eip4ci 自举库)
+
+```
+POST /api/auth/login {"account":"alice","password":"123456"}
+→ HTTP 200
+ {"success":true,"token":"eyJ...","expireSeconds":28800,
+ "userId":"USER_ALICE","account":"alice","name":"爱丽丝",
+ "roles":["ROLE_CUSTOMER","ROLE_PROJECT","ROLE_TASK"]}
+```
+
+### 5.2 JWT roles 驱动行级过滤(复用 C2 的 3 受控实体)
+
+带 alice 令牌(CURRENTUSER=USER_ALICE,roles=[ROLE_CUSTOMER/PROJECT/TASK])调受控实体,
+引擎按 `CREATEBY={CURRENTUSERID}` 过滤,**仅返回 alice 的行**:
+
+| 场景 | 实体 | HTTP | 返回行数 | 期望 |
+|------|------|------|---------|------|
+| 带令牌(JWT roles) | EIP4PT_CUSTOMER | 200 | **16** | alice 16 行(非全量 50)✅ |
+| 带令牌(JWT roles) | EIP4PT_PROJECT | 200 | **16** | ✅ |
+| 带令牌(JWT roles) | EIP4PT_TASK | 200 | **16** | ✅ |
+| 无令牌无 asUser | EIP4PT_CUSTOMER | 200 | 50 | ADMIN 视角不过滤(默认不变)✅ |
+| C2 旁路 ?asUser=USER_BOB | EIP4PT_CUSTOMER | 200 | 17 | 测试通道仍可用 ✅ |
+
+DB ground truth(CREATEBY 重分区后):ALICE 16 / BOB 17 / CAROL 17,逐数吻合。
+> JWT roles 成功**替代** asUser/roles 参数:同一引擎过滤路径,身份来源从查询参换成 JWT claims。
+
+### 5.3 严格鉴权(prod profile,8087)
+
+| 场景 | HTTP | 期望 |
+|------|------|------|
+| 登录正确口令 | 200 | 签发令牌 ✅ |
+| 登录错误口令 | 401 | 拒绝 ✅ |
+| 无令牌访问 /api/entity/** | **401** | 拒绝(凭据缺失)✅ |
+| 伪造签名令牌 | **401** | 拒绝 ✅ |
+| 乱码令牌 | **401** | 拒绝 ✅ |
+| 已过期令牌(expire=-3600s) | **401** | 拒绝 ✅ |
+| 带有效令牌访问 /api/entity/** | 200 | 放行 + 过滤 16 行 ✅ |
+
+> prod 链经 `HttpStatusEntryPoint(UNAUTHORIZED)` 使未认证返回 401(而非 Spring 默认 403,语义更正确)。
+> 并排除 `UserDetailsServiceAutoConfiguration`,免生成误导性 dev 口令(JWT 认证不需内存用户)。
+
+---
+
+## 六、单测(16 用例,platform-auth)
+
+`JwtServiceTest`(9):签发回读全 claim、过期被拒、异密钥伪造被拒、篡改串被拒、issuer 不符被拒、
+密钥缺失/过短构造失败、乱码非 JWT 被拒、MD5 口令哈希与框架口径一致。
+
+`EngineContextIsolationTest`(4):bind 写入再 clear 清空、过滤器请求收尾后清空、无令牌不填充、
+**16 线程×200 次不同令牌并发零串号 + 收尾零残留**(并发隔离证明)。
+
+`SecurityProfileTest`(3):**prod 链受保护路径无令牌=401**(测试旁路关闭断言)、
+prod 链仍放行登录端点与 API 文档、非 prod 链 permitAll 旁路开启(对拍 CI 依赖)。
+
+```
+Tests run: 16, Failures: 0, Errors: 0, Skipped: 0 —— BUILD SUCCESS
+```
+
+---
+
+## 七、CI 兼容
+
+`scripts/ci.sh`(default profile,连 eip4ci):
+- `--skip-parity`:编译 + 全模块单测 + ArchUnit 边界纪律 → 绿。
+- 完整(含 parity):**21/21 实体 1108 行 100% 逐行一致** + C2 权限对拍 **9/9 正例 + 3/3 负例**全过。
+
+> 关键:CI 用 default(非 prod)profile,安全层走 permitAll 测试通道,parity 的免令牌 +
+> asUser/roles 旁路**零回归**——证明安全层接入未破坏对拍门禁。ArchUnit 仍绿(新代码仅依赖
+> com.dsasp 的 UserSession/LoggedInUser,反向零依赖)。
+
+---
+
+## 八、自举数据(bootstrap-auth.sql)
+
+位置:`platform-parity/src/main/resources/bootstrap/bootstrap-auth.sql`(幂等,在 sys+privilege 之后追加)。
+内容:① SYS_USER 物理表(认证读路径列);② 测试用户 alice(SYS_USER_ID='USER_ALICE',口令 123456 的 MD5);
+③ 用户组/角色链(sys_usergroupuser ⋈ sys_usergrouprole,复刻 RoleServiceImpl 读路径)→ alice 得
+ROLE_CUSTOMER/PROJECT/TASK;④ 受控实体 CREATEBY 重分区(与 privilege 脚本同口径,使过滤可判别)。
+
+---
+
+## 九、新坑(已同步《迁移手册》)
+
+- §5.29 JWT 上下文被 EntityController 的 ADMIN 默认覆盖(认证集成坑)。
+- §5.30 引擎 UserSession 是静态 ThreadLocal,认证过滤器必须请求级 set/clear(ROLES 用 put(List))。
+- §5.31 客户库 SYS_USER 口令哈希=无盐小写十六进制 MD5(侦察结论)。
+
+## 附:产物清单
+
+- 实现:`platform-auth/src/main/java/com/eip4/platform/auth/security/`(10 类)
+- 适配:`platform-metadata/.../web/EntityController.java`(buildCtx 三级优先)
+- 配置:`pom.xml`(jjwt dependencyManagement)、`platform-auth/pom.xml`(security/jwt/jdbc)、
+ `platform-app/.../application.yml` + `application-local.yml`(JWT 配置 + 排除 UserDetailsService 自动配)
+- 自举:`platform-parity/.../bootstrap/bootstrap-auth.sql`
+- 单测:`platform-auth/src/test/.../security/`(3 类 16 用例)
+- 报告:本文件;新坑进《迁移手册》§5.29/5.30/5.31
diff --git a/platform-auth/pom.xml b/platform-auth/pom.xml
index c761542..1d8dca7 100644
--- a/platform-auth/pom.xml
+++ b/platform-auth/pom.xml
@@ -13,6 +13,16 @@
P2:组织/权限/数据权限真实现(当前为 PoC 桩 + C2 数据权限最小真实现)
com.eip4platform-legacy-core
+
+ org.springframework.bootspring-boot-starter-security
+ org.springframework.bootspring-boot-starter-web
+
+ org.springframework.bootspring-boot-starter-jdbc
+
+ io.jsonwebtokenjjwt-api
+ io.jsonwebtokenjjwt-implruntime
+ io.jsonwebtokenjjwt-jacksonruntime
org.springframework.bootspring-boot-starter-testtest
+ org.springframework.securityspring-security-testtest
diff --git a/platform-auth/src/main/java/com/eip4/platform/auth/security/AuthConfig.java b/platform-auth/src/main/java/com/eip4/platform/auth/security/AuthConfig.java
new file mode 100644
index 0000000..6c129c3
--- /dev/null
+++ b/platform-auth/src/main/java/com/eip4/platform/auth/security/AuthConfig.java
@@ -0,0 +1,14 @@
+package com.eip4.platform.auth.security;
+
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * platform-auth 安全模块装配入口:注册 {@link JwtProperties}。
+ * 其余组件({@link JwtService}/{@link SysUserService}/{@link SecurityConfig}/
+ * {@link AuthController})由 {@code com.eip4.platform} 组件扫描自动拾取。
+ */
+@Configuration
+@EnableConfigurationProperties(JwtProperties.class)
+public class AuthConfig {
+}
diff --git a/platform-auth/src/main/java/com/eip4/platform/auth/security/AuthController.java b/platform-auth/src/main/java/com/eip4/platform/auth/security/AuthController.java
new file mode 100644
index 0000000..8e2750f
--- /dev/null
+++ b/platform-auth/src/main/java/com/eip4/platform/auth/security/AuthController.java
@@ -0,0 +1,71 @@
+package com.eip4.platform.auth.security;
+
+import java.util.Optional;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 认证端点。{@code /api/auth/**} 由 {@code SecurityConfig} 放行(登录本身无需令牌)。
+ */
+@RestController
+@RequestMapping("/api/auth")
+public class AuthController {
+
+ private final SysUserService sysUserService;
+ private final JwtService jwtService;
+
+ public AuthController(SysUserService sysUserService, JwtService jwtService) {
+ this.sysUserService = sysUserService;
+ this.jwtService = jwtService;
+ }
+
+ /**
+ * 账号口令登录,成功签发 JWT。
+ *
+ * 失败统一返回 401 + 含糊文案(不区分「账号不存在」与「口令错误」,避免账号枚举)。
+ */
+ @PostMapping("/login")
+ public ResponseEntity login(@RequestBody LoginRequest req) {
+ if (req == null || req.account() == null || req.password() == null) {
+ return ResponseEntity.status(401).body(LoginResponse.failure("账号或密码错误"));
+ }
+ Optional user = sysUserService.authenticate(req.account(), req.password());
+ if (user.isEmpty()) {
+ return ResponseEntity.status(401).body(LoginResponse.failure("账号或密码错误"));
+ }
+ AuthPrincipal p = user.get();
+ String token = jwtService.issue(p);
+ return ResponseEntity.ok(LoginResponse.success(
+ token, jwtService.getExpireSeconds(), p.userId(), p.account(), p.name(), p.roles()));
+ }
+
+ /** 登录请求体。 */
+ public record LoginRequest(String account, String password) {
+ }
+
+ /** 登录响应体(失败时仅含 success=false + msg)。 */
+ public record LoginResponse(
+ boolean success,
+ String msg,
+ String token,
+ Long expireSeconds,
+ String userId,
+ String account,
+ String name,
+ java.util.List roles) {
+
+ static LoginResponse success(String token, long expireSeconds,
+ String userId, String account, String name,
+ java.util.List roles) {
+ return new LoginResponse(true, "", token, expireSeconds, userId, account, name, roles);
+ }
+
+ static LoginResponse failure(String msg) {
+ return new LoginResponse(false, msg, null, null, null, null, null, null);
+ }
+ }
+}
diff --git a/platform-auth/src/main/java/com/eip4/platform/auth/security/AuthPrincipal.java b/platform-auth/src/main/java/com/eip4/platform/auth/security/AuthPrincipal.java
new file mode 100644
index 0000000..866996c
--- /dev/null
+++ b/platform-auth/src/main/java/com/eip4/platform/auth/security/AuthPrincipal.java
@@ -0,0 +1,36 @@
+package com.eip4.platform.auth.security;
+
+import java.util.List;
+
+/**
+ * 已认证用户主体:JWT claims 的不可变载体。
+ *
+ * 同时承担两个角色:(1) 作为 Spring Security 的 principal;(2) 作为引擎上下文
+ * {@code UserSession} 的数据来源。各字段直接映射 {@code SYS_USER} 的列与
+ * {@code LoggedInUser} 契约:
+ *
+ * - {@code userId} → {@code CURRENTUSER}({@code SYS_USER_ID},行级过滤的 {@code CREATEBY={CURRENTUSERID}} 主体)
+ * - {@code depart} → {@code CURRENTDEPART}({@code MASTERDEPART})
+ * - {@code org} → {@code CURRENTORG}({@code USERORGID})
+ * - {@code roles} → {@code ROLES}(List,驱动 {@code SYS_FILTERRULE} 角色匹配)
+ *
+ *
+ * @param userId 用户主键 SYS_USER_ID(引擎 CURRENTUSER)
+ * @param account 登录账号 ACCOUNT
+ * @param name 姓名 NAME(展示用)
+ * @param depart 主部门 MASTERDEPART(引擎 CURRENTDEPART,可空)
+ * @param org 所属机构 USERORGID(引擎 CURRENTORG,可空)
+ * @param roles 角色 id 列表(引擎 ROLES,永不为 null)
+ */
+public record AuthPrincipal(
+ String userId,
+ String account,
+ String name,
+ String depart,
+ String org,
+ List roles) {
+
+ public AuthPrincipal {
+ roles = roles == null ? List.of() : List.copyOf(roles);
+ }
+}
diff --git a/platform-auth/src/main/java/com/eip4/platform/auth/security/EngineContextBinder.java b/platform-auth/src/main/java/com/eip4/platform/auth/security/EngineContextBinder.java
new file mode 100644
index 0000000..b50a0b6
--- /dev/null
+++ b/platform-auth/src/main/java/com/eip4/platform/auth/security/EngineContextBinder.java
@@ -0,0 +1,53 @@
+package com.eip4.platform.auth.security;
+
+import java.util.List;
+import java.util.Properties;
+
+import com.dsasp.server.common.user.service.LoggedInUser;
+import com.dsasp.server.common.util.UserSession;
+
+/**
+ * 引擎上下文桥:把 {@link AuthPrincipal} 写入保真层引擎的请求级上下文 {@code UserSession}。
+ *
+ * {@code UserSession} 是静态 ThreadLocal<Properties>(读源码核实):
+ * 引擎全程从当前线程取 {@code CURRENTUSER/CURRENTDEPART/CURRENTORG} 与
+ * {@code ROLES}(List)。因此每请求必须在当前处理线程上 {@code set},
+ * 处理结束 无条件 {@code clear}(finally),否则线程被 Tomcat 复用时
+ * 会把上一请求的身份泄漏给下一请求。本类只做 set/clear,泄漏隔离由
+ * {@code JwtAuthFilter} 的 try/finally 保证,并由并发单测断言。
+ *
+ *
不改保真层一行:仅调用 {@code UserSession.set/remove} 公有静态法。
+ */
+public final class EngineContextBinder {
+
+ private EngineContextBinder() {
+ }
+
+ /**
+ * 用已认证主体覆盖当前线程的引擎上下文。
+ *
+ *
非 ADMIN 上下文(CURRENTUSER = 真实 userId)将触发引擎行级数据过滤
+ * (引擎仅当 {@code CURRENTUSER != ADMIN} 时调 {@code dataPrivilegeService}),
+ * 从而以 JWT 内的 userId/roles 替代 C2 的 asUser/roles 测试参数。
+ */
+ public static void bind(AuthPrincipal principal) {
+ Properties ctx = new Properties();
+ if (principal.userId() != null) {
+ ctx.setProperty(LoggedInUser.CURRENTUSER, principal.userId());
+ }
+ if (principal.depart() != null) {
+ ctx.setProperty(LoggedInUser.CURRENTDEPART, principal.depart());
+ }
+ if (principal.org() != null) {
+ ctx.setProperty(LoggedInUser.CURRENTORG, principal.org());
+ }
+ // ROLES 是 List(非字符串):引擎按 ctx.get("ROLES") 强转 List,故用 put 而非 setProperty
+ ctx.put(LoggedInUser.ROLES, List.copyOf(principal.roles()));
+ UserSession.set(ctx);
+ }
+
+ /** 清空当前线程的引擎上下文(请求收尾,防跨请求泄漏)。 */
+ public static void clear() {
+ UserSession.remove();
+ }
+}
diff --git a/platform-auth/src/main/java/com/eip4/platform/auth/security/JwtAuthFilter.java b/platform-auth/src/main/java/com/eip4/platform/auth/security/JwtAuthFilter.java
new file mode 100644
index 0000000..2a5d606
--- /dev/null
+++ b/platform-auth/src/main/java/com/eip4/platform/auth/security/JwtAuthFilter.java
@@ -0,0 +1,93 @@
+package com.eip4.platform.auth.security;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import io.jsonwebtoken.JwtException;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+
+/**
+ * JWT 认证过滤器:校验 {@code Authorization: Bearer },通过则
+ * (1) 构造 Spring Security 的 {@code SecurityContext};
+ * (2) 把 claims 填充进引擎 {@code UserSession}(经 {@link EngineContextBinder})。
+ *
+ * 跨请求隔离:引擎上下文在 {@code finally} 中无条件
+ * {@code clear},确保 Tomcat 复用工作线程时绝不泄漏上一请求身份。
+ *
+ *
失败即不放行:令牌缺失/签名错/过期/伪造时,本过滤器不设置
+ * Authentication,把请求原样下放——受保护路径由 {@code SecurityConfig} 的
+ * {@code authenticated()} 规则拒为 401(放行路径如 /api/auth/** 不受影响)。
+ * 绝不因解析异常而「兜底放行」。
+ */
+public class JwtAuthFilter extends OncePerRequestFilter {
+
+ private static final Logger log = LoggerFactory.getLogger(JwtAuthFilter.class);
+ private static final String HEADER = "Authorization";
+ private static final String PREFIX = "Bearer ";
+
+ private final JwtService jwtService;
+
+ public JwtAuthFilter(JwtService jwtService) {
+ this.jwtService = jwtService;
+ }
+
+ @Override
+ protected void doFilterInternal(HttpServletRequest request,
+ HttpServletResponse response,
+ FilterChain chain) throws ServletException, IOException {
+ boolean ctxBound = false;
+ try {
+ AuthPrincipal principal = resolve(request);
+ if (principal != null) {
+ authenticate(principal);
+ EngineContextBinder.bind(principal);
+ ctxBound = true;
+ }
+ chain.doFilter(request, response);
+ } finally {
+ // 无条件清理:即便下游抛异常,也必须把引擎上下文从复用线程上摘除
+ if (ctxBound) {
+ EngineContextBinder.clear();
+ }
+ }
+ }
+
+ /** 解析 Bearer 令牌;无头/格式不符/校验失败均返回 null(不认证)。 */
+ private AuthPrincipal resolve(HttpServletRequest request) {
+ String header = request.getHeader(HEADER);
+ if (header == null || !header.startsWith(PREFIX)) {
+ return null;
+ }
+ String token = header.substring(PREFIX.length()).trim();
+ if (token.isEmpty()) {
+ return null;
+ }
+ try {
+ return jwtService.parse(token);
+ } catch (JwtException | IllegalArgumentException e) {
+ // 伪造/过期/篡改:记日志(不含令牌明文),不认证 → 受保护路径将得 401
+ log.debug("JWT 校验失败,拒绝认证: {}", e.getMessage());
+ return null;
+ }
+ }
+
+ /** 把已校验主体写入 SecurityContext,roles → ROLE_ 权限。 */
+ private void authenticate(AuthPrincipal principal) {
+ List authorities = principal.roles().stream()
+ .map(r -> new SimpleGrantedAuthority("ROLE_" + r))
+ .toList();
+ UsernamePasswordAuthenticationToken auth =
+ new UsernamePasswordAuthenticationToken(principal, null, authorities);
+ SecurityContextHolder.getContext().setAuthentication(auth);
+ }
+}
diff --git a/platform-auth/src/main/java/com/eip4/platform/auth/security/JwtProperties.java b/platform-auth/src/main/java/com/eip4/platform/auth/security/JwtProperties.java
new file mode 100644
index 0000000..51e47bd
--- /dev/null
+++ b/platform-auth/src/main/java/com/eip4/platform/auth/security/JwtProperties.java
@@ -0,0 +1,48 @@
+package com.eip4.platform.auth.security;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+/**
+ * JWT 配置(前缀 {@code eip4.auth.jwt})。
+ *
+ * 密钥不硬编码进仓库:本地默认值仅放 {@code application-local.yml}
+ * (HS256 至少 256 bit 的占位密钥,注明生产须替换);生产经环境变量
+ * {@code EIP4_AUTH_JWT_SECRET} 或外部配置注入。本类不内置任何默认密钥,
+ * 缺省时由 {@link JwtService} 启动期校验并报错,避免「忘了配密钥也能跑」的隐患。
+ */
+@ConfigurationProperties(prefix = "eip4.auth.jwt")
+public class JwtProperties {
+
+ /** HS256 对称密钥(Base64 或原文均可,长度须 ≥32 字节)。无默认值,必须外部配置。 */
+ private String secret;
+
+ /** 访问令牌有效期(秒)。默认 8 小时。 */
+ private long expireSeconds = 8 * 60 * 60;
+
+ /** 令牌签发者标识,写入 iss claim 并在校验时比对。 */
+ private String issuer = "eip4-platform";
+
+ public String getSecret() {
+ return secret;
+ }
+
+ public void setSecret(String secret) {
+ this.secret = secret;
+ }
+
+ public long getExpireSeconds() {
+ return expireSeconds;
+ }
+
+ public void setExpireSeconds(long expireSeconds) {
+ this.expireSeconds = expireSeconds;
+ }
+
+ public String getIssuer() {
+ return issuer;
+ }
+
+ public void setIssuer(String issuer) {
+ this.issuer = issuer;
+ }
+}
diff --git a/platform-auth/src/main/java/com/eip4/platform/auth/security/JwtService.java b/platform-auth/src/main/java/com/eip4/platform/auth/security/JwtService.java
new file mode 100644
index 0000000..816b09d
--- /dev/null
+++ b/platform-auth/src/main/java/com/eip4/platform/auth/security/JwtService.java
@@ -0,0 +1,116 @@
+package com.eip4.platform.auth.security;
+
+import java.nio.charset.StandardCharsets;
+import java.time.Instant;
+import java.util.Date;
+import java.util.List;
+
+import javax.crypto.SecretKey;
+
+import org.springframework.stereotype.Service;
+
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.JwtException;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.security.Keys;
+
+/**
+ * JWT 签发与校验(HS256 对称密钥,jjwt 0.12.x)。
+ *
+ *
选型理由:无状态 JWT 是单体私有化部署的自然选择(免 session 共享)。
+ * 在 jjwt 与 spring-security-oauth2-jose 之间选 jjwt:本系统是自签自验的
+ * 单一签发方,不与外部 IdP 联邦、无需 JWKS/非对称轮转,HS256 + 配置化对称密钥即足够;
+ * oauth2-jose/资源服务器栈面向 OAuth2 联邦场景,在此属过度设计。jjwt API 精简、
+ * 0.12.x 强制安全默认(密钥长度校验、算法绑定),契合「最小可用」。
+ *
+ *
密钥来自 {@link JwtProperties#getSecret()},构造期即校验存在且长度达标
+ * (HS256 要求 ≥256 bit),缺失/过短直接启动失败——杜绝弱密钥裸奔。
+ */
+@Service
+public class JwtService {
+
+ /** 自定义 claim 键(标准键 sub/iss/iat/exp 由 jjwt 内建)。 */
+ static final String CLAIM_USER_ID = "userId";
+ static final String CLAIM_ACCOUNT = "account";
+ static final String CLAIM_NAME = "name";
+ static final String CLAIM_DEPART = "depart";
+ static final String CLAIM_ORG = "org";
+ static final String CLAIM_ROLES = "roles";
+
+ private final SecretKey key;
+ private final long expireSeconds;
+ private final String issuer;
+
+ public JwtService(JwtProperties props) {
+ String secret = props.getSecret();
+ if (secret == null || secret.isBlank()) {
+ throw new IllegalStateException(
+ "JWT 密钥未配置:请设置 eip4.auth.jwt.secret(环境变量 EIP4_AUTH_JWT_SECRET)。"
+ + "本地默认值见 application-local.yml,生产须替换为强随机密钥。");
+ }
+ byte[] keyBytes = secret.getBytes(StandardCharsets.UTF_8);
+ if (keyBytes.length < 32) {
+ throw new IllegalStateException(
+ "JWT 密钥过短:HS256 要求 ≥32 字节(256 bit),当前 " + keyBytes.length + " 字节。");
+ }
+ this.key = Keys.hmacShaKeyFor(keyBytes);
+ this.expireSeconds = props.getExpireSeconds();
+ this.issuer = props.getIssuer();
+ }
+
+ /** 为已通过密码校验的用户签发访问令牌。 */
+ public String issue(AuthPrincipal principal) {
+ Instant now = Instant.now();
+ Instant exp = now.plusSeconds(expireSeconds);
+ return Jwts.builder()
+ .issuer(issuer)
+ .subject(principal.account())
+ .claim(CLAIM_USER_ID, principal.userId())
+ .claim(CLAIM_ACCOUNT, principal.account())
+ .claim(CLAIM_NAME, principal.name())
+ .claim(CLAIM_DEPART, principal.depart())
+ .claim(CLAIM_ORG, principal.org())
+ .claim(CLAIM_ROLES, principal.roles())
+ .issuedAt(Date.from(now))
+ .expiration(Date.from(exp))
+ .signWith(key)
+ .compact();
+ }
+
+ /**
+ * 校验并解析令牌。签名错误/过期/issuer 不符/格式非法均抛 {@link JwtException}
+ * (由调用方 {@code JwtAuthFilter} 翻译为 401,绝不放行)。
+ *
+ * @return 令牌内嵌的用户主体
+ * @throws JwtException 校验失败
+ */
+ public AuthPrincipal parse(String token) {
+ Claims claims = Jwts.parser()
+ .requireIssuer(issuer)
+ .verifyWith(key)
+ .build()
+ .parseSignedClaims(token)
+ .getPayload();
+ return new AuthPrincipal(
+ claims.get(CLAIM_USER_ID, String.class),
+ claims.get(CLAIM_ACCOUNT, String.class),
+ claims.get(CLAIM_NAME, String.class),
+ claims.get(CLAIM_DEPART, String.class),
+ claims.get(CLAIM_ORG, String.class),
+ rolesOf(claims));
+ }
+
+ /** 令牌有效期(秒),登录响应回带供前端管理刷新时机。 */
+ public long getExpireSeconds() {
+ return expireSeconds;
+ }
+
+ @SuppressWarnings("unchecked")
+ private static List rolesOf(Claims claims) {
+ Object raw = claims.get(CLAIM_ROLES);
+ if (raw instanceof List> list) {
+ return list.stream().map(String::valueOf).toList();
+ }
+ return List.of();
+ }
+}
diff --git a/platform-auth/src/main/java/com/eip4/platform/auth/security/PasswordHasher.java b/platform-auth/src/main/java/com/eip4/platform/auth/security/PasswordHasher.java
new file mode 100644
index 0000000..c3ac5fe
--- /dev/null
+++ b/platform-auth/src/main/java/com/eip4/platform/auth/security/PasswordHasher.java
@@ -0,0 +1,66 @@
+package com.eip4.platform.auth.security;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+/**
+ * 密码哈希——与保真层 {@code com.dsasp.server.common.util.EncryptUtil#encodeMD5String}
+ * 逐字节一致的复刻(侦察结论见 P2认证实测报告.md §密码哈希)。
+ *
+ * 客户库 {@code SYS_USER.PASSWORD} 落地算法实况(读 framework 源码核实):
+ *
+ * MessageDigest.getInstance("MD5").digest(str.getBytes())
+ * → 逐字节小写十六进制(b<16 补前导 0),32 字符,无盐、无迭代。
+ * 登录比对为 hash.equals(PASSWORD) 纯字符串相等(见 AuthConstroller / ChangePasswordView)。
+ *
+ * 故本类不引入 Spring Security 的 {@code PasswordEncoder}(BCrypt 等),而原样复刻
+ * MD5——目标是验证既有客户库口令,保真兼容优先于「现代更强哈希」。
+ * (口令存储现代化是后续独立议题:可在改密路径渐进迁移,不在本认证任务范围。)
+ *
+ * 不在保真层改一行:本复刻置于 {@code com.eip4},EncryptUtil 原样不动。
+ */
+public final class PasswordHasher {
+
+ private PasswordHasher() {
+ }
+
+ /**
+ * 计算明文口令的 MD5 哈希(小写十六进制,32 字符),与客户库存储格式一致。
+ *
+ *
实现与 EncryptUtil 一致:用平台默认字符集 {@code str.getBytes()}
+ * (与旧系统运行环境保持一致,避免跨字符集导致同口令异哈希)。
+ */
+ public static String md5Hex(String plain) {
+ try {
+ MessageDigest md5 = MessageDigest.getInstance("MD5");
+ byte[] bytes = md5.digest(plain.getBytes());
+ StringBuilder sb = new StringBuilder(bytes.length * 2);
+ for (byte b : bytes) {
+ int bt = b & 0xff;
+ if (bt < 16) {
+ sb.append('0');
+ }
+ sb.append(Integer.toHexString(bt));
+ }
+ return sb.toString();
+ } catch (NoSuchAlgorithmException e) {
+ // MD5 是 JDK 必备算法,不可能缺失;包装为非受检异常以简化调用方
+ throw new IllegalStateException("JDK 缺少 MD5 算法", e);
+ }
+ }
+
+ /**
+ * 常量时间比对哈希,避免按字符早退的时序侧信道。
+ *
+ * @param storedHash 客户库 SYS_USER.PASSWORD 中的哈希
+ * @param plain 用户提交的明文口令
+ */
+ public static boolean matches(String storedHash, String plain) {
+ if (storedHash == null || plain == null) {
+ return false;
+ }
+ byte[] a = storedHash.trim().getBytes();
+ byte[] b = md5Hex(plain).getBytes();
+ return MessageDigest.isEqual(a, b);
+ }
+}
diff --git a/platform-auth/src/main/java/com/eip4/platform/auth/security/SecurityConfig.java b/platform-auth/src/main/java/com/eip4/platform/auth/security/SecurityConfig.java
new file mode 100644
index 0000000..c50df96
--- /dev/null
+++ b/platform-auth/src/main/java/com/eip4/platform/auth/security/SecurityConfig.java
@@ -0,0 +1,93 @@
+package com.eip4.platform.auth.security;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
+import org.springframework.http.HttpStatus;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.HttpStatusEntryPoint;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
+
+/**
+ * Spring Security 配置(无状态,STATELESS:不建 HttpSession,免 session 共享)。
+ *
+ *
双链按 profile 装配:
+ *
+ * - prod(生产):严格链——{@code /api/auth/**}、swagger/openapi 放行,
+ * 其余 {@code /api/**} 必须认证;无任何测试旁路。
+ * - 非 prod(default/local/ci 等):宽松链——保留 {@code permitAll} 测试通道,
+ * 使对拍框架的免令牌 + {@code asUser/roles} 旁路可用(CI 依赖)。JWT 过滤器仍挂载,
+ * 带令牌照常填充引擎上下文。
+ *
+ * 「生产绝不放行」由 {@code @Profile} 条件装配硬保证,并由 {@code SecurityProfileTest} 断言。
+ *
+ * 两链共享的放行清单与无状态/无表单/无 CSRF 设定抽到 {@link #applyCommon}。
+ */
+@Configuration
+public class SecurityConfig {
+
+ /** 始终放行的路径:登录端点 + API 文档(认证前置依赖,不得拦)。 */
+ static final String[] PUBLIC_PATHS = {
+ "/api/auth/**",
+ "/swagger-ui/**", "/swagger-ui.html",
+ "/v3/api-docs/**", "/v3/api-docs.yaml",
+ };
+
+ private final JwtService jwtService;
+
+ public SecurityConfig(JwtService jwtService) {
+ this.jwtService = jwtService;
+ }
+
+ /** 生产链:其余 /api/** 一律需认证,无测试旁路。 */
+ @Bean
+ @Profile("prod")
+ SecurityFilterChain prodFilterChain(HttpSecurity http) throws Exception {
+ applyCommon(http);
+ http.authorizeHttpRequests(reg -> reg
+ .requestMatchers(publicMatchers()).permitAll()
+ .requestMatchers(new AntPathRequestMatcher("/api/**")).authenticated()
+ .anyRequest().authenticated());
+ // 未认证访问受保护资源返回 401(语义正确:凭据缺失/无效),而非 Spring 默认的 403
+ http.exceptionHandling(eh -> eh.authenticationEntryPoint(
+ new HttpStatusEntryPoint(HttpStatus.UNAUTHORIZED)));
+ return http.build();
+ }
+
+ /**
+ * 非生产链(default/local/ci):保留 permitAll 测试通道。
+ * JWT 过滤器照常挂载——带令牌走 JWT 上下文,不带令牌走 asUser/roles 旁路(对拍 CI 依赖)。
+ */
+ @Bean
+ @Profile("!prod")
+ SecurityFilterChain devFilterChain(HttpSecurity http) throws Exception {
+ applyCommon(http);
+ http.authorizeHttpRequests(reg -> reg.anyRequest().permitAll());
+ return http.build();
+ }
+
+ /** 放行清单转 Ant 路径匹配器(不依赖 MVC introspector,生产/切片测试一致)。 */
+ private static AntPathRequestMatcher[] publicMatchers() {
+ AntPathRequestMatcher[] matchers = new AntPathRequestMatcher[PUBLIC_PATHS.length];
+ for (int i = 0; i < PUBLIC_PATHS.length; i++) {
+ matchers[i] = new AntPathRequestMatcher(PUBLIC_PATHS[i]);
+ }
+ return matchers;
+ }
+
+ /** 共享:无状态会话、关表单/Basic/CSRF、挂 JWT 过滤器于用户名密码过滤器之前。 */
+ private void applyCommon(HttpSecurity http) throws Exception {
+ http
+ .csrf(AbstractHttpConfigurer::disable)
+ .formLogin(AbstractHttpConfigurer::disable)
+ .httpBasic(AbstractHttpConfigurer::disable)
+ .logout(AbstractHttpConfigurer::disable)
+ .sessionManagement(sm -> sm.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+ .addFilterBefore(new JwtAuthFilter(jwtService),
+ UsernamePasswordAuthenticationFilter.class);
+ }
+}
diff --git a/platform-auth/src/main/java/com/eip4/platform/auth/security/SysUserService.java b/platform-auth/src/main/java/com/eip4/platform/auth/security/SysUserService.java
new file mode 100644
index 0000000..52ea8aa
--- /dev/null
+++ b/platform-auth/src/main/java/com/eip4/platform/auth/security/SysUserService.java
@@ -0,0 +1,106 @@
+package com.eip4.platform.auth.security;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.dao.DataAccessException;
+import org.springframework.dao.EmptyResultDataAccessException;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * 客户库 {@code SYS_USER} 账号口令校验 + 角色解析(只读 SELECT,不写库)。
+ *
+ *
口径与 framework 登录路径一致(见 {@code AuthConstroller#login} /
+ * {@code LoginWindow}):按 {@code ACCOUNT} 取用户行,口令存储为
+ * {@code EncryptUtil.encodeMD5String} 的小写十六进制 MD5,纯字符串相等比对(无盐)。
+ *
+ *
角色解析复刻 {@code RoleServiceImpl#findRolesByUserId}:
+ * {@code sys_usergrouprole ⋈ sys_usergroupuser}(用户→用户组→角色)。
+ * 较旧实现的字符串拼接,本处改用 {@code ?} 占位参数化(安全第 2 层「渐进参数化」)。
+ * org 模块尚未移植(P2-org 职责),故若用户组/角色表缺失则降级为空角色,不致登录失败。
+ */
+@Service
+public class SysUserService {
+
+ private static final Logger log = LoggerFactory.getLogger(SysUserService.class);
+
+ /** SYS_USER 取用户:按账号查(参数化),仅取认证与上下文所需列。 */
+ private static final String SQL_FIND_BY_ACCOUNT =
+ "SELECT SYS_USER_ID, ACCOUNT, PASSWORD, NAME, MASTERDEPART, USERORGID "
+ + "FROM SYS_USER WHERE ACCOUNT = ?";
+
+ /** 角色解析:用户→用户组→角色(参数化,复刻 RoleServiceImpl 的 join)。 */
+ private static final String SQL_ROLES_BY_USER =
+ "SELECT DISTINCT ugr.roleid FROM sys_usergrouprole ugr "
+ + "INNER JOIN sys_usergroupuser ugu ON ugu.usergroupid = ugr.usergroupid "
+ + "WHERE ugu.userid = ?";
+
+ private final JdbcTemplate jdbcTemplate;
+
+ public SysUserService(JdbcTemplate jdbcTemplate) {
+ this.jdbcTemplate = jdbcTemplate;
+ }
+
+ /**
+ * 校验账号口令,成功则返回填充好的用户主体(含角色)。
+ *
+ * @return 校验通过的 {@link AuthPrincipal};账号不存在或口令不符返回 {@link Optional#empty()}
+ */
+ @Transactional(readOnly = true)
+ public Optional authenticate(String account, String rawPassword) {
+ if (account == null || account.isBlank() || rawPassword == null) {
+ return Optional.empty();
+ }
+ UserRow row;
+ try {
+ row = jdbcTemplate.queryForObject(SQL_FIND_BY_ACCOUNT, (rs, n) -> new UserRow(
+ trim(rs.getString("SYS_USER_ID")),
+ trim(rs.getString("ACCOUNT")),
+ rs.getString("PASSWORD"),
+ rs.getString("NAME"),
+ trim(rs.getString("MASTERDEPART")),
+ trim(rs.getString("USERORGID"))), account);
+ } catch (EmptyResultDataAccessException e) {
+ return Optional.empty();
+ }
+ if (row == null || !PasswordHasher.matches(row.password(), rawPassword)) {
+ return Optional.empty();
+ }
+ List roles = findRoles(row.userId());
+ return Optional.of(new AuthPrincipal(
+ row.userId(), row.account(), row.name(), row.depart(), row.org(), roles));
+ }
+
+ /** 解析用户角色;org 表缺失时降级为空列表(不阻断登录)。 */
+ private List findRoles(String userId) {
+ try {
+ List roles = jdbcTemplate.queryForList(SQL_ROLES_BY_USER, String.class, userId);
+ List trimmed = new ArrayList<>(roles.size());
+ for (String r : roles) {
+ String t = trim(r);
+ if (t != null && !t.isEmpty()) {
+ trimmed.add(t);
+ }
+ }
+ return trimmed;
+ } catch (DataAccessException e) {
+ log.warn("角色解析失败(org 用户组/角色表可能尚未移植),登录降级为空角色: {}", e.getMessage());
+ return List.of();
+ }
+ }
+
+ private static String trim(String s) {
+ return s == null ? null : s.trim();
+ }
+
+ /** SYS_USER 行投影。char(36) 列 PG 返回带尾空格,统一 trim。 */
+ private record UserRow(
+ String userId, String account, String password,
+ String name, String depart, String org) {
+ }
+}
diff --git a/platform-auth/src/test/java/com/eip4/platform/auth/security/EngineContextIsolationTest.java b/platform-auth/src/test/java/com/eip4/platform/auth/security/EngineContextIsolationTest.java
new file mode 100644
index 0000000..9d07154
--- /dev/null
+++ b/platform-auth/src/test/java/com/eip4/platform/auth/security/EngineContextIsolationTest.java
@@ -0,0 +1,175 @@
+package com.eip4.platform.auth.security;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+import java.util.Properties;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.mock.web.MockFilterChain;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpServletResponse;
+import org.springframework.security.core.context.SecurityContextHolder;
+
+import com.dsasp.server.common.user.service.LoggedInUser;
+import com.dsasp.server.common.util.UserSession;
+
+/**
+ * 引擎上下文 set/clear 的并发隔离证明:
+ * (1) bind 后引擎 UserSession 命中正确身份;(2) clear/过滤器收尾后线程上无残留;
+ * (3) 多线程并发各自带不同令牌时,绝不串号(每线程只看到自己的 userId/roles)。
+ */
+class EngineContextIsolationTest {
+
+ private static final String SECRET = "isolation-test-secret-key-long-enough-abcdefghijklmnop";
+
+ private JwtService jwtService() {
+ JwtProperties p = new JwtProperties();
+ p.setSecret(SECRET);
+ p.setIssuer("eip4-platform");
+ return new JwtService(p);
+ }
+
+ @AfterEach
+ void cleanup() {
+ UserSession.remove();
+ SecurityContextHolder.clearContext();
+ }
+
+ @Test
+ void bind写入再clear清空() {
+ AuthPrincipal alice = new AuthPrincipal("USER_ALICE", "alice", "爱丽丝",
+ "DEPT_A", "ORG_1", List.of("ROLE_CUSTOMER"));
+ EngineContextBinder.bind(alice);
+
+ Properties ctx = UserSession.get();
+ assertEquals("USER_ALICE", ctx.getProperty(LoggedInUser.CURRENTUSER));
+ assertEquals("DEPT_A", ctx.getProperty(LoggedInUser.CURRENTDEPART));
+ assertEquals("ORG_1", ctx.getProperty(LoggedInUser.CURRENTORG));
+ assertEquals(List.of("ROLE_CUSTOMER"), ctx.get(LoggedInUser.ROLES));
+
+ EngineContextBinder.clear();
+ assertNull(UserSession.get(), "clear 后引擎上下文必须为空,杜绝跨请求泄漏");
+ }
+
+ @Test
+ void 过滤器请求收尾后清空上下文() throws Exception {
+ JwtService svc = jwtService();
+ String token = svc.issue(new AuthPrincipal("USER_BOB", "bob", "鲍勃",
+ null, null, List.of("ROLE_TASK")));
+
+ JwtAuthFilter filter = new JwtAuthFilter(svc);
+ MockHttpServletRequest req = new MockHttpServletRequest("GET", "/api/entity/x/list");
+ req.addHeader("Authorization", "Bearer " + token);
+ MockHttpServletResponse resp = new MockHttpServletResponse();
+
+ // 下游链断言:链执行期间上下文已填充
+ AtomicBoolean ctxSeenInChain = new AtomicBoolean(false);
+ MockFilterChain chain = new MockFilterChain() {
+ @Override
+ public void doFilter(jakarta.servlet.ServletRequest request,
+ jakarta.servlet.ServletResponse response) {
+ Properties ctx = UserSession.get();
+ ctxSeenInChain.set(ctx != null
+ && "USER_BOB".equals(ctx.getProperty(LoggedInUser.CURRENTUSER)));
+ }
+ };
+ filter.doFilter(req, resp, chain);
+
+ assertTrue(ctxSeenInChain.get(), "过滤器链执行期间引擎上下文应已填充为 USER_BOB");
+ assertNull(UserSession.get(), "过滤器 finally 后引擎上下文必须清空");
+ }
+
+ @Test
+ void 无令牌不填充上下文且收尾干净() throws Exception {
+ JwtAuthFilter filter = new JwtAuthFilter(jwtService());
+ MockHttpServletRequest req = new MockHttpServletRequest("GET", "/api/entity/x/list");
+ MockHttpServletResponse resp = new MockHttpServletResponse();
+ AtomicBoolean emptyInChain = new AtomicBoolean(false);
+ MockFilterChain chain = new MockFilterChain() {
+ @Override
+ public void doFilter(jakarta.servlet.ServletRequest request,
+ jakarta.servlet.ServletResponse response) {
+ emptyInChain.set(UserSession.get() == null);
+ }
+ };
+ filter.doFilter(req, resp, chain);
+ assertTrue(emptyInChain.get(), "无令牌时不应填充引擎上下文(留给 asUser/roles 旁路或 ADMIN 视角)");
+ assertNull(UserSession.get());
+ }
+
+ @Test
+ void 并发不同令牌各自隔离不串号() throws Exception {
+ JwtService svc = jwtService();
+ JwtAuthFilter filter = new JwtAuthFilter(svc);
+
+ int threads = 16;
+ int iterations = 200;
+ ExecutorService pool = Executors.newFixedThreadPool(threads);
+ CountDownLatch start = new CountDownLatch(1);
+ CountDownLatch done = new CountDownLatch(threads);
+ // 收集任何串号:key=期望 userId,value=实际观测到的不一致 userId
+ ConcurrentHashMap leaks = new ConcurrentHashMap<>();
+ AtomicBoolean residueAfter = new AtomicBoolean(false);
+
+ for (int i = 0; i < threads; i++) {
+ String userId = "USER_" + i;
+ String role = "ROLE_" + i;
+ String token = svc.issue(new AuthPrincipal(userId, "acc" + i, "n" + i,
+ null, null, List.of(role)));
+ pool.submit(() -> {
+ try {
+ start.await();
+ for (int k = 0; k < iterations; k++) {
+ MockHttpServletRequest req =
+ new MockHttpServletRequest("GET", "/api/entity/x/list");
+ req.addHeader("Authorization", "Bearer " + token);
+ MockHttpServletResponse resp = new MockHttpServletResponse();
+ MockFilterChain chain = new MockFilterChain() {
+ @Override
+ public void doFilter(jakarta.servlet.ServletRequest rq,
+ jakarta.servlet.ServletResponse rs) {
+ Properties ctx = UserSession.get();
+ String seen = ctx == null ? null
+ : ctx.getProperty(LoggedInUser.CURRENTUSER);
+ if (!userId.equals(seen)) {
+ leaks.put(userId, String.valueOf(seen));
+ }
+ @SuppressWarnings("unchecked")
+ List roles = ctx == null ? null
+ : (List) ctx.get(LoggedInUser.ROLES);
+ if (roles == null || !roles.equals(List.of(role))) {
+ leaks.put(userId + "#roles", String.valueOf(roles));
+ }
+ }
+ };
+ filter.doFilter(req, resp, chain);
+ // 每次请求收尾后,本线程上下文必须已清空
+ if (UserSession.get() != null) {
+ residueAfter.set(true);
+ }
+ }
+ } catch (Exception e) {
+ leaks.put("EXC", e.toString());
+ } finally {
+ done.countDown();
+ }
+ });
+ }
+ start.countDown();
+ assertTrue(done.await(60, TimeUnit.SECONDS), "并发任务应在超时内完成");
+ pool.shutdownNow();
+
+ assertTrue(leaks.isEmpty(), "并发下不得串号/泄漏,实际异常: " + leaks);
+ assertTrue(!residueAfter.get(), "每次请求收尾后线程上不得残留引擎上下文");
+ }
+}
diff --git a/platform-auth/src/test/java/com/eip4/platform/auth/security/JwtServiceTest.java b/platform-auth/src/test/java/com/eip4/platform/auth/security/JwtServiceTest.java
new file mode 100644
index 0000000..e750338
--- /dev/null
+++ b/platform-auth/src/test/java/com/eip4/platform/auth/security/JwtServiceTest.java
@@ -0,0 +1,119 @@
+package com.eip4.platform.auth.security;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import io.jsonwebtoken.JwtException;
+
+/**
+ * JWT 签发/校验/过期/伪造 单测(不起 Spring 上下文,直接构造 JwtService)。
+ */
+class JwtServiceTest {
+
+ private static final String SECRET = "unit-test-secret-key-which-is-long-enough-0123456789";
+
+ private static JwtService service(long expireSeconds) {
+ JwtProperties p = new JwtProperties();
+ p.setSecret(SECRET);
+ p.setExpireSeconds(expireSeconds);
+ p.setIssuer("eip4-platform");
+ return new JwtService(p);
+ }
+
+ private static AuthPrincipal sample() {
+ return new AuthPrincipal("USER_ALICE", "alice", "爱丽丝",
+ "DEPT_A", "ORG_1", List.of("ROLE_CUSTOMER", "ROLE_TASK"));
+ }
+
+ @Test
+ void 签发并回读全部claim() {
+ JwtService svc = service(3600);
+ String token = svc.issue(sample());
+ AuthPrincipal back = svc.parse(token);
+
+ assertEquals("USER_ALICE", back.userId());
+ assertEquals("alice", back.account());
+ assertEquals("爱丽丝", back.name());
+ assertEquals("DEPT_A", back.depart());
+ assertEquals("ORG_1", back.org());
+ assertEquals(List.of("ROLE_CUSTOMER", "ROLE_TASK"), back.roles());
+ }
+
+ @Test
+ void 过期令牌校验失败() {
+ // 负有效期 → 签发即已过期
+ JwtService svc = service(-10);
+ String token = svc.issue(sample());
+ assertThrows(JwtException.class, () -> svc.parse(token));
+ }
+
+ @Test
+ void 异密钥伪造令牌被拒() {
+ JwtService issuer = service(3600);
+ String token = issuer.issue(sample());
+
+ JwtProperties other = new JwtProperties();
+ other.setSecret("a-totally-different-secret-key-also-long-enough-9876543210");
+ other.setIssuer("eip4-platform");
+ JwtService verifier = new JwtService(other);
+
+ assertThrows(JwtException.class, () -> verifier.parse(token));
+ }
+
+ @Test
+ void 篡改令牌串被拒() {
+ JwtService svc = service(3600);
+ String token = svc.issue(sample());
+ // 翻转 payload 段末位字符,破坏签名一致性
+ String tampered = token.substring(0, token.length() - 1)
+ + (token.endsWith("A") ? "B" : "A");
+ assertThrows(JwtException.class, () -> svc.parse(tampered));
+ }
+
+ @Test
+ void issuer不符被拒() {
+ JwtProperties issuerProps = new JwtProperties();
+ issuerProps.setSecret(SECRET);
+ issuerProps.setIssuer("someone-else");
+ JwtService foreignIssuer = new JwtService(issuerProps);
+ String token = foreignIssuer.issue(sample());
+
+ JwtService ours = service(3600); // issuer = eip4-platform
+ assertThrows(JwtException.class, () -> ours.parse(token));
+ }
+
+ @Test
+ void 密钥缺失则构造失败() {
+ JwtProperties p = new JwtProperties();
+ p.setSecret(" ");
+ assertThrows(IllegalStateException.class, () -> new JwtService(p));
+ }
+
+ @Test
+ void 密钥过短则构造失败() {
+ JwtProperties p = new JwtProperties();
+ p.setSecret("short"); // < 32 字节
+ assertThrows(IllegalStateException.class, () -> new JwtService(p));
+ }
+
+ @Test
+ void 乱码非JWT串被拒() {
+ JwtService svc = service(3600);
+ assertThrows(RuntimeException.class, () -> svc.parse("not-a-jwt-token"));
+ }
+
+ @Test
+ void md5口令哈希与框架口径一致() {
+ // framework EncryptUtil.encodeMD5String("123456") 的标准小写十六进制 MD5
+ assertEquals("e10adc3949ba59abbe56e057f20f883e",
+ PasswordHasher.md5Hex("123456"));
+ assertTrue(PasswordHasher.matches("e10adc3949ba59abbe56e057f20f883e", "123456"));
+ assertFalse(PasswordHasher.matches("e10adc3949ba59abbe56e057f20f883e", "wrong"));
+ }
+}
diff --git a/platform-auth/src/test/java/com/eip4/platform/auth/security/SecurityProfileTest.java b/platform-auth/src/test/java/com/eip4/platform/auth/security/SecurityProfileTest.java
new file mode 100644
index 0000000..6dd54ae
--- /dev/null
+++ b/platform-auth/src/test/java/com/eip4/platform/auth/security/SecurityProfileTest.java
@@ -0,0 +1,86 @@
+package com.eip4.platform.auth.security;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
+import org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration;
+import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpServletResponse;
+import org.springframework.security.web.FilterChainProxy;
+
+import jakarta.servlet.http.HttpServletResponse;
+
+/**
+ * 安全链按 profile 装配的断言:
+ *
+ * - 生产链(prod):测试旁路关闭——无令牌访问 /api/entity/** 被拒(401/403,非 2xx);
+ * 放行清单(/api/auth/**、/v3/api-docs/**)仍开。
+ * - 非生产链(无 profile):permitAll 测试通道开启——无令牌访问 /api/entity/** 放行(对拍 CI 依赖)。
+ *
+ * 用 WebApplicationContextRunner 直接装载 SecurityConfig + 真实 Security 自动配置,
+ * 取出 springSecurityFilterChain 跑 Mock 请求观察拦截结果,不需起整 Boot 应用。
+ */
+class SecurityProfileTest {
+
+ private static final String SECRET = "profile-test-secret-key-long-enough-abcdefghijklmnopqr";
+
+ private WebApplicationContextRunner runner() {
+ JwtProperties props = new JwtProperties();
+ props.setSecret(SECRET);
+ props.setIssuer("eip4-platform");
+ JwtService jwt = new JwtService(props);
+ return new WebApplicationContextRunner()
+ .withConfiguration(org.springframework.boot.autoconfigure.AutoConfigurations.of(
+ SecurityAutoConfiguration.class,
+ SecurityFilterAutoConfiguration.class))
+ .withBean(JwtService.class, () -> jwt)
+ .withUserConfiguration(SecurityConfig.class);
+ }
+
+ /** 经 springSecurityFilterChain 跑一个 mock 请求,返回最终响应状态码(被拦则非 200)。 */
+ private int statusThroughChain(org.springframework.context.ApplicationContext ctx,
+ String method, String uri) throws Exception {
+ FilterChainProxy chain = ctx.getBean("springSecurityFilterChain", FilterChainProxy.class);
+ MockHttpServletRequest req = new MockHttpServletRequest(method, uri);
+ req.setServletPath(uri);
+ MockHttpServletResponse resp = new MockHttpServletResponse();
+ // 终端链:若安全链放行到此,则置 200;若安全链已拒(401/403),resp 已被写入状态
+ chain.doFilter(req, resp, (rq, rs) -> ((HttpServletResponse) rs).setStatus(200));
+ return resp.getStatus();
+ }
+
+ @Test
+ void 生产链关闭测试旁路_受保护路径无令牌被拒() {
+ runner().withPropertyValues("spring.profiles.active=prod").run(ctx -> {
+ assertThat(ctx).hasNotFailed();
+ int protectedStatus = statusThroughChain(ctx, "GET", "/api/entity/EIP4PT_TASK/list");
+ assertThat(protectedStatus)
+ .as("生产 profile:受保护 API 无令牌必须被拒为 401(凭据缺失)")
+ .isEqualTo(401);
+ });
+ }
+
+ @Test
+ void 生产链仍放行登录端点与API文档() {
+ runner().withPropertyValues("spring.profiles.active=prod").run(ctx -> {
+ assertThat(ctx).hasNotFailed();
+ assertThat(statusThroughChain(ctx, "POST", "/api/auth/login"))
+ .as("登录端点须放行").isEqualTo(200);
+ assertThat(statusThroughChain(ctx, "GET", "/v3/api-docs"))
+ .as("OpenAPI 文档须放行").isEqualTo(200);
+ });
+ }
+
+ @Test
+ void 非生产链开启测试旁路_无令牌放行() {
+ // 无 active profile → devFilterChain(@Profile("!prod"))
+ runner().run(ctx -> {
+ assertThat(ctx).hasNotFailed();
+ assertThat(statusThroughChain(ctx, "GET", "/api/entity/EIP4PT_TASK/list"))
+ .as("非生产 profile:permitAll 测试通道开启,无令牌应放行(对拍 CI 依赖)")
+ .isEqualTo(200);
+ });
+ }
+}
diff --git a/platform-metadata/src/main/java/com/eip4/platform/metadata/web/EntityController.java b/platform-metadata/src/main/java/com/eip4/platform/metadata/web/EntityController.java
index a339e7a..d54c763 100644
--- a/platform-metadata/src/main/java/com/eip4/platform/metadata/web/EntityController.java
+++ b/platform-metadata/src/main/java/com/eip4/platform/metadata/web/EntityController.java
@@ -130,25 +130,41 @@ public class EntityController {
}
/**
- * 构造调用上下文。无 asUser → ADMIN 视角(不触发过滤);有 asUser → 非 ADMIN 视角,
- * 把 CURRENTUSER 与 ROLES(List)放入 Properties,交由引擎按 SYS_FILTERRULE 规则过滤。
+ * 构造调用上下文,优先级:
+ *
+ * - 显式 asUser 查询参(C2 对拍测试通道,CI 依赖)→ 非 ADMIN 视角,触发行级过滤。
+ * - JWT 已绑定的引擎上下文:{@code JwtAuthFilter} 已把 JWT claims 写入
+ * 请求级 {@code UserSession}(CURRENTUSER=真实 userId + ROLES)。无 asUser 时
+ * 直接复用该绑定上下文,使JWT roles 替代 asUser/roles 参数驱动行级过滤。
+ * - 都没有(无令牌、无 asUser)→ ADMIN 视角,不过滤(与原默认行为一致)。
+ *
*/
private Properties buildCtx(String asUser, String roles) {
- if (asUser == null || asUser.isBlank()) {
- return UserSession.getAdmin();
- }
- Properties ctx = new Properties();
- ctx.setProperty(LoggedInUser.CURRENTUSER, asUser);
- List roleList = new ArrayList<>();
- if (roles != null && !roles.isBlank()) {
- for (String r : roles.split(",")) {
- if (!r.isBlank()) {
- roleList.add(r.trim());
+ // 1) 显式 asUser 测试通道优先(保持 C2 既有行为不变)
+ if (asUser != null && !asUser.isBlank()) {
+ Properties ctx = new Properties();
+ ctx.setProperty(LoggedInUser.CURRENTUSER, asUser);
+ List roleList = new ArrayList<>();
+ if (roles != null && !roles.isBlank()) {
+ for (String r : roles.split(",")) {
+ if (!r.isBlank()) {
+ roleList.add(r.trim());
+ }
}
}
+ ctx.put(LoggedInUser.ROLES, roleList);
+ return ctx;
}
- ctx.put(LoggedInUser.ROLES, roleList);
- return ctx;
+ // 2) JWT 过滤器已绑定的请求级上下文(非 ADMIN 真实用户)→ 复用,驱动行级过滤
+ Properties bound = UserSession.get();
+ if (bound != null) {
+ String cu = bound.getProperty(LoggedInUser.CURRENTUSER);
+ if (cu != null && !cu.isBlank() && !LoggedInUser.ADMIN.trim().equals(cu.trim())) {
+ return bound;
+ }
+ }
+ // 3) 默认 ADMIN 视角(无令牌、无 asUser)
+ return UserSession.getAdmin();
}
/** GeneralPOJO 值存于内部数组(非 bean getter),手工展开为平面 map 供 JSON 序列化。 */
diff --git a/platform-parity/src/main/resources/bootstrap/bootstrap-auth.sql b/platform-parity/src/main/resources/bootstrap/bootstrap-auth.sql
new file mode 100644
index 0000000..a8ea9d1
--- /dev/null
+++ b/platform-parity/src/main/resources/bootstrap/bootstrap-auth.sql
@@ -0,0 +1,90 @@
+-- ===========================================================================
+-- bootstrap-auth.sql —— P2 认证自举(SYS_USER + 用户组/角色链 + CREATEBY 重分区)
+-- 幂等,可重复执行;在 bootstrap-sys.sql + bootstrap-privilege.sql 之后追加。
+--
+-- 目的:为 platform-auth 的「登录 → 签发 JWT → JWT roles 驱动行级过滤」端到端实测
+-- 准备本地最小数据:
+-- 1) SYS_USER 物理表(列对齐 framework SYS_USER_SEARCH 读路径所需:ACCOUNT/PASSWORD/
+-- NAME/MASTERDEPART/USERORGID/SYS_USER_ID)。
+-- 2) 1 个测试用户 alice:SYS_USER_ID='USER_ALICE'(=引擎 CURRENTUSER,使
+-- CREATEBY={CURRENTUSERID} 过滤命中 alice 的行),口令明文 123456
+-- → MD5(小写十六进制)=e10adc3949ba59abbe56e057f20f883e(与 EncryptUtil 一致)。
+-- 3) 用户组/角色链(sys_usergroupuser ⋈ sys_usergrouprole),复刻
+-- RoleServiceImpl#findRolesByUserId 读路径;alice → ROLE_CUSTOMER/ROLE_PROJECT/ROLE_TASK
+-- (与 bootstrap-privilege.sql 的受控实体角色一致,JWT roles 即可替代 asUser/roles)。
+-- 4) 受控实体 CREATEBY 重分区(与 privilege 脚本同口径),使过滤可判别。
+-- 注意:本脚本仅用于本地/对拍自举;不进生产数据。
+-- ===========================================================================
+
+-- 1. SYS_USER 物理表(仅认证读路径所需列,char(36) 主键与 framework 一致)
+CREATE TABLE IF NOT EXISTS sys_user (
+ sys_user_id character(36) NOT NULL,
+ account varchar(100),
+ password varchar(100),
+ name varchar(100),
+ masterdepart character(36),
+ userorgid character(36),
+ isactive integer DEFAULT 1,
+ createby character(36),
+ updateby character(36),
+ createtime bigint DEFAULT 0,
+ updatetime bigint DEFAULT 0,
+ version integer DEFAULT 0,
+ PRIMARY KEY (sys_user_id)
+);
+
+-- 2. 测试用户 alice(幂等 upsert):口令 123456 的 MD5
+INSERT INTO sys_user
+ (sys_user_id, account, password, name, masterdepart, userorgid, isactive, createby, updateby)
+VALUES
+ ('USER_ALICE', 'alice', 'e10adc3949ba59abbe56e057f20f883e', '爱丽丝',
+ 'DEPT_A', 'ORG_1', 1, 'ADMIN', 'ADMIN')
+ON CONFLICT (sys_user_id) DO UPDATE SET
+ account = EXCLUDED.account, password = EXCLUDED.password,
+ name = EXCLUDED.name, masterdepart = EXCLUDED.masterdepart,
+ userorgid = EXCLUDED.userorgid, isactive = 1;
+
+-- 3. 用户组/角色链(复刻 RoleServiceImpl 读路径:user→group→role)
+CREATE TABLE IF NOT EXISTS sys_usergroupuser (
+ usergroupid character(36),
+ userid character(36)
+);
+CREATE TABLE IF NOT EXISTS sys_usergrouprole (
+ usergroupid character(36),
+ roleid character(36)
+);
+
+-- 幂等:先清本测试组的链,再插
+DELETE FROM sys_usergroupuser WHERE usergroupid = 'UG_TEST';
+DELETE FROM sys_usergrouprole WHERE usergroupid = 'UG_TEST';
+
+-- alice 属于测试用户组 UG_TEST
+INSERT INTO sys_usergroupuser (usergroupid, userid) VALUES ('UG_TEST', 'USER_ALICE');
+
+-- UG_TEST 关联 3 个受控实体角色(与 bootstrap-privilege.sql 一致)
+INSERT INTO sys_usergrouprole (usergroupid, roleid) VALUES
+ ('UG_TEST', 'ROLE_CUSTOMER'),
+ ('UG_TEST', 'ROLE_PROJECT'),
+ ('UG_TEST', 'ROLE_TASK');
+
+-- 4. 受控实体 CREATEBY 重分区(与 bootstrap-privilege.sql §4 同口径,确定性幂等)
+WITH ranked AS (
+ SELECT eip4pt_task_id, row_number() OVER (ORDER BY eip4pt_task_id) AS rn FROM eip4pt_task
+)
+UPDATE eip4pt_task t SET createby = CASE (r.rn % 3)
+ WHEN 0 THEN 'USER_ALICE' WHEN 1 THEN 'USER_BOB' ELSE 'USER_CAROL' END
+FROM ranked r WHERE t.eip4pt_task_id = r.eip4pt_task_id;
+
+WITH ranked AS (
+ SELECT eip4pt_project_id, row_number() OVER (ORDER BY eip4pt_project_id) AS rn FROM eip4pt_project
+)
+UPDATE eip4pt_project t SET createby = CASE (r.rn % 3)
+ WHEN 0 THEN 'USER_ALICE' WHEN 1 THEN 'USER_BOB' ELSE 'USER_CAROL' END
+FROM ranked r WHERE t.eip4pt_project_id = r.eip4pt_project_id;
+
+WITH ranked AS (
+ SELECT eip4pt_customer_id, row_number() OVER (ORDER BY eip4pt_customer_id) AS rn FROM eip4pt_customer
+)
+UPDATE eip4pt_customer t SET createby = CASE (r.rn % 3)
+ WHEN 0 THEN 'USER_ALICE' WHEN 1 THEN 'USER_BOB' ELSE 'USER_CAROL' END
+FROM ranked r WHERE t.eip4pt_customer_id = r.eip4pt_customer_id;
diff --git a/pom.xml b/pom.xml
index 9ecbf1c..fb58682 100644
--- a/pom.xml
+++ b/pom.xml
@@ -34,6 +34,7 @@
17
17
1.3.0
+ 0.12.6