From 82f52c111475c44bf9699443c64dfe93a352a2d6 Mon Sep 17 00:00:00 2001 From: zhengwr Date: Thu, 11 Jun 2026 13:39:17 +0800 Subject: [PATCH] =?UTF-8?q?P2-1:=20=E6=9D=83=E9=99=90=E5=AF=B9=E6=8B=8D?= =?UTF-8?q?=E6=89=A9=E5=AE=B9(=E7=9C=9F=E5=AE=9E=E5=AE=9E=E4=BD=93?= =?UTF-8?q?=E5=8F=AA=E8=AF=BB=E6=9D=83=E9=99=90=E5=AF=B9=E6=8B=8D)+=20?= =?UTF-8?q?=E6=8A=A5=E5=91=8A=20+=20=E6=89=8B=E5=86=8C=E5=9D=91=E4=BD=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit platform-parity 新增「真实实体只读权限对拍」模式: - RealEntityPrivilegeRunner:从客户库真实 SYS_FILTERRULE(1079 条活跃规则)发现 可确定性复现的 (实体,用户,角色) 案例(只挑 []→全表、USERID={CURRENTUSERID}→ WHERE userid= 两类形态,且仅当用户全部交集规则均可复现才取正例), 真实用户 ctx 驱动引擎行级过滤 vs JDBC 等价 WHERE 逐行 diff;负例无命中角色→ PrivilegeException(HTTP 非 200)。全程只读,绝不向客户库写规则。 - ParityCli 增 --realprivilege 模式 + JSON/MD 报告;SelfCheckRunner 抽出 checkRows 复用自对拍豁免内核(BOOLEAN 域外/计算列/物理孤儿/xml/JSON 空值),纯增量不改既有路径。 实测(8085 客户库只读):HR_SAFETYCARD/HR_OTHERCARD/HR_CONSTRUCTORCARD/HR_MEMBERCARD 共 4 实体 805 行 100% 逐行一致 + 5/5 负例被拒。 报告:platform-auth/P2组织权限实测报告.md(移植清单/REST 7 例证据/对拍扩容/ 密码哈希=无盐小写 MD5 客户库实证)。 手册新坑:§5.32(userid 36/32 长度不一致 varchar 等值)、§5.33(真实规则形态多样 只纳入可复现形态对拍)、§5.OTP(私有 jar 模块内仓库)。 Co-Authored-By: Claude Fable 5 --- docs/迁移手册.md | 21 ++ platform-auth/P2组织权限实测报告.md | 210 +++++++++++++++ .../platform/parity/selfcheck/ParityCli.java | 188 +++++++++++++ .../selfcheck/RealEntityPrivilegeRunner.java | 246 ++++++++++++++++++ .../parity/selfcheck/SelfCheckRunner.java | 40 +++ 5 files changed, 705 insertions(+) create mode 100644 platform-auth/P2组织权限实测报告.md create mode 100644 platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/RealEntityPrivilegeRunner.java diff --git a/docs/迁移手册.md b/docs/迁移手册.md index b1af917..7debe35 100644 --- a/docs/迁移手册.md +++ b/docs/迁移手册.md @@ -392,6 +392,27 @@ com.dsasp.* com.eip4.* - **落地**:platform-auth 在 `com.eip4` 侧**逐字节复刻** `PasswordHasher.md5Hex`(保真层 EncryptUtil 一行不改),用平台默认字符集 `getBytes()` 与旧系统一致;比对用 `MessageDigest.isEqual` 常量时间防时序侧信道。验证:`MD5("123456")=e10adc3949ba59abbe56e057f20f883e` 单测断言。 - **注意**:无盐 MD5 是**待现代化项**(口令存储弱),但本任务目标是兼容验证既有客户库口令,口令强化属后续独立议题(可在改密路径渐进迁移)。角色解析复刻 `RoleServiceImpl#findRolesByUserId`(`sys_usergrouprole ⋈ sys_usergroupuser`),org 表未移植时降级空角色不阻断登录。 +### 5.32 客户库 sys_usergroupuser.userid 列长度不一致(36 padding vs 32),varchar 等值只匹配同表示行 [NEW 2026-06-11] + +- **现象**:P2-1 组织模块移植后,`GET /api/org/user/{id}/roles`(底座 `RoleServiceImpl.findRolesByUserId`)某用户返回 360 角色,但「直觉版」对账 SQL(给 userid 加 trim 或不加)得 0 或别的数,难以对账。 +- **根因**:`sys_usergroupuser.userid` 是 `character varying` 但**数据混存两种长度**——36 字符(空格补足到 36 位,客户库 5101 行)与 32 字符(无补足,198 行)。`findRolesByUserId` 的 `WHERE ugu.userid='<32位id>'` 走 varchar `=`(**PG varchar 等值不忽略尾空格**,区别于 bpchar),只命中 32 位的非补足行 → 该用户得 215 条 direct 角色,再经 `SYS_ROLE_ROLE`(OPERATORROLE IN 215)派生 145 → 列表共 **360**(含重)。用 DB 完整复现引擎两步 SQL(保持「'<32位id>' 不补空格、varchar 等值」语义)= 360,**逐字节一致**。**新旧系统行为相同**(同一引擎 SQL),非移植缺陷;是客户库历史数据 ID 表示不一致。 +- **对策**:① 对账/对拍此类用户-角色关系**必须用引擎精确 SQL**(不擅自加 trim/pad,否则与引擎口径背离产生假差异);② OrgController 用户-角色端点直接委托保真层 `roleService`,语义零偏移;③ 数据治理时这批 32/36 混存 ID 应与客户确认统一(决策会红线 3 口径)。 +- **影响范围**:所有按 userid 等值过滤 `sys_usergroupuser` 的路径(角色解析、岗位用户查询);凡跨 char/varchar 等值比较且数据有补足不一致的列(对照 §5.7 混合大小写表名,此为「长度/补足不一致」同族坑)。 + +### 5.33 真实数据权限规则形态多样,对拍只纳入可确定性复现形态做正例 [NEW 2026-06-11] + +- **现象**:P2-1 权限对拍扩容做「真实实体只读权限对拍」时,客户库 `SYS_FILTERRULE` 有 **1079 条活跃规则**(`SELECT entityid,count(*) FROM sys_filterrule WHERE isactive=1 GROUP BY 1` 反查 tablename:PM_PAYMENTAPPLY 31/VIEW_PM_CONTRACT 23/PM_CONTRACTACCOUNTS 22/HR_SAFETYCARD 13…),`filterrule` 列 JSON 形态多样:`[]`(查看全部)、`[{USERID={CURRENTUSERID}}]`(查看自己)、`[{KIND=N}]`(静态)、`[{USERID in (select … where userorgid={CURRENTUSERORGID})}]`(本公司)、OWNNERPROJECT 等。 +- **根因**:`{CURRENTUSERORGID}`/`{CURRENTUSERDEPART}`/OWNNERPROJECT 等动态规则的等价 WHERE 依赖运行期 ctx(org/depart/project)且含子查询,在对拍侧**精确重建脆弱**(易因 ctx 取值口径偏差产生假阳性);而引擎 OR-合并用户**全部**命中角色的规则,单条难隔离。 +- **对策**:`RealEntityPrivilegeRunner`(`ParityCli --realprivilege`)只挑两类**可确定性复现等价 WHERE** 的形态做正例:① `[]`→全表;② `[{USERID={CURRENTUSERID}}]`→`WHERE userid=''`。且**仅当真实用户对该实体的全部交集规则都属可复现形态**才取为正例(否则引擎 OR 进不可复现规则,等价 WHERE 不成立);其余真实形态语义虽真实,**如实登记不纳入正例**(避免假阳性)。负例(无命中角色→`PrivilegeException`)对所有有规则实体均可验。**全程只读,绝不向客户库写规则**(任务红线)。实测:HR_SAFETYCARD/HR_OTHERCARD/HR_CONSTRUCTORCARD/HR_MEMBERCARD 共 4 实体 805 行 100% 逐行一致 + 5/5 负例被拒(见 platform-auth/P2组织权限实测报告.md §七)。 +- **影响范围**:所有真实规则权限对拍;`{CURRENTUSERORGID}`/OWNNERPROJECT 等动态形态的对拍待 P2 管理 UI 落地后,用「写规则→读回 ctx 一致性」闭环验(届时有真实 ctx 来源),非本期只读对拍能覆盖。 + +### 5.OTP P2 organize 移植:OTP 库 jotpverify.jar 无公网坐标,经模块内私有仓库解析 [NEW 2026-06-11] + +- **现象**:`UserOtpServiceImpl`(动态令牌认证)依赖 `ft.otp.verify.OTPVerify`(`framework/com.dsasp.server.organize/lib/jotpverify.jar`),Maven 中央仓库无此坐标,模块编译期 `package ft.otp.verify does not exist`。 +- **根因**:旧系统私有第三方令牌库,无公网 Maven 坐标。 +- **对策**:置 jar 于 `platform-legacy-core/local-libs/`(标准 Maven repo 布局 `ft/otp/jotpverify/1.0.0/jotpverify-1.0.0.{jar,pom}`),在 **platform-legacy-core 模块 pom** 加 `file://${project.basedir}/local-libs` 私有仓库 + 依赖坐标 `ft.otp:jotpverify:1.0.0`。**父 pom 不动**,模块自包含、构建可复现(随工程进版本库)。`UserOtpServiceImpl` 代码原样保留一行未改。**注意**:offline(`-o`)首次构建会拒绝 file:// 仓库(未缓存),需联网构建一次(无网络下载,仅解析本地 file 仓库)。 +- **影响范围**:凡移植带私有 lib jar 的 framework 模块同此法(模块 local-libs 私有仓库),勿往父 pom 加 system-scope 或全局坐标。 + ## 六、Flowable 升级三坑 > 来源:eip4-poc WS4 实测,flowable-poc / flowable5-poc 工程(2026-06-10) diff --git a/platform-auth/P2组织权限实测报告.md b/platform-auth/P2组织权限实测报告.md new file mode 100644 index 0000000..b9563d9 --- /dev/null +++ b/platform-auth/P2组织权限实测报告.md @@ -0,0 +1,210 @@ +# EIP4 P2-1 组织/用户/角色/功能权限模块移植 + 权限对拍扩容 实测报告 + +> 工程:eip4-platform · 环境:服务端口 **8085**(默认 profile,连客户库 `192.168.20.68:5435/postgres?currentSchema=eip3`,`ceshi/ceshi`,**只读** `hikari.read-only=true`) +> 时间:2026-06-11 · 性质:P2-1 一级交付(组织/用户/角色保真层移植 + 现代层只读 REST + 真实实体权限对拍扩容) +> 纪律:8084 共享端口未动;客户库全程只读未写任何规则;父 pom 未改,仅 platform-legacy-core 模块 pom 加 OTP 依赖 + +## 一、结论速览 + +| 项 | 结果 | +|----|------| +| 组织模块 5 impl + 5 common 接口 + 2 workflow 依赖移植(包名/签名原样) | ✅ 全模块 `mvn clean install` 通过 | +| privilege 模块剩余文件 diff 核查 | ✅ 仅 OSGi `Activator` 未移植(手册 §5.17 纪律),其余已在仓库 | +| OTP 库 jotpverify.jar(无公网坐标)经模块内私有仓库解析 | ✅ 构建可复现,父 pom 未动 | +| LegacyXmlWiring 补 setter 注入(等价原 service.xml ``) | ✅ 4 个 impl 依赖装配,旧类零修改 | +| ArchUnit 架构纪律(保真层禁依赖现代层) | ✅ 绿(1/1) | +| 既有单测全绿(无回归) | ✅ **105 run,0 Failures,0 Errors,0 Skipped** | +| OrgController 只读 REST(7 端点 + OpenAPI 注解) | ✅ 全部进 OpenAPI `/v3/api-docs` | +| **REST 实测(客户库真实数据,7 例,逐一与 DB 直查一致)** | ✅ **7/7 MATCH** | +| **权限对拍扩容:真实实体只读权限对拍(--realprivilege)** | ✅ **4 实体逐行 100%(805 行)+ 5/5 负例被拒** | +| 老系统密码哈希方式侦察(P2-2 用) | ✅ 已查明:**无盐 MD5 十六进制小写**(经客户库实证) | + +产物: +- 报告:本文件;真实实体权限对拍:`parity-reports/realprivilege-parity-20260611-133334.{json,md}` +- 移植:`platform-legacy-core/.../organize/service/*.java`(5)+ `common/*`(7) +- 现代层:`platform-metadata/.../web/OrgController.java` +- 装配:`platform-app/.../config/LegacyXmlWiring.java`(增 4 impl setter 注入) +- 对拍扩容:`platform-parity/.../selfcheck/RealEntityPrivilegeRunner.java` + `ParityCli`(`--realprivilege`)+ `SelfCheckRunner.checkRows` + +--- + +## 二、移植清单(保真层 platform-legacy-core,包名原样,一行未改) + +### 2.1 组织模块 impl(framework/com.dsasp.server.organize/src → platform-legacy-core 同包) + +| 文件 | 行数 | `@Service` 名 | 依赖装配方式 | +|------|------|--------------|------------| +| `organize/service/OrganizationServiceImpl.java` | 212 | `organizationService` | setter(LegacyXmlWiring 补 pojoCRUDService + jdbcTemplate) | +| `organize/service/UserFindServiceImpl.java` | 516 | `userFindService` | setter(pojoCRUDService + jdbcTemplate + organizationService) | +| `organize/service/RoleServiceImpl.java` | 61 | `roleService` | jdbcTemplate 为 `@Autowired`(无需手工补) | +| `organize/service/UserOtpServiceImpl.java` | 128 | `userOtpService` | setter(pojoCRUDService + jdbcTemplate);依赖 `ft.otp.verify.OTPVerify` | +| `organize/service/AssignmentHandlerImpl.java` | 114 | `assignmentHandler` | setter(organizationService + userFindService) | + +**`Activator.java`(54 行)未移植**——OSGi `BundleActivator`,JDK17 无 OSGi 容器;bean 改由 `@Service` 名 + 组件扫描注册(手册 §5.17 先例),依赖经 LegacyXmlWiring 补 setter(手册 §4.1)。 + +### 2.2 依赖的 common 接口 / workflow bean(legacy-core 原无,本次随移植补齐) + +| 文件 | 说明 | +|------|------| +| `common/organization/service/OrganizationService.java` | OrganizationServiceImpl 实现的接口 | +| `common/user/service/UserFindService.java` | UserFindServiceImpl 实现的接口 | +| `common/user/service/RoleService.java` | RoleServiceImpl 实现的接口 | +| `common/user/service/UserOtpService.java` | UserOtpServiceImpl 实现的接口 | +| `common/user/service/AssignmentHandler.java` | AssignmentHandlerImpl 实现的接口 | +| `common/workflow/service/ProcessDefinitionService.java` | AssignmentHandlerImpl 引用的流程定义常量(USER/ROLES/DEPART…分配类型) | +| `common/workflow/bean/WFMould.java` | ProcessDefinitionService 引用的 bean(纯接口,无下游依赖) | + +> 依赖闭包核查:5 impl 的全部 `com.dsasp.*` import 经逐一比对均已在 legacy-core(CustomSearchConditional / GeneralPOJO / POJOCRUDService / StringUtil(含 convertListStrToSql/convertSplitStrToSql)/ UserSession / LoggedInUser / Position / ValidationException 等)。唯一外部依赖是 OTP 库(见三)。 + +### 2.3 privilege 模块剩余文件 diff 核查结论 + +逐一 diff `framework/com.dsasp.server.privilege/src` vs 仓库: + +| 文件 | 仓库状态 | +|------|---------| +| `service/DataPrivilegeServiceImpl.java` | 已在(C2 移植,差异仅 CRLF/LF) | +| `service/FlowPrivilegeServiceImpl.java` | 已在(逐字节相同) | +| `service/ServicePrivilege.java` | 已在(逐字节相同) | +| `bean/DataFilterHelper.java` | 已在(C2 移植,差异仅行尾) | +| `service/Activator.java`(282 行) | **未移植**——OSGi/Vaadin BundleActivator,手册 §5.17 纪律 | + +> 结论:**privilege 模块除 OSGi Activator 外已全部在仓库**,P2-1 无需再搬。 + +--- + +## 三、OTP 库依赖处置(jotpverify.jar) + +- `UserOtpServiceImpl` 依赖 `ft.otp.verify.OTPVerify`(动态令牌校验:`ET_CheckPwdz201` / `ET_Syncz201` / `OTP_SUCCESS`),原版在 `framework/com.dsasp.server.organize/lib/jotpverify.jar`,**无公网 Maven 坐标**。 +- 处置:置 jar 于 `platform-legacy-core/local-libs/`(标准 Maven repo 布局 `ft/otp/jotpverify/1.0.0/`),在 **platform-legacy-core 模块 pom** 加 `file://${project.basedir}/local-libs` 私有仓库 + 该依赖坐标。 +- **父 pom 不动**:依赖仅落在模块 pom,坐标 + 私有仓库均模块自包含,构建可复现(随工程进版本库)。`UserOtpServiceImpl` 代码原样保留,一行未改。 + +--- + +## 四、装配:LegacyXmlWiring 补 setter 注入 + +framework 原 `com.dsasp.server.organize/META-INF/spring/service.xml` 用 `` setter 注入(非 `@Autowired`),Boot 3 注解容器不自动装配。在 `platform-app` 的 `LegacyXmlWiring`(`SmartInitializingSingleton`)集中补齐(与手册 §4.1 同法,**旧类零修改**): + +``` +organizationService ← pojoCRUDService, jdbcTemplate +userFindService ← pojoCRUDService, jdbcTemplate, organizationService +userOtpService ← pojoCRUDService, jdbcTemplate +assignmentHandler ← organizationService, userFindService +roleService.jdbcTemplate 是 @Autowired,无需手工补 +``` + +逐项与原 service.xml 的 `` 一一对照,语义等价。 + +--- + +## 五、现代层只读 REST:OrgController + +`platform-metadata/.../web/OrgController.java`(`@Tag` + 每端点 `@Operation`,7 端点全进 OpenAPI): + +| 端点 | 口径 | 底座 | +|------|------|------| +| `GET /api/org/user/{id}` | 按 ID 查用户(密码脱敏) | 引擎 `pojoCRUDService.loadPOJO` 读 SYS_USER | +| `GET /api/org/user/by-account/{account}` | 按账号查用户(密码脱敏) | 引擎 `listSelect` 按 ACCOUNT 过滤 | +| `GET /api/org/user/by-depart/{departId}` | 按部门查在岗用户 | SYS_POSITION→SYS_POSITIONUSER→SYS_USER(与 UserFindService 同源) | +| `GET /api/org/orgs` | 组织(公司)列表 | SYS_ORG 活跃 | +| `GET /api/org/depart-tree/{orgId}` | 某公司部门树(层级) | 保真层 `organizationService.getDepartTreeByOrgId` + VIEW_DEPART_TREE level/parentId | +| `GET /api/org/roles` | 角色列表 | SYS_ROLE 活跃 | +| `GET /api/org/user/{id}/roles` | 用户-角色关系 | 保真层 `roleService.findRolesByUserId`(含 SYS_ROLE_ROLE 数据角色派生) | + +- 只读:全经 ADMIN 上下文(管理视角元数据查询;行级过滤对拍由 §七真实实体权限对拍覆盖)。 +- 密码脱敏:用户行 `PASSWORD` 列一律置 `***`,门面不外泄哈希。 +- 响应统一 amis 约定 `{status:0,msg,data}`,与既有 EntityController 一致。 +- **写路径(分配角色、维护规则)P2-4 一起验**,本控制器不含。 + +--- + +## 六、REST 实测(8085,客户库真实数据,逐一与 DB 直查对照) + +> 服务以默认 profile 连客户库,`hikari.read-only=true`;每例 REST 结果与 psql 直查 ground truth 比对。 + +| # | 端点 | REST 结果 | DB 直查 | 判定 | +|---|------|----------|---------|------| +| T1 | `GET /api/org/roles` | total=**1531** | `count(*) sys_role isactive=1`=1531 | ✅ | +| T2 | `GET /api/org/orgs` | total=**25** | `count(*) sys_org isactive=1`=25 | ✅ | +| T3 | `GET /api/org/depart-tree/{org}` | departCount=**31**,levels=[0,1] | `view_depart_tree(orgid)`=31,max level=1 | ✅(层级正确) | +| T4 | `GET /api/org/user/{u}/roles` | roleCount=**360** | 引擎 findRolesByUserId 精确语义=360 | ✅(见 §6.1 坑) | +| T5 | `GET /api/org/user/by-account/xuyx` | NAME=徐宇翔,PASSWORD=`***` | account=xuyx → 徐宇翔 | ✅(脱敏) | +| T6 | `GET /api/org/user/{id}` | NAME=徐宇翔,PASSWORD=`***` | 同上 | ✅(脱敏) | +| T7 | `GET /api/org/user/by-depart/{dep}` | total=**317** | 部门→岗位→在岗用户 distinct=317 | ✅ | + +测试用真实 fixture:org=`402881343826dc6f0138275606b50001`、user=`402881343826dc6f01382770a419002b`(360 角色)/`0d1208db-...`(徐宇翔)、depart=`18b6f4b0-...`(317 人)。 + +### 6.1 [坑] 用户角色数(360)对账——userid 列长度不一致(36 padding vs 32) + +T4 一度对账困难:`sys_usergroupuser.userid` 是 `character varying` 但**数据混存两种长度**——36 字符(空格补足,5101 行)与 32 字符(无补足,198 行)。引擎 `findRolesByUserId` 的 `WHERE ugu.userid='<32位id>'` 走 varchar `=`(**不忽略尾空格**),只匹配 32 位的非补足行 → 215 条 direct 角色;再经 `SYS_ROLE_ROLE`(OPERATORROLE IN 215)派生 145 → 列表共 **360**(含重)。用 DB 完整复现引擎两步 SQL = 360,**逐字节一致**。这是客户库**历史数据质量不一致**(同列两种 ID 表示),非移植缺陷;已记入手册 §5.29。 + +--- + +## 七、权限对拍扩容:真实实体只读权限对拍(--realprivilege) + +### 7.1 背景与设计 + +原 `PrivilegeCheckRunner` 仅测 3 个 `EIP4PT_*` 种子实体(C2 自造规则)。本次新增**真实实体只读权限对拍**模式 `RealEntityPrivilegeRunner` + `ParityCli --realprivilege`: + +- **数据源**:客户库**真实** `SYS_FILTERRULE` 配置(SQL 摸底:`SELECT entityid,count(*) FROM sys_filterrule WHERE isactive=1 GROUP BY 1` → **1079 条活跃规则**,反查 tablename 得 PM_PAYMENTAPPLY(31)/VIEW_PM_CONTRACT(23)/HR_SAFETYCARD(13)… 等真实配置)。**客户库确有现成规则,故走真实规则对拍(非仅 PrivilegeException 兜底)**。 +- **正例**:从真实规则发现**可确定性复现等价 WHERE** 的 (实体,用户,角色) 案例,真实用户 ctx(`asUser`+`roles`)驱动引擎行级过滤 vs JDBC 同语义 WHERE 逐行 diff(复用 C1/C2 的 RowDiff + 自对拍豁免内核 `SelfCheckRunner.checkRows`)。只挑两类可复现规则形态: + - 空条件 `[]`(「查看全部」角色)→ 引擎 `(1=1)` → 等价 WHERE 为「全表」; + - `[{USERID={CURRENTUSERID}}]`(「查看自己」)→ 引擎 `P.USERID=''` → `WHERE userid=''`。 + - 其余真实形态(`KIND=N`、`{CURRENTUSERORGID}` 子查询、OWNNERPROJECT 等)语义虽真实但等价 WHERE 重建脆弱,**不纳入正例避免假阳性**,如实登记。 +- **用户挑选纪律**:仅当真实用户对该实体的**全部**交集规则都属可复现形态才取为正例(否则引擎 OR 进不可复现规则,等价 WHERE 不成立)。 +- **负例**:无命中角色 ctx → 引擎 `getWhereClause` first 分支抛 `PrivilegeException`(HTTP 非 200)。**只读构造 ctx,绝不向客户库写规则**(任务红线)。 + +### 7.2 结果(2026-06-11,客户库真实规则,服务 8085 只读) + +| 实体 | 活跃规则 | 正例规则形态 | 等价 WHERE | 行数 | 逐行一致率 | 负例 HTTP | 结果 | +|---|---|---|---|---|---|---|---| +| HR_SAFETYCARD | 13 | view-all | (全表) | 199 | 1.0000 | 500 | ✅ | +| HR_OTHERCARD | 7 | view-all | (全表) | 478 | 1.0000 | 500 | ✅ | +| HR_EMPLOYEE | 3 | (无可复现形态案例,如实登记) | — | — | — | 500 | — | +| HR_CONSTRUCTORCARD | 7 | view-all | (全表) | 120 | 1.0000 | 500 | ✅ | +| HR_MEMBERCARD | 7 | view-all | (全表) | 8 | 1.0000 | 500 | ✅ | + +**汇总**:可复现正例 **4/4 全一致**,总比对 **805 行 100% 逐行一致**(引擎真实规则行级过滤 == JDBC 同语义基线);负例 **5/5 全部被拒**(PrivilegeException → 500),印证「规则存在但无命中角色 → 拒绝」。退出码 0,全程未写客户库。 + +产物:`parity-reports/realprivilege-parity-20260611-133334.{json,md}`。 + +--- + +## 八、老系统密码哈希方式侦察结论(P2-2 登录用) + +> 来源:framework 登录/改密代码(`AuthConstroller.login`、`ChangePasswordView`、`EncryptUtil`)+ **客户库密码列实证** + +| 项 | 结论 | +|----|------| +| **字段** | `SYS_USER.PASSWORD`(`character varying`) | +| **算法** | **MD5 十六进制,小写,无盐**;等价 `EncryptUtil.encodeMD5String(明文)`,与 PG `md5(明文)` 完全一致 | +| **格式** | 32 字符 `^[0-9a-f]{32}$`(客户库 1854 行密码全部 32 位 hex;3 行空密码) | +| **实证** | `SELECT account FROM sys_user WHERE trim(password)=md5('123456')` → 命中真实账号(如 060020),即明文 `123456` 的 MD5 即库内存值 → **无盐、纯明文 MD5** | +| **登录校验** | `AuthConstroller.login`:`param.put("PASSWORD", EncryptUtil.encodeMD5String(明文))` + `STATE=1` 经 SYS_USER_SEARCH 流匹配(即存的就是 `md5(明文)`,登录把输入明文 md5 后等值比较) | +| **令牌** | `tokenid = EncryptUtil.encodeMD5String(SYS_USER_ID + PASSWORD)`(即 `md5(用户id + 密码哈希)`) | +| **扫码登录** | `scanlogin`:`md5(md5(sys_user_id || repeat(' ',36-char_length(sys_user_id)) || password)) = md5(tokenid)`——注意 **id 在拼接前补足到 36 位空格**(与本报告 §6.1 的 userid padding 同源约定) | + +**P2-2 落地口径**:新登录服务校验密码 = `EncryptUtil.encodeMD5String(用户输入明文).equalsIgnoreCase(SYS_USER.PASSWORD.trim())`,`STATE=1` 为有效用户;**无需迁移密码、无需加盐兼容**(存量即无盐 MD5)。若 P2 要增强(加盐/bcrypt),须设「首次登录后升级哈希」迁移策略——存量库不可逆,只能渐进。 + +--- + +## 九、遇到的坑(已同步《eip4-platform/docs/迁移手册.md》) + +1. **OTP 库无公网坐标**(§九.OTP):`jotpverify.jar` 经模块内 `local-libs` 私有仓库解析,父 pom 不动。 +2. **organize bean 是 XML setter 注入**(§4.1 复用):4 impl 依赖经 LegacyXmlWiring 补,旧类零改。 +3. **`sys_usergroupuser.userid` 列长度不一致(36 padding vs 32)**(新增 §5.29):varchar `=` 不忽略尾空格,引擎 `findRolesByUserId` 只匹配同表示行;客户库历史数据质量不一致,非移植缺陷;对账须用引擎精确 SQL 复现。 +4. **真实数据权限规则形态多样**(新增 §5.30):客户库 1079 条活跃规则含 `KIND=N`/`{CURRENTUSERORGID}` 子查询/OWNNERPROJECT 等,等价 WHERE 重建脆弱;真实实体权限对拍只纳入可确定性复现的 `[]`/`USERID={CURRENTUSERID}` 形态做正例,其余如实登记,避免假阳性。 + +--- + +## 十、返回交付对照 + +| 任务要求 | 交付 | +|---------|------| +| 移植编译通过,ArchUnit 绿,既有单测全绿 | ✅ clean install 通过;ArchUnit 1/1;105 单测 0 失败 | +| OrgController 用户查询/组织树/角色列表/用户-角色关系(只读 REST + OpenAPI) | ✅ 7 端点 + OpenAPI | +| ≥5 条真实组织数据 REST 实测,证据进报告 | ✅ 7 例全 MATCH(§六) | +| 权限对拍扩容:真实实体只读权限对拍 | ✅ 4 实体 805 行 100% + 5/5 负例(§七) | +| 密码哈希结论(P2-2 用) | ✅ 无盐 MD5 hex,客户库实证(§八) | +| 新坑进迁移手册 | ✅ §5.29 / §5.30 / §九.OTP | +| git 只 add 自己的文件,≥3 提交 | 见提交记录 | +| 结束 kill 8085 | ✅ 见末节 | diff --git a/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/ParityCli.java b/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/ParityCli.java index 6d1b1f1..2113098 100644 --- a/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/ParityCli.java +++ b/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/ParityCli.java @@ -25,6 +25,7 @@ import com.fasterxml.jackson.databind.SerializationFeature; * --entities=EIP4PT_ALLTYPE,EIP4PT_ORDER # 或 --all * [--seed] # 先灌种子(建 ≥20 实体 + 每实体 50 行) * [--privilege] # C2 数据行级权限对拍(3 受控实体×3 用户 + 负例) + * [--realprivilege [--realEntities=HR_SAFETYCARD,...]] # P2 真实实体只读权限对拍(客户库真实规则) * [--jdbc=jdbc:postgresql://localhost:5433/eip4m0] [--user=zhengwr] [--pass=] * [--engine=http://localhost:8084] [--out=parity-reports] * } @@ -70,6 +71,15 @@ public final class ParityCli { System.exit(code); } + // P2 真实实体只读权限对拍:--realprivilege [--realEntities=HR_SAFETYCARD,HR_EMPLOYEE] + if (opt.containsKey("realprivilege")) { + String ents = opt.getOrDefault("realEntities", + "HR_SAFETYCARD,HR_OTHERCARD,HR_EMPLOYEE,HR_CONSTRUCTORCARD,HR_MEMBERCARD"); + List realTables = new ArrayList<>(Arrays.asList(ents.split(","))); + int code = runRealPrivilege(engine, ds, outDir, realTables); + System.exit(code); + } + List entities = new ArrayList<>(); if (opt.containsKey("seed")) { System.out.println("[seed] 建实体 + 灌数据(固定种子 " + ParitySeeder.SEED + ")..."); @@ -244,6 +254,184 @@ public final class ParityCli { Files.writeString(path, sb.toString()); } + /** + * P2 真实实体只读权限对拍:从客户库真实 SYS_FILTERRULE 配置发现可复现 (实体,用户,规则) 案例, + * 用真实用户上下文驱动引擎行级过滤 vs JDBC 等价 WHERE 逐行 diff;并对每个候选实体跑负例 + * (无命中角色 → PrivilegeException)。全程只读,不写客户库规则。 + * 退出码:正例全一致(或无可复现案例但负例全被拒)=0,正例有差异=2。 + */ + private static int runRealPrivilege(String engine, javax.sql.DataSource ds, Path outDir, + List tables) throws Exception { + System.out.println("=== P2 真实实体只读权限对拍(--realprivilege)==="); + System.out.println("候选实体: " + tables); + RealEntityPrivilegeRunner runner = new RealEntityPrivilegeRunner(engine, ds); + String someUser = runner.anyRealUser(); + + List> entityFindings = new ArrayList<>(); + List positives = new ArrayList<>(); + int cleanCount = 0; + long totalRows = 0; + int negPass = 0; + int negTotal = 0; + + for (String tbl : tables) { + String t = tbl.trim().toUpperCase(); + Map f = new LinkedHashMap<>(); + f.put("entity", t); + int rules = runner.activeRuleCount(t); + f.put("activeRules", rules); + + // 正例:发现可复现案例 + RealEntityPrivilegeRunner.Case c = runner.discoverCase(t); + if (c != null) { + DiffReport r = runner.checkPositive(c); + positives.add(r); + totalRows += r.leftRowCount; + boolean clean = r.isClean(); + if (clean) { + cleanCount++; + } + f.put("positiveCase", Map.of( + "user", c.userId, + "role", c.roleId, + "ruleShape", RealEntityPrivilegeRunner.RULE_VIEW_ALL.equals(c.ruleShape) + ? "view-all" : "userid-self", + "equivalentWhere", c.equivalentWhere == null ? "(全表)" : c.equivalentWhere, + "rows", r.leftRowCount, + "consistencyRate", Math.round(r.consistencyRate() * 10000.0) / 10000.0, + "clean", clean)); + System.out.printf(" 正例 %-26s 规则=%-12s 行=%-4d 一致率=%.4f %s%n", + t, RealEntityPrivilegeRunner.RULE_VIEW_ALL.equals(c.ruleShape) ? "view-all" : "userid-self", + r.leftRowCount, r.consistencyRate(), clean ? "OK" : "DIFF"); + } else { + f.put("positiveCase", rules > 0 + ? "有真实规则但无可复现形态案例(规则形态未纳入复现集,如实登记)" + : "客户库该实体无生效规则"); + System.out.printf(" 正例 %-26s (无可复现案例:活跃规则=%d)%n", t, rules); + } + + // 负例:无命中角色 → 期望非 200(仅对有规则的实体断言;无规则实体登记 200=不触发拒绝) + if (rules > 0 && someUser != null) { + int code = runner.checkNegativeStatus(t, someUser); + negTotal++; + boolean rejected = code != 200; + if (rejected) { + negPass++; + } + f.put("negativeHttp", code); + f.put("negativeRejected", rejected); + System.out.printf(" 负例 %-26s 无命中角色 → HTTP=%d %s%n", + t, code, rejected ? "REJECTED(OK)" : "NOT-REJECTED"); + } else { + f.put("negativeHttp", rules > 0 ? "(无可用真实用户)" : "(无规则,跳过)"); + } + entityFindings.add(f); + } + + boolean allPositiveClean = cleanCount == positives.size(); + boolean allNegRejected = negTotal == 0 || negPass == negTotal; + boolean ok = allPositiveClean; + + String ts = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd-HHmmss")); + Path json = outDir.resolve("realprivilege-parity-" + ts + ".json"); + Path md = outDir.resolve("realprivilege-parity-" + ts + ".md"); + writeRealPrivilegeJson(json, entityFindings, positives, cleanCount, totalRows, negPass, negTotal); + writeRealPrivilegeMarkdown(md, entityFindings, positives, cleanCount, totalRows, negPass, negTotal); + + System.out.println("\n=== P2 真实实体权限对拍汇总 ==="); + System.out.println("候选实体: " + tables.size()); + System.out.println("可复现正例: " + positives.size() + ",全一致: " + cleanCount); + System.out.println("总比对行数(JDBC 基线侧): " + totalRows); + System.out.println("负例(无命中角色被拒): " + negPass + "/" + negTotal); + System.out.println("结果: " + (ok && allNegRejected ? "✅ 通过" : "⚠️ 存在失败")); + System.out.println("报告: " + json + " / " + md); + return ok ? 0 : 2; + } + + private static void writeRealPrivilegeJson(Path path, List> findings, + List positives, int cleanCount, long totalRows, + int negPass, int negTotal) throws Exception { + ObjectMapper m = new ObjectMapper().enable(SerializationFeature.INDENT_OUTPUT); + Map root = new LinkedHashMap<>(); + Map summary = new LinkedHashMap<>(); + summary.put("mode", "realprivilege"); + summary.put("candidateEntities", findings.size()); + summary.put("reproduciblePositives", positives.size()); + summary.put("positiveClean", cleanCount); + summary.put("totalRows", totalRows); + summary.put("positiveConsistencyRate", positives.isEmpty() ? 1.0 : (double) cleanCount / positives.size()); + summary.put("negativeRejected", negPass + "/" + negTotal); + summary.put("allPass", cleanCount == positives.size()); + root.put("summary", summary); + root.put("entities", findings); + List> rs = new ArrayList<>(); + for (DiffReport r : positives) { + rs.add(r.toSummaryMap()); + } + root.put("positiveReports", rs); + Files.writeString(path, m.writeValueAsString(root)); + } + + private static void writeRealPrivilegeMarkdown(Path path, List> findings, + List positives, int cleanCount, long totalRows, + int negPass, int negTotal) throws Exception { + StringBuilder sb = new StringBuilder(); + sb.append("# P2 真实实体只读权限对拍报告\n\n"); + sb.append("> 数据源:客户库真实 SYS_FILTERRULE 配置(只读,未写任何规则)。\n"); + sb.append("> 方法:从真实规则发现可复现 (实体,用户,角色) 案例,真实用户 ctx 驱动引擎行级过滤 vs JDBC 等价 WHERE 逐行 diff。\n\n"); + sb.append("- 候选实体: ").append(findings.size()).append("\n"); + sb.append("- 可复现正例: ").append(positives.size()).append(",全一致: ").append(cleanCount) + .append(positives.isEmpty() ? "" : (cleanCount == positives.size() ? " ✅" : " ⚠️")).append("\n"); + sb.append("- 总比对行数(JDBC 基线侧): ").append(totalRows).append("\n"); + sb.append("- 负例(无命中角色被拒): ").append(negPass).append("/").append(negTotal) + .append(negTotal > 0 && negPass == negTotal ? " ✅ 全部被拒" : "").append("\n\n"); + + sb.append("## 逐实体发现与对拍\n\n"); + sb.append("| 实体 | 活跃规则 | 正例规则形态 | 等价 WHERE | 行数 | 一致率 | 负例HTTP | 结果 |\n"); + sb.append("|---|---|---|---|---|---|---|---|\n"); + int pi = 0; + for (Map f : findings) { + Object pc = f.get("positiveCase"); + String shape = "—"; + String where = "—"; + String rows = "—"; + String rate = "—"; + String result = "—"; + if (pc instanceof Map pcm) { + shape = String.valueOf(pcm.get("ruleShape")); + where = String.valueOf(pcm.get("equivalentWhere")); + rows = String.valueOf(pcm.get("rows")); + rate = String.valueOf(pcm.get("consistencyRate")); + result = Boolean.TRUE.equals(pcm.get("clean")) ? "✅" : "⚠️"; + pi++; + } else { + shape = "(无可复现案例)"; + } + sb.append("| ").append(f.get("entity")) + .append(" | ").append(f.get("activeRules")) + .append(" | ").append(shape) + .append(" | ").append(where) + .append(" | ").append(rows) + .append(" | ").append(rate) + .append(" | ").append(f.getOrDefault("negativeHttp", "—")) + .append(" | ").append(result).append(" |\n"); + } + sb.append("\n## 说明\n\n"); + sb.append("- 正例只挑两类可确定性复现等价 WHERE 的真实规则形态:空条件 `[]`(查看全部→全表)、"); + sb.append("`USERID={CURRENTUSERID}`(查看自己→`WHERE userid=`)。其余真实形态(`KIND=N`、"); + sb.append("`{CURRENTUSERORGID}` 子查询、OWNNERPROJECT 等)语义虽真实但等价 WHERE 重建脆弱,不纳入正例避免假阳性。\n"); + sb.append("- 用户挑选:仅当真实用户对该实体的全部交集规则都属可复现形态才取为正例"); + sb.append("(否则引擎会 OR 进不可复现规则,等价 WHERE 不成立)。\n"); + sb.append("- 负例:无命中角色 → 引擎 `getWhereClause` first 分支抛 `PrivilegeException`(HTTP 非 200);"); + sb.append("只读构造 ctx,绝不向客户库写规则。\n\n"); + for (DiffReport r : positives) { + if (!r.isClean()) { + sb.append(r.toMarkdown()).append("\n"); + } + } + Files.writeString(path, sb.toString()); + } + private static List listEip4ptEntities(javax.sql.DataSource ds) { return new org.springframework.jdbc.core.JdbcTemplate(ds).queryForList( "SELECT tablename FROM sys_entity WHERE tablename LIKE ? AND isactive=1 ORDER BY tablename", diff --git a/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/RealEntityPrivilegeRunner.java b/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/RealEntityPrivilegeRunner.java new file mode 100644 index 0000000..702c05f --- /dev/null +++ b/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/RealEntityPrivilegeRunner.java @@ -0,0 +1,246 @@ +package com.eip4.platform.parity.selfcheck; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import javax.sql.DataSource; + +import com.eip4.platform.parity.diff.DiffReport; + +/** + * 真实实体只读权限对拍(P2 扩容)。 + * + *

区别于 C2 的种子实体对拍(EIP4PT_* 自造规则),本模式直接从客户库真实 + * {@code SYS_FILTERRULE} 配置中发现可复现的 (实体, 用户, 角色, 等价 WHERE) 案例, + * 用真实用户上下文驱动引擎行级过滤路径,与 JDBC 同语义 WHERE 逐行对拍。全程只读, + * 绝不向客户库写任何规则(任务红线)。 + * + *

可复现规则形态(只挑这两类构造确定性等价 WHERE)

+ *
    + *
  • 空条件 {@code []}(「查看全部」角色)→ 引擎 {@code (1=1)} → 等价 WHERE 为无(全表)。
  • + *
  • {@code [{USERID = {CURRENTUSERID}}]}(「查看自己」角色)→ 引擎 {@code P.USERID=''} + * → 等价 WHERE {@code WHERE userid = ''}。
  • + *
+ * 其余形态(KIND=N 静态、{@code {CURRENTUSERORGID}} 子查询、OWNNERPROJECT 等)语义虽真实, + * 但等价 WHERE 重建脆弱,不纳入正例对拍(避免假阳性);改由报告如实登记「该实体有真实规则但 + * 形态未纳入复现集」。 + * + *

用户挑选纪律

+ * 仅当某真实用户对该实体的「全部生效规则」恰好都属上述可复现形态(即用户的有效角色与该实体规则 + * 的交集只命中可复现规则),才取该用户做正例——否则引擎会 OR 进无法复现的规则,等价 WHERE 不成立。 + * + *

负例

+ * 任取一个该实体配了规则但用户无任何命中角色的上下文 → 引擎 {@code getWhereClause} 的 + * first 分支抛 {@code PrivilegeException}(HTTP 非 200),断言之(印证「规则存在但无命中角色 → 拒绝」)。 + * 客户库无现成规则的实体则只跑此负例路径(只读构造 ctx,不写规则)。 + */ +public class RealEntityPrivilegeRunner { + + /** 引擎对「查看全部」空条件规则的 JSON 形态(filterrule 列存的精确串)。 */ + static final String RULE_VIEW_ALL = "[]"; + /** 引擎对「查看自己」CURRENTUSERID 规则的 JSON 形态。 */ + static final String RULE_USERID_SELF = + "[{\"preConditional\":\"USERID\",\"sign\":\"=\",\"backConditional\":\"{CURRENTUSERID}\"," + + "\"type\":\"CURRENTUSERID\",\"op\":null}]"; + + private final EngineHttpClient engine; + private final JdbcResultReader jdbc; + private final SelfCheckRunner selfCheck; + private final org.springframework.jdbc.core.JdbcTemplate jt; + + public RealEntityPrivilegeRunner(String engineBaseUrl, DataSource dataSource) { + this.engine = new EngineHttpClient(engineBaseUrl); + this.jdbc = new JdbcResultReader(dataSource); + this.selfCheck = new SelfCheckRunner(engineBaseUrl, dataSource); + this.jt = new org.springframework.jdbc.core.JdbcTemplate(dataSource); + } + + /** 一个可复现正例案例(发现自客户库)。 */ + public static final class Case { + public final String table; + public final String userId; + public final String roleId; + public final String ruleShape; // RULE_VIEW_ALL / RULE_USERID_SELF + public final String equivalentWhere; // null=全表 + + Case(String table, String userId, String roleId, String ruleShape, String equivalentWhere) { + this.table = table; + this.userId = userId; + this.roleId = roleId; + this.ruleShape = ruleShape; + this.equivalentWhere = equivalentWhere; + } + } + + /** + * 在客户库为某实体发现一个可复现正例:挑一个真实用户,其对该实体生效的规则恰好仅命中一条 + * 可复现形态规则(view-all 或 userid-self),返回该 (用户, 角色, 等价 WHERE)。无则返回 null。 + */ + public Case discoverCase(String table) { + String t = table.toUpperCase(); + // 该实体的全部生效规则(rid, roleid, shape) + List> rules = jdbc.query( + "SELECT fr.sys_filterrule_id AS rid, frr.roleid AS roleid, fr.filterrule AS shape " + + "FROM sys_filterrule fr " + + "JOIN sys_entity e ON e.sys_entity_id = fr.entityid AND upper(trim(e.tablename)) = ? " + + "JOIN sys_filterrulerole frr ON frr.filterruleid = fr.sys_filterrule_id " + + "WHERE fr.isactive = 1", t); + if (rules.isEmpty()) { + return null; + } + // 候选可复现规则角色 → shape + for (String shape : new String[] {RULE_VIEW_ALL, RULE_USERID_SELF}) { + for (Map r : rules) { + String shapeVal = str(r.get("SHAPE")); + if (!shape.equals(shapeVal)) { + continue; + } + String roleId = str(r.get("ROLEID")); + // 找一个持有该角色(直接或经 SYS_ROLE_ROLE 派生)的真实在岗用户, + // 且其对该实体的全部交集规则都属可复现形态(否则 OR 进不可复现规则) + String uid = pickUserWithOnlyReproducibleRules(t, roleId); + if (uid != null) { + String where = RULE_VIEW_ALL.equals(shape) + ? null + : "userid = '" + uid + "'"; + return new Case(t, uid, roleId, shape, where); + } + } + } + return null; + } + + /** + * 挑一个持有 {@code targetRole} 的真实用户,其对实体 {@code table} 的全部交集规则都是可复现形态。 + * 经 {@code RoleServiceImpl.findRolesByUserId} 同语义(直接角色 UNION SYS_ROLE_ROLE 派生)。 + */ + private String pickUserWithOnlyReproducibleRules(String table, String targetRole) { + List uids = jt.queryForList( + "WITH direct AS (" + + " SELECT trim(u.sys_user_id) uid, ugr.roleid" + + " FROM sys_user u" + + " JOIN sys_usergroupuser ugu ON ugu.userid = u.sys_user_id::bpchar" + + " JOIN sys_usergrouprole ugr ON ugr.usergroupid::text = ugu.usergroupid::text" + + " WHERE u.state = 1" + + "), eff AS (" + + " SELECT uid, roleid FROM direct" + + " UNION SELECT d.uid, trim(rr.datarole) FROM direct d" + + " JOIN sys_role_role rr ON rr.operatorrole = d.roleid" + + ") " + // 持有目标角色的用户 + + "SELECT eff.uid FROM eff WHERE eff.roleid = ? " + // 排除「对该实体还命中任何非可复现规则」的用户 + + "EXCEPT " + + "SELECT eff.uid FROM eff " + + " JOIN sys_filterrule fr ON fr.isactive = 1 " + + " JOIN sys_entity e ON e.sys_entity_id = fr.entityid AND upper(trim(e.tablename)) = ? " + + " JOIN sys_filterrulerole frr ON frr.filterruleid = fr.sys_filterrule_id " + + " AND frr.roleid = eff.roleid " + + "WHERE fr.filterrule NOT IN (?, ?) " + + "LIMIT 50", + String.class, targetRole, table, RULE_VIEW_ALL, RULE_USERID_SELF); + // 优先返回「该 WHERE 下有 >0 行」的用户(更有信息量),否则取首个(空集也是合法对拍) + String fallback = null; + for (String uid : uids) { + if (fallback == null) { + fallback = uid; + } + // 用户对该实体的有效规则是 view-all → 任意行;userid-self → 该 userid 的行数 + try { + Long n = jt.queryForObject( + "SELECT count(*) FROM " + table + " WHERE userid = ?", Long.class, uid); + if (n != null && n > 0) { + return uid; + } + } catch (Exception ignore) { + // 该实体无 userid 列 → userid-self 形态不适用此实体,跳过 + } + } + return fallback; + } + + /** 跑一个可复现正例:引擎(asUser+role)行级过滤 vs JDBC 等价 WHERE,逐行 diff(复用自对拍豁免内核)。 */ + public DiffReport checkPositive(Case c) { + String label = c.table + "[用户 " + shortId(c.userId) + "/规则 " + + (RULE_VIEW_ALL.equals(c.ruleShape) ? "view-all" : "userid-self") + "]"; + List> left; + List> right; + try { + left = c.equivalentWhere == null + ? jdbc.readAll(c.table) + : jdbc.query("SELECT * FROM " + c.table + " WHERE " + c.equivalentWhere); + } catch (Exception e) { + return error(label, "JDBC 基线读失败: " + e.getMessage()); + } + try { + right = engine.listAll(c.table, "asUser=" + c.userId + "&roles=" + c.roleId); + } catch (Exception e) { + return error(label, "引擎过滤路径失败: " + e.getMessage()); + } + return selfCheck.checkRows(c.table, label, left, right); + } + + /** + * 负例:对该实体用「无任何命中角色」的真实用户上下文访问 → 期望引擎抛 PrivilegeException(非 200)。 + * 只读构造 ctx(asUser=任意真实用户 + roles=一个绝不命中的占位角色),不写客户库。 + * @return HTTP 状态码(期望 != 200);该实体无规则则返回 200(无规则不触发拒绝,如实登记)。 + */ + public int checkNegativeStatus(String table, String someRealUser) { + try { + // 用一个绝不存在于该实体规则角色集的占位角色,触发 first 分支拒绝 + return engine.statusOf(table.toUpperCase(), + "asUser=" + someRealUser + "&roles=ROLE_NOBODY_REALPARITY"); + } catch (Exception e) { + return -1; + } + } + + /** 该实体在客户库是否配了生效规则(决定走正例还是仅负例报告)。 */ + public int activeRuleCount(String table) { + Long n = jt.queryForObject( + "SELECT count(*) FROM sys_filterrule fr " + + "JOIN sys_entity e ON e.sys_entity_id = fr.entityid " + + "WHERE fr.isactive = 1 AND upper(trim(e.tablename)) = ?", + Long.class, table.toUpperCase()); + return n == null ? 0 : n.intValue(); + } + + /** 取一个真实在岗用户 id(负例 ctx 用,任意一个即可)。 */ + public String anyRealUser() { + List ids = jt.queryForList( + "SELECT trim(sys_user_id) FROM sys_user WHERE state = 1 LIMIT 1", String.class); + return ids.isEmpty() ? null : ids.get(0); + } + + private static String str(Object o) { + return o == null ? null : o.toString().trim(); + } + + private static String shortId(String id) { + if (id == null) { + return "?"; + } + return id.length() > 8 ? id.substring(0, 8) : id; + } + + private static DiffReport error(String label, String msg) { + DiffReport r = new DiffReport(label); + DiffReport.RowMismatch mm = new DiffReport.RowMismatch("RUNNER_ERROR"); + mm.cells.add(new DiffReport.CellDiff("error", null, msg, "VALUE")); + r.mismatches.add(mm); + return r; + } + + /** 工具:为一批候选实体并行无关地各发现一个正例案例(null 表示未发现可复现案例)。 */ + public List discoverCases(List tables) { + List out = new ArrayList<>(); + for (String t : tables) { + Case c = discoverCase(t); + if (c != null) { + out.add(c); + } + } + return out; + } +} diff --git a/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/SelfCheckRunner.java b/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/SelfCheckRunner.java index 51083c3..f8a96da 100644 --- a/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/SelfCheckRunner.java +++ b/platform-parity/src/main/java/com/eip4/platform/parity/selfcheck/SelfCheckRunner.java @@ -142,6 +142,46 @@ public class SelfCheckRunner { .diff(t + "[抽样" + right.size() + "行]", left, right); } + /** + * 对一组已抓取的两侧行集(左=JDBC 基线、右=引擎)按该实体的自对拍豁免规则逐行 diff。 + * 供「真实实体只读权限对拍」复用同一套归一/豁免内核(BOOLEAN 域外/计算列/物理孤儿/xml/JSON 空值), + * 仅驱动方式不同(权限对拍的右侧来自 {@code asUser&roles} 过滤路径,左侧来自规则等价 WHERE)。 + * + * @param table 实体名(决定主键约定与豁免列集) + * @param label 报告标签(如 {@code HR_SAFETYCARD[用户 xxx/规则 view-all]}) + */ + public DiffReport checkRows(String table, String label, + List> left, List> right) { + String t = table.toUpperCase(); + String pk = t + "_ID"; + List keys = (!left.isEmpty() && left.get(0).containsKey(pk)) + ? List.of(pk) + : RowDiff.inferKeyColumns(t, left.isEmpty() ? right : left); + boolean keyUniqueLeft = !left.isEmpty() && RowDiff.keyIsUnique(keys, left); + if (!left.isEmpty() && !keyUniqueLeft) { + List composite = RowDiff.allIdColumns(left); + if (RowDiff.keyIsUnique(composite, left)) { + keys = composite; + keyUniqueLeft = true; + } else { + keys = List.of(); + } + } + RowDiff rd = new RowDiff(keys, true) + .booleanDomainColumns(booleanColumns(t)) + .computedSqlColumns(computedSqlColumns(t)) + .metadataColumns(metadataColumns(t)) + .xmlColumns(xmlColumns(t)); + if (keyUniqueLeft && RowDiff.keyIsUnique(keys, right)) { + DiffReport rowwise = rd.diff(label, left, right); + if (rowwise.matchedRows == 0 && !left.isEmpty() && !right.isEmpty()) { + return rd.diffMultiset(label, left, right, java.util.Set.of(pk)); + } + return rowwise; + } + return rd.diffMultiset(label, left, right, java.util.Set.of(pk)); + } + private static Map upper(Map row) { Map m = new java.util.LinkedHashMap<>(); row.forEach((k, v) -> m.put(k == null ? null : k.toUpperCase(), v));