From c09dab33f793663411255e26e6e8769b6610a0f8 Mon Sep 17 00:00:00 2001 From: lxp <2770281812@qq.com> Date: Mon, 19 Oct 2026 17:21:23 +0800 Subject: [PATCH] =?UTF-8?q?=E7=99=BB=E5=BD=95=E9=89=B4=E6=9D=83?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.example | 5 +- README.md | 12 +- cadworld-adminapi/docs/admin-api.md | 21 +- cadworld-adminapi/docs/auth-api.md | 105 ++++++++ cadworld-adminapi/pom.xml | 5 + .../cadworld/AdminApiApplication.java | 3 +- .../audit/EarlyFailureAuditFilter.java | 4 +- .../config/AdminOpenApiConfiguration.java | 18 ++ .../controller/AdminAuthController.java | 81 ++++++ .../controller/ComponentAssetController.java | 2 +- .../controller/UserManagementController.java | 2 +- .../src/main/resources/application.yml | 6 +- .../com/linkerbot/cadworld/AdminApiTest.java | 54 +++- .../linkerbot/cadworld/AdminAuthApiTest.java | 246 +++++++++++++++++ .../cadworld/AdminAuthTestSupport.java | 22 ++ .../linkerbot/cadworld/TestSchemaSupport.java | 4 +- .../linkerbot/cadworld/UploadHttpTest.java | 9 + .../audit/OperationAuditInterceptorTest.java | 12 +- cadworld-api/docs/api.md | 2 +- cadworld-api/docs/auth-api.md | 147 +++++++++++ cadworld-api/docs/demand-integration.md | 6 +- cadworld-api/docs/demand-schema.md | 6 +- cadworld-api/docs/robot-demand-api.md | 17 +- cadworld-api/pom.xml | 10 + .../cadworld/api/ApiApplication.java | 6 +- .../api/config/DemandConfiguration.java | 2 +- .../api/controller/AuthController.java | 62 +++++ .../cadworld/api/controller/DemandOwner.java | 34 +-- .../api/controller/RobotDemandController.java | 31 +-- .../src/main/resources/application.yml | 3 + .../cadworld/api/ApiAuthTestSupport.java | 30 +++ .../linkerbot/cadworld/api/AuthApiTest.java | 247 ++++++++++++++++++ .../cadworld/api/DemandFlowApiTest.java | 124 ++++++--- .../cadworld/api/MatchingApiTest.java | 15 +- .../api/config/ApiCorsConfigurationTest.java | 2 +- .../cadworld/dto/auth/CaptchaResponse.java | 8 + .../cadworld/dto/auth/LoginRequest.java | 20 ++ .../cadworld/dto/auth/LoginResponse.java | 8 + .../cadworld/dto/auth/LoginUserResponse.java | 4 + .../cadworld/dto/user/SaveUserRequest.java | 8 +- .../cadworld/dto/user/UserResponse.java | 2 +- .../linkerbot/cadworld/entity/SysUser.java | 9 +- .../cadworld/common/util/EmailAddresses.java | 12 + .../cadworld-security-admin/pom.xml | 12 + .../admin/AdminBearerTokenFilter.java | 67 +++++ .../admin/AdminSecurityConfiguration.java | 80 ++++++ .../AuthenticatedAdminOperatorProvider.java | 13 + .../cadworld/security/admin/CurrentAdmin.java | 21 ++ .../cadworld-security-api/pom.xml | 12 + .../api/ApiSecurityConfiguration.java | 77 ++++++ .../security/api/BearerTokenFilter.java | 65 +++++ .../cadworld/security/api/CurrentUser.java | 20 ++ .../cadworld-security-common/pom.xml | 15 ++ .../security/common/AuthProperties.java | 19 ++ .../security/common/CaptchaService.java | 87 ++++++ .../security/common/TokenService.java | 36 +++ .../security/common/AuthPropertiesTest.java | 37 +++ .../cadworld/security/common/SessionTest.java | 104 ++++++++ .../config/AdminOperatorProperties.java | 12 - .../service/AdminOperatorProvider.java | 16 +- .../service/auth/AdminLoginService.java | 49 ++++ .../service/auth/LoginUserService.java | 77 ++++++ .../impl/UserManagementServiceImpl.java | 49 +++- .../cadworld/service/support/UserCodes.java | 13 + .../service/auth/LoginUserServiceTest.java | 82 ++++++ 65 files changed, 2203 insertions(+), 186 deletions(-) create mode 100644 cadworld-adminapi/docs/auth-api.md create mode 100644 cadworld-adminapi/src/main/java/com/linkerbot/cadworld/config/AdminOpenApiConfiguration.java create mode 100644 cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/AdminAuthController.java create mode 100644 cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminAuthApiTest.java create mode 100644 cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminAuthTestSupport.java create mode 100644 cadworld-api/docs/auth-api.md create mode 100644 cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/AuthController.java create mode 100644 cadworld-api/src/test/java/com/linkerbot/cadworld/api/ApiAuthTestSupport.java create mode 100644 cadworld-api/src/test/java/com/linkerbot/cadworld/api/AuthApiTest.java create mode 100644 cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/CaptchaResponse.java create mode 100644 cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/LoginRequest.java create mode 100644 cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/LoginResponse.java create mode 100644 cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/LoginUserResponse.java create mode 100644 cadworld-common/src/main/java/com/linkerbot/cadworld/common/util/EmailAddresses.java create mode 100644 cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/AdminBearerTokenFilter.java create mode 100644 cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/AdminSecurityConfiguration.java create mode 100644 cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/AuthenticatedAdminOperatorProvider.java create mode 100644 cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/CurrentAdmin.java create mode 100644 cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/ApiSecurityConfiguration.java create mode 100644 cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/BearerTokenFilter.java create mode 100644 cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/CurrentUser.java create mode 100644 cadworld-security/cadworld-security-common/src/main/java/com/linkerbot/cadworld/security/common/AuthProperties.java create mode 100644 cadworld-security/cadworld-security-common/src/main/java/com/linkerbot/cadworld/security/common/CaptchaService.java create mode 100644 cadworld-security/cadworld-security-common/src/main/java/com/linkerbot/cadworld/security/common/TokenService.java create mode 100644 cadworld-security/cadworld-security-common/src/test/java/com/linkerbot/cadworld/security/common/AuthPropertiesTest.java create mode 100644 cadworld-security/cadworld-security-common/src/test/java/com/linkerbot/cadworld/security/common/SessionTest.java delete mode 100644 cadworld-service/src/main/java/com/linkerbot/cadworld/config/AdminOperatorProperties.java create mode 100644 cadworld-service/src/main/java/com/linkerbot/cadworld/service/auth/AdminLoginService.java create mode 100644 cadworld-service/src/main/java/com/linkerbot/cadworld/service/auth/LoginUserService.java create mode 100644 cadworld-service/src/main/java/com/linkerbot/cadworld/service/support/UserCodes.java create mode 100644 cadworld-service/src/test/java/com/linkerbot/cadworld/service/auth/LoginUserServiceTest.java diff --git a/.env.example b/.env.example index 74b5e64..452d9de 100644 --- a/.env.example +++ b/.env.example @@ -15,8 +15,9 @@ OSS_BUCKET=linkerbot APP_STORAGE_PUBLIC_BASE_URL=http://127.0.0.1:8992/admin-api/component-assets # At least 32 UTF-8 bytes. Empty uses a random key and invalidates sessions on restart. APP_UPLOAD_SESSION_SECRET= -APP_ADMIN_OPERATOR_ID=0 -APP_ADMIN_OPERATOR_NAME=TEST_OPERATOR +# 管理端验证码与登录态有效期(单实例进程内缓存) +APP_ADMIN_AUTH_CAPTCHA_TTL=PT2M +APP_ADMIN_AUTH_TOKEN_TTL=PT24H LOG_PATH=logs # OSS 目录上传签名有效期(不超过会话剩余有效期) diff --git a/README.md b/README.md index 90d7be5..1db4d94 100644 --- a/README.md +++ b/README.md @@ -11,19 +11,19 @@ Java 21 / Spring Boot 3.4.4 / MyBatis-Plus 多模块项目。管理端提供组 | cadworld-bean | 实体、请求和响应 DTO、枚举 | | cadworld-common | 统一响应、异常、JSON 类型处理、请求编号和操作目标上下文 | | cadworld-api | 独立用户端 API:组件详情、匹配、需求会话、图文理解、自动选件与装配 | -| cadworld-security | 预留安全子模块 | +| cadworld-security | 用户端及管理端 Spring Security、独立登录态、共用图片验证码与 Token 基础实现 | -当前没有登录和权限接口。上传和审计使用配置操作人,默认 `0 / TEST_OPERATOR`,无需在 `sys_user` 中创建对应记录。上传会话令牌绑定操作人、组件、上传批次和资源目录。 +用户端支持[邮箱与图片验证码登录](cadworld-api/docs/auth-api.md),首次自动注册,所有业务接口需要 Bearer Token。管理端支持[管理员邮箱登录](cadworld-adminapi/docs/auth-api.md),仅允许已启用的 ADMIN 账号,全部后台业务接口要求管理端 Bearer Token。上传会话和审计使用实际登录管理员。两端 Token 和验证码不能互用。 ## 数据库 -管理端访问 `component`、`sys_user`、`sys_operation_log`。用户端组件匹配复用 `component`,需求解析流程另外使用五张独立表;新增表的中文注释建表语句见 [需求流程建表说明](cadworld-api/docs/demand-schema.md),需要部署时手动执行,应用不自动建表。组件旋转轴字段 `rotation_axis` 的迁移 SQL 见 [管理端字段部署说明](cadworld-adminapi/docs/admin-api.md#43-旋转轴字段部署),部署两端新代码前须执行。 +管理端访问 `component`、`sys_user`、`sys_operation_log`。用户端登录使用 `sys_user`,组件匹配复用 `component`,需求解析流程另外使用五张独立表;新增表的中文注释建表语句见 [需求流程建表说明](cadworld-api/docs/demand-schema.md),需要部署时手动执行,应用不自动建表。组件旋转轴字段 `rotation_axis` 的迁移 SQL 见 [管理端字段部署说明](cadworld-adminapi/docs/admin-api.md#43-旋转轴字段部署),部署两端新代码前须执行。 组件存储基本信息、自由度、旋转轴、功能、形状、大小描述、扭矩、BOM 清单、URDF 信息、两组自定义字段、STEP 对象键、URDF 目录及实际文件清单、`version`、`deleted` 删除标记和维护时间。旋转轴通过 `rotationAxis` 接收和返回,仅接受 `X`、`Y`、`Z`,未设置时为 null。BOM 和 URDF 信息均为 JSON 对象或数组,创建和修改必填 `urdfInfo`;可选 `bomList` 缺失或为 null 时写入 `[]`。列表返回旋转轴和描述字段,BOM 和 URDF 信息仅在详情及保存结果中返回。通用日志存储模块、动作、目标快照、操作人、请求元信息和结果,不依赖组件专属列。 -应用启动不建表、不迁移旧数据。本次未修改 `.sql` 文件;仓库中历史 SQL 不代表当前组件和日志结构,请使用已经建好的表。MySQL 需支持现有建表语句中的 JSON / TEXT 表达式默认值。 +用户登录改造发布前需手动执行[用户编码迁移 SQL](cadworld-api/docs/auth-api.md#4-发布前手动执行的迁移-sql)。应用启动不建表、不迁移旧数据。本次未修改 `.sql` 文件;仓库中历史 SQL 不代表当前组件和日志结构,请使用已经建好的表。MySQL 需支持现有建表语句中的 JSON / TEXT 表达式默认值。 -组件名称允许重复,编码唯一且不可修改。新增编码为 `CW-` 加 16 位随机数字或大写字母(排除 `I/L/O/U`),总长 19,例如 `CW-7K3M9Q2R6V8X4T5N`;使用 80 位密码学安全随机空间,数据库唯一索引约束重复。旧版 35 字符编码和已有上传会话继续兼容,无需修改表结构或迁移已有编码。组件和用户均逻辑删除;已删除组件的编码和已删除用户的手机号仍被占用。组件替换资源或逻辑删除均不自动删除 OSS 文件。 +组件名称允许重复,编码唯一且不可修改。新增编码为 `CW-` 加 16 位随机数字或大写字母(排除 `I/L/O/U`),总长 19,例如 `CW-7K3M9Q2R6V8X4T5N`;使用 80 位密码学安全随机空间,数据库唯一索引约束重复。旧版 35 字符编码和已有上传会话继续兼容,无需修改表结构或迁移已有编码。组件逻辑删除;用户删除入口改为禁用账号,可重新启用,邮箱仍被占用。已删除组件的编码仍被占用。组件替换资源或逻辑删除均不自动删除 OSS 文件。 现有 `component` 表包含 `deleted TINYINT UNSIGNED NOT NULL DEFAULT 0` 字段,中文注释为“删除标记:0-未删除,1-已删除”。运行代码通过 MyBatis-Plus 自动过滤已删除组件,列表、详情、修改和编辑上传签名均只处理未删除记录。 @@ -54,7 +54,7 @@ Spring Boot 不自动读取 `.env`,需要通过 shell 导入。默认 profile | OSS_UPLOAD_SESSION_TTL | 上传会话有效期,默认 `PT30M`;续签不延长会话 | | OSS_UPLOAD_SIGNATURE_TTL | OSS 签名有效期,默认 `PT5M`,不超过会话剩余时间 | | APP_UPLOAD_SESSION_SECRET | 至少 32 个 UTF-8 字节;留空使用进程随机密钥,重启后原会话失效;多实例需配置相同密钥 | -| APP_ADMIN_OPERATOR_ID / APP_ADMIN_OPERATOR_NAME | 当前配置操作人,默认 `0 / TEST_OPERATOR` | +| APP_ADMIN_AUTH_CAPTCHA_TTL / APP_ADMIN_AUTH_TOKEN_TTL | 管理端验证码与登录态有效期,默认 `PT2M / PT24H`;未设置时沿用通用 APP_AUTH_* 配置 | | LOG_PATH | 运行日志目录,默认 `logs` | 运行时使用已有 OSS 桶,不自动创建桶。前端通过 OSS V4 表单签名直接上传,后端通过 HEAD 检查文件,资源下载仍由后台代理。OSS 需配置前端站点的 CORS,允许表单 POST;上传字段原样使用,`file` 放在表单最后。凭证需有目标目录上传和读取权限。 diff --git a/cadworld-adminapi/docs/admin-api.md b/cadworld-adminapi/docs/admin-api.md index 90974bd..ac8811b 100644 --- a/cadworld-adminapi/docs/admin-api.md +++ b/cadworld-adminapi/docs/admin-api.md @@ -6,7 +6,7 @@ ## 1. 通用约定 -JSON 请求设置 `Content-Type: application/json`。当前没有登录认证,操作人来自 `APP_ADMIN_OPERATOR_ID / APP_ADMIN_OPERATOR_NAME`,默认 `0 / TEST_OPERATOR`。上传令牌与该操作人绑定。 +JSON 请求设置 `Content-Type: application/json`。先完成[管理员邮箱与图片验证码登录](auth-api.md),业务接口统一携带 `Authorization: Bearer `。仅允许已启用的 ADMIN 账号,不自动注册;上传会话及审计使用真实登录管理员。 `/admin-api/**` 跨域白名单按 profile 区分:`test` 允许 `https://dev-cadworld-admin.robotquan.com`,`prod` 允许 `https://cadworld-admin.robotquan.com`。可通过 `APP_ADMIN_ALLOWED_ORIGINS` 覆盖,多个完整 origin 用逗号分隔,禁止通配符;显式留空关闭跨域。允许 `GET / HEAD / POST / PUT / DELETE / OPTIONS`,请求头允许 `Content-Type / Authorization / X-Request-Id`,支持凭证,并向前端暴露 `X-Request-Id`;预检缓存 3600 秒。OSS 直传上传的 CORS 仍需在 OSS 单独配置。 @@ -30,6 +30,10 @@ JSON 请求设置 `Content-Type: application/json`。当前没有登录认证, | 方法 | 路径 | 作用 | | --- | --- | --- | +| GET | /admin-api/auth/captcha | 获取图片验证码,无需登录 | +| POST | /admin-api/auth/login | 管理员邮箱登录,无需登录 | +| POST | /admin-api/auth/logout | 退出当前管理端登录态 | +| GET | /admin-api/users/me | 当前管理员,不返回主键 | | POST | /admin-api/storage/upload-signature | 分配编码及上传授权,或续签 | | GET | /admin-api/components | 组件分页查询 | | POST | /admin-api/components | 新增组件,校验上传文件后入库 | @@ -41,7 +45,7 @@ JSON 请求设置 `Content-Type: application/json`。当前没有登录认证, | POST | /admin-api/users | 创建用户 | | GET | /admin-api/users/{id} | 用户详情 | | PUT | /admin-api/users/{id} | 修改用户 | -| DELETE | /admin-api/users/{id} | 逻辑删除用户 | +| DELETE | /admin-api/users/{id} | 禁用用户,可重新启用 | | GET | /admin-api/operation-logs | 通用操作日志分页查询 | | GET | /admin-api/operation-logs/{id} | 操作日志详情 | @@ -335,7 +339,7 @@ ALTER TABLE `component` 已删除组件不出现在列表和详情中,不能修改、申请编辑上传签名或续签绑定该组件的上传会话。组件编码仍保持唯一,不能复用原新增会话重新创建同编码组件。删除标记仅用于数据库内部,不增加到接口响应中。 -使用详情中的 `stepUrl`、`urdfUrl` 或依赖文件 URL 直接 GET 下载。下载成功返回原文件流,不包 JSON;对象不存在返回 404。对象键区分大小写且必须属于当前环境根目录。 +使用详情中的 `stepUrl`、`urdfUrl` 或依赖文件 URL 下载。若 URL 指向 `/admin-api/component-assets/**`,fetch 或模型加载器须携带管理端 Authorization 头,文件可转 Blob URL 展示或下载;Token 不放在 URL 中。若指向公开 OSS/CDN,则沿用公开资源加载方式。下载成功返回原文件流,不包 JSON;对象不存在返回 404。对象键区分大小写且必须属于当前环境根目录。 ## 6. 浏览器完整上传示例 @@ -349,10 +353,11 @@ ALTER TABLE `component` 以下示例使用一次签名完成两类文件上传,授权即将到期时调用同一接口续签,上传全部成功后直接保存。表单取当前页面值;示例按顺序上传以便展示流程,实际页面可使用受控并发。 ```javascript +// adminToken 为管理员登录返回的 Token,保存在应用登录状态中。 async function adminApi(path, method, body) { const response = await fetch(`/admin-api${path}`, { method, - headers: { 'Content-Type': 'application/json' }, + headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${adminToken}` }, ...(body === undefined ? {} : { body: JSON.stringify(body) }) }); const result = await response.json(); @@ -441,15 +446,17 @@ const saved = await uploadAndSave({ ## 7. 用户管理 -保持现有行为和表结构。列表支持 `page`、`size`、`keyword`(手机号或昵称)、`userType`(NORMAL / ADMIN)、`status`(ACTIVE / DISABLED)。详情返回 `id`、`phone`、`nickname`、`status`、`userType`、`createdAt`、`updatedAt`。 +用户字段以邮箱版 `sys_user` 为准,发布前执行[用户编码迁移 SQL](../../cadworld-api/docs/auth-api.md#4-发布前手动执行的迁移-sql)。列表支持 `page`、`size`、`keyword`(邮箱或昵称)、`userType`(NORMAL / ADMIN)、`status`(ACTIVE / DISABLED)。详情返回 `id`、`userCode`、`email`、`nickname`、`status`、`userType`、`createdAt`、`updatedAt`;后台路径仍使用 `/{id}`,用户端只返回业务编码。 POST / PUT 请求: ```json -{"phone":"13812345678","nickname":"测试用户","status":"ACTIVE","userType":"NORMAL"} +{"email":"user@example.com","nickname":"测试用户","status":"ACTIVE","userType":"NORMAL"} ``` -手机号需符合大陆手机号格式并保持唯一,昵称必填且最多 64 字符。创建省略状态和类型时默认为 ACTIVE / NORMAL;修改省略则保留原值。逻辑删除后列表及详情不再返回该用户,手机号仍被占用。用户管理只记录运行日志。 +邮箱去除首尾空格并转小写后校验,最多 254 字符且唯一,重复返回 `409 / USER_EMAIL_DUPLICATE`。昵称必填且最多 64 字符。创建自动生成不可变 `userCode`,省略状态和类型时默认为 ACTIVE / NORMAL;修改省略则保留原值。 + +`DELETE /admin-api/users/{id}` 将状态设为 DISABLED,不删除记录。禁用用户仍能在列表和详情中查询,邮箱继续占用,可通过 PUT 将状态恢复为 ACTIVE。禁用后用户端登录返回 403,已有登录态的后续请求返回 401。用户管理只记录运行日志。 ## 8. 通用操作日志 diff --git a/cadworld-adminapi/docs/auth-api.md b/cadworld-adminapi/docs/auth-api.md new file mode 100644 index 0000000..38da41c --- /dev/null +++ b/cadworld-adminapi/docs/auth-api.md @@ -0,0 +1,105 @@ +# 管理端邮箱与图片验证码登录 + +服务默认端口 `8992`。仅允许 `sys_user` 中 `status=ACTIVE`、`user_type=ADMIN` 的账号登录;未知邮箱和普通用户返回 `403 / ADMIN_ACCESS_DENIED`,不自动创建账号或提升权限。流程不发送邮件、不验证邮箱归属,与用户端采用相同的图片验证码交互。 + +## 1. 接口与调用 + +| 方法 | 路径 | 说明 | +| --- | --- | --- | +| GET | `/admin-api/auth/captcha` | 无需登录,获取一次性图片验证码 | +| POST | `/admin-api/auth/login` | 无需登录,邮箱与图片验证码登录 | +| POST | `/admin-api/auth/logout` | 撤销当前管理员 Token | +| GET | `/admin-api/users/me` | 获取当前管理员,不返回数据库主键 | + +除验证码、登录和 OPTIONS 预检外,所有 `/admin-api/**` 业务接口都要求 `Authorization: Bearer `,包含组件、用户、操作日志、上传签名和代理资源下载。Swagger 文档可直接打开,在 Authorize 中填入登录返回的 Token 后调试业务接口。 + +验证码响应 `data`: + +```json +{"captchaCode":"一次性编码","image":"data:image/png;base64,...","expiresIn":120} +``` + +图片为 180×60 PNG,答案 5 位,不区分大小写,忽略首尾空格。默认有效期 2 分钟,每次通过参数校验的登录提交都会消费验证码,答错后也需重新获取。 + +登录请求: + +```json +{"email":"admin@example.com","captchaCode":"验证码编码","captchaAnswer":"ABCDE"} +``` + +邮箱去除首尾空格并转小写后校验,最多 254 字符。成功响应沿用 `{code,message,data,requestId}`,`data` 如下: + +```json +{ + "token":"登录凭证", + "tokenType":"Bearer", + "expiresIn":86400, + "user":{"userCode":"0123456789ABCDEF0123456789ABCDEF","nickname":"管理员","email":"admin@example.com"} +} +``` + +`GET /admin-api/users/me` 返回同样的 `user` 字段内容。Token 默认有效期 24 小时,不滑动续期;同一管理员可同时保持多个登录态,退出仅撤销当前 Token。验证码和登录响应均设置 `Cache-Control: no-store`。 + +```javascript +const challenge = (await (await fetch('/admin-api/auth/captcha')).json()).data; +// challenge.image 用于展示图片;answer 为管理员输入的答案。 +const response = await fetch('/admin-api/auth/login', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ email, captchaCode: challenge.captchaCode, captchaAnswer: answer }) +}); +if (!response.ok) throw await response.json(); +const { token } = (await response.json()).data; + +const current = await fetch('/admin-api/users/me', { + headers: { Authorization: `Bearer ${token}` } +}); +``` + +不要将 Token 放在 URL 中。代理图片、模型或下载文件也需通过带认证头的 fetch 或加载器读取。公开 OSS/CDN 地址按资源服务原有方式访问,OSS 直传表单仍使用签名字段,不向 OSS 发送管理端 Token。 + +## 2. 权限、上传与审计 + +- 每次请求从数据库检查状态和角色。禁用或删除用户后已有 Token 返回 `401 / UNAUTHORIZED`;管理员降级为普通用户后返回 `403 / ADMIN_ACCESS_DENIED`。 +- 上传会话绑定当前登录管理员的内部用户主键;不同管理员不能续签或使用对方的上传会话。原配置操作人签发的上传会话需要重新申请。 +- 组件操作的审计操作人来自当前管理员的主键和昵称;认证失败只记录运行日志,不伪造业务操作人。multipart 等早期业务失败仍记录真实管理员。 +- 用户端和管理端共用验证码与 Token 基础代码,但拥有独立进程缓存和独立身份主体;两端 Token 和验证码不能互用。退出某一端不影响另一端。 + +| HTTP 状态 | code | 处理方式 | +| --- | --- | --- | +| 400 | `CAPTCHA_INVALID` | 验证码错误、过期或已消费,重新获取 | +| 401 | `UNAUTHORIZED` | 未登录、Token 无效或用户已不可用,重新登录 | +| 403 | `ADMIN_ACCESS_DENIED` | 账号没有管理员权限 | +| 403 | `ACCOUNT_DISABLED` | 管理员账号已禁用 | +| 422 | `INVALID_REQUEST` | 邮箱、必填字段或长度不合法 | +| 503 | `DATABASE_UNAVAILABLE` | 数据库暂不可用,稍后重试 | + +## 3. 配置和初始管理员 + +验证码和登录态分别使用最多 10000 条的进程内 Caffeine 缓存,按单实例部署;重启、容量淘汰或过期后凭证失效。缓存不影响数据库中的用户和业务数据。 + +| 配置 | 默认值与说明 | +| --- | --- | +| `APP_ADMIN_AUTH_CAPTCHA_TTL` | `PT2M`,至少 1 秒;未设置时沿用 `APP_AUTH_CAPTCHA_TTL` | +| `APP_ADMIN_AUTH_TOKEN_TTL` | `PT24H`,至少 1 秒;未设置时沿用 `APP_AUTH_TOKEN_TTL` | +| `APP_ADMIN_ALLOWED_ORIGINS` | 沿用管理端域名白名单,允许 Authorization 请求头;401/403 保留跨域响应头 | + +`APP_ADMIN_OPERATOR_ID / APP_ADMIN_OPERATOR_NAME` 已不再使用。此改造无需新增表字段,沿用上次邮箱用户及 `user_code` 迁移后的表结构。 + +首次管理员由数据库预先授权。选择以下一种方式手动执行,替换为实际邮箱或已有用户编码,应用不会自动执行,也未修改 `.sql` 文件。 + +新建管理员: + +```sql +INSERT INTO `sys_user` (`user_code`, `email`, `nickname`, `status`, `user_type`) +VALUES (UPPER(REPLACE(UUID(), '-', '')), LOWER(TRIM('your-admin@example.com')), + '管理员', 'ACTIVE', 'ADMIN'); +``` + +将已有用户授权为管理员: + +```sql +UPDATE `sys_user` +SET `user_type` = 'ADMIN', `status` = 'ACTIVE' +WHERE `user_code` = '替换为已有用户唯一编码'; +``` diff --git a/cadworld-adminapi/pom.xml b/cadworld-adminapi/pom.xml index a41613b..6447ba9 100644 --- a/cadworld-adminapi/pom.xml +++ b/cadworld-adminapi/pom.xml @@ -16,6 +16,11 @@ cadworld-adminapi + + com.linkerbot + cadworld-security-admin + ${project.version} + com.linkerbot cadworld-service diff --git a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/AdminApiApplication.java b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/AdminApiApplication.java index c7d3a8c..7545b53 100644 --- a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/AdminApiApplication.java +++ b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/AdminApiApplication.java @@ -3,9 +3,10 @@ package com.linkerbot.cadworld; import org.mybatis.spring.annotation.MapperScan; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration; import org.springframework.boot.context.properties.ConfigurationPropertiesScan; -@SpringBootApplication +@SpringBootApplication(exclude = UserDetailsServiceAutoConfiguration.class) @ConfigurationPropertiesScan("com.linkerbot.cadworld.config") @MapperScan("com.linkerbot.cadworld.mapper") public class AdminApiApplication { diff --git a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/audit/EarlyFailureAuditFilter.java b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/audit/EarlyFailureAuditFilter.java index fea2e5c..269b16c 100644 --- a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/audit/EarlyFailureAuditFilter.java +++ b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/audit/EarlyFailureAuditFilter.java @@ -9,7 +9,7 @@ import java.io.IOException; import java.util.Map; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Qualifier; -import org.springframework.core.Ordered; +import org.springframework.boot.autoconfigure.security.SecurityProperties; import org.springframework.core.annotation.Order; import org.springframework.stereotype.Component; import org.springframework.web.filter.OncePerRequestFilter; @@ -24,7 +24,7 @@ import org.springframework.web.util.pattern.PathPattern; /** Multipart size failures can occur before an MVC interceptor is invoked. */ @Slf4j @Component -@Order(Ordered.HIGHEST_PRECEDENCE + 1) +@Order(SecurityProperties.DEFAULT_FILTER_ORDER + 1) public class EarlyFailureAuditFilter extends OncePerRequestFilter { private final RequestMappingHandlerMapping mappings; private final OperationAuditInterceptor audit; diff --git a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/config/AdminOpenApiConfiguration.java b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/config/AdminOpenApiConfiguration.java new file mode 100644 index 0000000..9fd0d84 --- /dev/null +++ b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/config/AdminOpenApiConfiguration.java @@ -0,0 +1,18 @@ +package com.linkerbot.cadworld.config; + +import io.swagger.v3.oas.models.Components; +import io.swagger.v3.oas.models.OpenAPI; +import io.swagger.v3.oas.models.security.SecurityRequirement; +import io.swagger.v3.oas.models.security.SecurityScheme; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +@Configuration(proxyBeanMethods = false) +public class AdminOpenApiConfiguration { + @Bean + OpenAPI adminOpenApi() { + return new OpenAPI().components(new Components().addSecuritySchemes("adminBearer", + new SecurityScheme().type(SecurityScheme.Type.HTTP).scheme("bearer"))) + .addSecurityItem(new SecurityRequirement().addList("adminBearer")); + } +} diff --git a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/AdminAuthController.java b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/AdminAuthController.java new file mode 100644 index 0000000..5a6ee9e --- /dev/null +++ b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/AdminAuthController.java @@ -0,0 +1,81 @@ +package com.linkerbot.cadworld.controller; + +import com.linkerbot.cadworld.common.api.ApiResponse; +import com.linkerbot.cadworld.common.api.RequestIdHolder; +import com.linkerbot.cadworld.dto.auth.CaptchaResponse; +import com.linkerbot.cadworld.dto.auth.LoginRequest; +import com.linkerbot.cadworld.dto.auth.LoginResponse; +import com.linkerbot.cadworld.dto.auth.LoginUserResponse; +import com.linkerbot.cadworld.entity.SysUser; +import com.linkerbot.cadworld.logging.ApiRequestLog; +import com.linkerbot.cadworld.security.admin.CurrentAdmin; +import com.linkerbot.cadworld.security.common.AuthProperties; +import com.linkerbot.cadworld.security.common.CaptchaService; +import com.linkerbot.cadworld.security.common.TokenService; +import com.linkerbot.cadworld.service.auth.AdminLoginService; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.security.SecurityRequirements; +import io.swagger.v3.oas.annotations.tags.Tag; +import jakarta.servlet.http.HttpServletResponse; +import jakarta.validation.Valid; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.http.HttpHeaders; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestHeader; +import org.springframework.web.bind.annotation.RestController; + +@Slf4j +@RestController +@RequiredArgsConstructor +@Tag(name = "管理员登录") +public class AdminAuthController { + private final CaptchaService captcha; + private final TokenService tokens; + private final AdminLoginService users; + private final AuthProperties properties; + + @ApiRequestLog("获取管理员图片验证码") + @Operation(summary = "获取一次性图片验证码") + @SecurityRequirements + @GetMapping("/admin-api/auth/captcha") + public ApiResponse captcha(HttpServletResponse response) { + response.setHeader(HttpHeaders.CACHE_CONTROL, "no-store"); + return ApiResponse.success(captcha.issue()); + } + + @ApiRequestLog("管理员邮箱登录") + @Operation(summary = "邮箱与图片验证码登录,仅允许已启用的管理员") + @SecurityRequirements + @PostMapping("/admin-api/auth/login") + public ApiResponse login(@Valid @RequestBody LoginRequest input, HttpServletResponse response) { + response.setHeader(HttpHeaders.CACHE_CONTROL, "no-store"); + captcha.verify(input.captchaCode(), input.captchaAnswer()); + SysUser user = users.login(input.email()); + return ApiResponse.success(new LoginResponse(tokens.issue(user.getUserCode()), "Bearer", + properties.tokenTtl().toSeconds(), view(user))); + } + + @ApiRequestLog("管理员退出登录") + @Operation(summary = "退出当前管理员登录态") + @PostMapping("/admin-api/auth/logout") + public ApiResponse logout(@RequestHeader(HttpHeaders.AUTHORIZATION) String authorization) { + String userCode = CurrentAdmin.required().userCode(); + tokens.revoke(authorization.substring(7)); + log.info("管理员退出登录 userCode={} requestId={}", userCode, RequestIdHolder.get()); + return ApiResponse.success(null); + } + + @ApiRequestLog("查询当前管理员") + @Operation(summary = "获取当前登录管理员") + @GetMapping("/admin-api/users/me") + public ApiResponse me() { + return ApiResponse.success(view(users.requireActive(CurrentAdmin.required().userCode()))); + } + + private LoginUserResponse view(SysUser user) { + return new LoginUserResponse(user.getUserCode(), user.getNickname(), user.getEmail()); + } +} diff --git a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/ComponentAssetController.java b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/ComponentAssetController.java index db93ffb..3c3c310 100644 --- a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/ComponentAssetController.java +++ b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/ComponentAssetController.java @@ -44,7 +44,7 @@ public class ComponentAssetController { if (object.contentLength() >= 0) { response.setContentLengthLong(object.contentLength()); } - response.setHeader(HttpHeaders.CACHE_CONTROL, "public, max-age=3600"); + response.setHeader(HttpHeaders.CACHE_CONTROL, "private, max-age=3600"); objectStorageClient.writeObjectTo(objectKey, response.getOutputStream()); } } diff --git a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/UserManagementController.java b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/UserManagementController.java index 4fd3ba2..ebd1089 100644 --- a/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/UserManagementController.java +++ b/cadworld-adminapi/src/main/java/com/linkerbot/cadworld/controller/UserManagementController.java @@ -46,7 +46,7 @@ public class UserManagementController { @PutMapping("/{id}") public ApiResponse update(@PathVariable Long id, @Valid @RequestBody SaveUserRequest request) { return ApiResponse.success(service.update(id, request)); } - @ApiRequestLog("逻辑删除用户") + @ApiRequestLog("禁用用户") @DeleteMapping("/{id}") public ApiResponse delete(@PathVariable Long id) { service.delete(id); diff --git a/cadworld-adminapi/src/main/resources/application.yml b/cadworld-adminapi/src/main/resources/application.yml index e4067f7..12553a7 100644 --- a/cadworld-adminapi/src/main/resources/application.yml +++ b/cadworld-adminapi/src/main/resources/application.yml @@ -34,12 +34,12 @@ springdoc: path: /swagger-ui.html app: + auth: + captcha-ttl: ${APP_ADMIN_AUTH_CAPTCHA_TTL:${APP_AUTH_CAPTCHA_TTL:PT2M}} + token-ttl: ${APP_ADMIN_AUTH_TOKEN_TTL:${APP_AUTH_TOKEN_TTL:PT24H}} admin: cors: allowed-origins: ${APP_ADMIN_ALLOWED_ORIGINS:} - operator: - id: ${APP_ADMIN_OPERATOR_ID:0} - name: ${APP_ADMIN_OPERATOR_NAME:TEST_OPERATOR} upload-session: issuer: cadworld-upload # Empty means a random, process-local signing key. Set a stable key for restarts/multiple instances. diff --git a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminApiTest.java b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminApiTest.java index d4f9713..7be91e4 100644 --- a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminApiTest.java +++ b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminApiTest.java @@ -6,14 +6,19 @@ import ch.qos.logback.core.read.ListAppender; import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; +import com.linkerbot.cadworld.audit.EarlyFailureAuditFilter; import com.linkerbot.cadworld.common.api.OperationTargetHolder; +import com.linkerbot.cadworld.common.web.RequestIdFilter; import com.linkerbot.cadworld.entity.Component; import com.linkerbot.cadworld.entity.OperationLog; import com.linkerbot.cadworld.logging.ApiRequestLogCapture; +import com.linkerbot.cadworld.logging.ApiRequestLoggingFilter; import com.linkerbot.cadworld.mapper.ComponentMapper; +import com.linkerbot.cadworld.security.common.TokenService; import com.linkerbot.cadworld.service.OperationLogService; -import com.linkerbot.cadworld.service.support.ComponentUploadSessionTokenProvider; import com.linkerbot.cadworld.service.support.ComponentUploadSessionTokenProvider.UploadSessionClaims; +import com.linkerbot.cadworld.service.support.ComponentUploadSessionTokenProvider; +import jakarta.servlet.Filter; import java.math.BigDecimal; import java.nio.charset.StandardCharsets; import java.time.Instant; @@ -31,6 +36,8 @@ import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.test.context.ActiveProfiles; import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MvcResult; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; +import org.springframework.web.context.WebApplicationContext; import org.springframework.web.method.HandlerMethod; import static org.assertj.core.api.Assertions.*; @@ -47,9 +54,12 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers. }) @ActiveProfiles("verification") @org.springframework.context.annotation.Import(InMemoryObjectStorageConfiguration.class) -@AutoConfigureMockMvc +@AutoConfigureMockMvc(print = org.springframework.boot.test.autoconfigure.web.servlet.MockMvcPrint.NONE) class AdminApiTest { @Autowired MockMvc mvc; + @Autowired WebApplicationContext webContext; + @Autowired TokenService adminTokens; + private long adminId; @Autowired ObjectMapper json; @Autowired JdbcTemplate jdbc; @Autowired InMemoryObjectStorageConfiguration.InMemoryObjectStorageClient storage; @@ -64,6 +74,12 @@ class AdminApiTest { storage.clear(); for (String table : List.of("component", "sys_user", "sys_operation_log")) jdbc.update("DELETE FROM " + table); OperationTargetHolder.clear(); + AdminAuthTestSupport.Session session = AdminAuthTestSupport.create(jdbc, adminTokens); + adminId = session.userId(); + mvc = MockMvcBuilders.webAppContextSetup(webContext) + .addFilters(new RequestIdFilter(), webContext.getBean(ApiRequestLoggingFilter.class), + webContext.getBean("springSecurityFilterChain", Filter.class), webContext.getBean(EarlyFailureAuditFilter.class)) + .defaultRequest(get("/").header("Authorization", "Bearer " + session.token())).build(); } @Test @@ -96,7 +112,7 @@ class AdminApiTest { String code = "CW-0123456789ABCDEF0123456789ABCDEF"; String batch = "abcdef0123456789abcdef0123456789"; String prefix = "cadworld_dev/components/" + code; - UploadSessionClaims session = new UploadSessionClaims(0L, null, code, batch, + UploadSessionClaims session = new UploadSessionClaims(adminId, null, code, batch, prefix + "/step/" + batch + "/", prefix + "/urdf/" + batch + "/", Instant.now().plusSeconds(300)); String token = tokens.generateToken(session); @@ -660,11 +676,11 @@ class AdminApiTest { Map body = uploaded(); UploadSessionClaims original = tokens.parseToken(body.get("uploadSessionToken").toString()); for (String token : List.of("forged-token", - tokens.generateToken(new ComponentUploadSessionTokenProvider.UploadSessionClaims(99L,null, + tokens.generateToken(new ComponentUploadSessionTokenProvider.UploadSessionClaims(adminId + 1000000,null, original.componentCode(),original.batch(),original.stepPrefix(),original.urdfPrefix(),original.expiresAt())), - tokens.generateToken(new ComponentUploadSessionTokenProvider.UploadSessionClaims(0L,null, + tokens.generateToken(new ComponentUploadSessionTokenProvider.UploadSessionClaims(adminId,null, original.componentCode(),original.batch(),original.stepPrefix(),original.urdfPrefix(),Instant.now().minusSeconds(60))), - tokens.generateToken(new ComponentUploadSessionTokenProvider.UploadSessionClaims(0L,null, + tokens.generateToken(new ComponentUploadSessionTokenProvider.UploadSessionClaims(adminId,null, original.componentCode(),original.batch(),original.stepPrefix().replace("cadworld_dev/","cadworld/"), original.urdfPrefix().replace("cadworld_dev/","cadworld/"),original.expiresAt())))) { body.put("uploadSessionToken",token); @@ -799,20 +815,31 @@ class AdminApiTest { } @Test - void userCrudAndLogicalDeletionRemainUnaudited() throws Exception { + void userCrudAndDisableRemainUnaudited() throws Exception { JsonNode user = data(mvc.perform(post("/admin-api/users").contentType(MediaType.APPLICATION_JSON) - .content("{\"phone\":\"13812345678\",\"nickname\":\"测试用户\"}")).andExpect(status().isOk()).andReturn()); + .content("{\"email\":\" USER@EXAMPLE.TEST \",\"nickname\":\"测试用户\"}")).andExpect(status().isOk()).andReturn()); long id = user.path("id").asLong(); mvc.perform(put("/admin-api/users/{id}",id).contentType(MediaType.APPLICATION_JSON) - .content("{\"phone\":\"13812345678\",\"nickname\":\"管理员\",\"status\":\"DISABLED\",\"userType\":\"ADMIN\"}")) + .content("{\"email\":\" USER@EXAMPLE.TEST \",\"nickname\":\"管理员\",\"status\":\"DISABLED\",\"userType\":\"ADMIN\"}")) .andExpect(status().isOk()); mvc.perform(get("/admin-api/users").param("userType","ADMIN").param("status","DISABLED")) .andExpect(jsonPath("$.data.total").value(1)); mvc.perform(delete("/admin-api/users/{id}",id)).andExpect(status().isOk()); - mvc.perform(get("/admin-api/users/{id}",id)).andExpect(status().isNotFound()); + mvc.perform(get("/admin-api/users/{id}",id)).andExpect(status().isOk()) + .andExpect(jsonPath("$.data.status").value("DISABLED")) + .andExpect(jsonPath("$.data.email").value("user@example.test")); mvc.perform(post("/admin-api/users").contentType(MediaType.APPLICATION_JSON) - .content("{\"phone\":\"13812345678\",\"nickname\":\"再次创建\"}")) - .andExpect(status().isConflict()).andExpect(jsonPath("$.code").value("USER_PHONE_DUPLICATE")); + .content("{\"email\":\"user@example.test\",\"nickname\":\"禁用后再次创建\"}")) + .andExpect(status().isConflict()).andExpect(jsonPath("$.code").value("USER_EMAIL_DUPLICATE")); + mvc.perform(get("/admin-api/users").param("keyword", "user@example.test")) + .andExpect(status().isOk()).andExpect(jsonPath("$.data.total").value(1)); + mvc.perform(put("/admin-api/users/{id}",id).contentType(MediaType.APPLICATION_JSON) + .content("{\"email\":\"user@example.test\",\"nickname\":\"重新启用\",\"status\":\"ACTIVE\"}")) + .andExpect(status().isOk()).andExpect(jsonPath("$.data.status").value("ACTIVE")) + .andExpect(jsonPath("$.data.userCode").value(user.path("userCode").asText())); + mvc.perform(post("/admin-api/users").contentType(MediaType.APPLICATION_JSON) + .content("{\"email\":\" USER@EXAMPLE.TEST \",\"nickname\":\"再次创建\"}")) + .andExpect(status().isConflict()).andExpect(jsonPath("$.code").value("USER_EMAIL_DUPLICATE")); assertThat(count("sys_operation_log")).isZero(); } @@ -839,10 +866,11 @@ class AdminApiTest { body.put("urdfInfo", "PRIVATE_URDF_VALUE"); expectCreateError(body, 422, "INVALID_COMPONENT_FORM"); mvc.perform(get("/admin-api/users").param("keyword","13800000001")); + mvc.perform(get("/admin-api/users").param("keyword","PRIVATE_EMAIL@example.test")); String messages = String.join("\n",runtime.messages()); assertThat(messages).contains("description=新增组件","result=SUCCESS","result=FAILURE","durationMs="); assertThat(messages).doesNotContain("PRIVATE_FIELD_VALUE","PRIVATE_BOM_VALUE","PRIVATE_URDF_VALUE", - "PRIVATE_TOKEN",body.get("stepObjectKey").toString(),"13800000001"); + "PRIVATE_TOKEN",body.get("stepObjectKey").toString(),"13800000001","PRIVATE_EMAIL@example.test"); assertThat(capture.list).isEmpty(); assertThat(jdbc.queryForList("SELECT * FROM sys_operation_log").toString()) .doesNotContain("PRIVATE_FIELD_VALUE","PRIVATE_BOM_VALUE","PRIVATE_URDF_VALUE", diff --git a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminAuthApiTest.java b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminAuthApiTest.java new file mode 100644 index 0000000..548cf8e --- /dev/null +++ b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminAuthApiTest.java @@ -0,0 +1,246 @@ +package com.linkerbot.cadworld; + +import ch.qos.logback.classic.Logger; +import ch.qos.logback.classic.spi.ILoggingEvent; +import ch.qos.logback.core.read.ListAppender; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.linkerbot.cadworld.security.common.AuthProperties; +import com.linkerbot.cadworld.security.common.CaptchaService; +import com.linkerbot.cadworld.security.common.TokenService; +import com.linkerbot.cadworld.service.auth.AdminLoginService; +import java.util.List; +import java.util.Map; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.context.TestConfiguration; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Import; +import org.springframework.context.annotation.Primary; +import org.springframework.dao.DataAccessResourceFailureException; +import org.springframework.http.HttpHeaders; +import org.springframework.http.MediaType; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.bean.override.mockito.MockitoSpyBean; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.MvcResult; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.doThrow; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.options; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +@SpringBootTest(classes = AdminApiApplication.class, properties = { + "spring.datasource.url=jdbc:h2:mem:admin-auth;MODE=MySQL;DB_CLOSE_DELAY=-1", + "spring.datasource.driver-class-name=org.h2.Driver", "spring.datasource.username=sa", "spring.datasource.password=", + "app.storage.root-prefix=cadworld_dev", "logging.file.path=target/test-logs", + "logging.level.com.linkerbot.cadworld=DEBUG", "app.admin.cors.allowed-origins=http://localhost:5173" +}) +@ActiveProfiles("verification") +@AutoConfigureMockMvc(print = org.springframework.boot.test.autoconfigure.web.servlet.MockMvcPrint.NONE) +@Import({InMemoryObjectStorageConfiguration.class, AdminAuthApiTest.CaptchaConfiguration.class}) +class AdminAuthApiTest { + private static final String ORIGIN = "http://localhost:5173"; + @Autowired private MockMvc mvc; + @Autowired private JdbcTemplate jdbc; + @Autowired private ObjectMapper json; + @Autowired private TokenService tokens; + @Autowired private AuthProperties properties; + @MockitoSpyBean private AdminLoginService users; + private AdminAuthTestSupport.Session admin; + + @BeforeEach + void prepare() { + for (String table : List.of("component", "sys_user", "sys_operation_log")) jdbc.update("DELETE FROM " + table); + admin = AdminAuthTestSupport.create(jdbc, tokens); + jdbc.update("UPDATE sys_user SET email=? WHERE user_code=?", "admin@example.test", admin.userCode()); + } + + @Test + void adminLoginNormalizesEmailAndReturnsCurrentUserWithoutId() throws Exception { + JsonNode login = login(" ADMIN@EXAMPLE.TEST "); + assertThat(login.path("tokenType").asText()).isEqualTo("Bearer"); + assertThat(login.path("expiresIn").asLong()).isEqualTo(86400); + assertThat(login.path("user").path("userCode").asText()).isEqualTo(admin.userCode()); + assertThat(login.path("user").size()).isEqualTo(3); + mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(login))) + .andExpect(status().isOk()).andExpect(jsonPath("$.data.email").value("admin@example.test")) + .andExpect(jsonPath("$.data.userCode").value(admin.userCode())) + .andExpect(jsonPath("$.data.id").doesNotExist()).andExpect(header().doesNotExist(HttpHeaders.SET_COOKIE)); + mvc.perform(get("/admin-api/users/me")).andExpect(status().isUnauthorized()); + } + + @Test + void unknownAndNormalEmailsAreRejectedWithoutRegistrationOrPrivilegeEscalation() throws Exception { + jdbc.update("INSERT INTO sys_user (user_code,email,nickname,status,user_type) VALUES (?,?,'普通用户','ACTIVE','NORMAL')", + "B".repeat(32), "normal@example.test"); + for (String email : List.of("normal@example.test", "unknown@example.test")) { + mvc.perform(post("/admin-api/auth/login").contentType(MediaType.APPLICATION_JSON) + .content(body(email, captcha(), "ABCDE"))) + .andExpect(status().isForbidden()).andExpect(jsonPath("$.code").value("ADMIN_ACCESS_DENIED")); + } + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_user", Long.class)).isEqualTo(2); + assertThat(jdbc.queryForObject("SELECT user_type FROM sys_user WHERE email=?", String.class, "normal@example.test")).isEqualTo("NORMAL"); + } + + @Test + void invalidAndReusedCaptchaCannotLoginAndValidationRejectsBadEmail() throws Exception { + String code = captcha(); + mvc.perform(post("/admin-api/auth/login").contentType(MediaType.APPLICATION_JSON) + .content(body("admin@example.test", code, "WRONG"))) + .andExpect(status().isBadRequest()).andExpect(jsonPath("$.code").value("CAPTCHA_INVALID")); + mvc.perform(post("/admin-api/auth/login").contentType(MediaType.APPLICATION_JSON) + .content(body("admin@example.test", code, "ABCDE"))) + .andExpect(status().isBadRequest()); + mvc.perform(post("/admin-api/auth/login").contentType(MediaType.APPLICATION_JSON) + .content(body("invalid-email", captcha(), "ABCDE"))) + .andExpect(status().isUnprocessableEntity()).andExpect(jsonPath("$.code").value("INVALID_REQUEST")); + } + + @Test + void disabledAndDemotedAdminsLoseAccessOnTheirNextRequest() throws Exception { + JsonNode login = login("admin@example.test"); + jdbc.update("UPDATE sys_user SET status='DISABLED' WHERE user_code=?", admin.userCode()); + mvc.perform(get("/admin-api/components").header(HttpHeaders.AUTHORIZATION, bearer(login))) + .andExpect(status().isUnauthorized()).andExpect(jsonPath("$.code").value("UNAUTHORIZED")); + mvc.perform(post("/admin-api/auth/login").header(HttpHeaders.ORIGIN, ORIGIN).contentType(MediaType.APPLICATION_JSON) + .content(body("admin@example.test", captcha(), "ABCDE"))) + .andExpect(status().isForbidden()).andExpect(jsonPath("$.code").value("ACCOUNT_DISABLED")) + .andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN)); + jdbc.update("UPDATE sys_user SET status='ACTIVE', user_type='NORMAL' WHERE user_code=?", admin.userCode()); + mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(login))) + .andExpect(status().isForbidden()).andExpect(jsonPath("$.code").value("ADMIN_ACCESS_DENIED")); + } + + @Test + void logoutOnlyRevokesCurrentAdminSessionAndOtherTokenStoresAreIndependent() throws Exception { + JsonNode first = login("admin@example.test"); + JsonNode second = login("admin@example.test"); + mvc.perform(post("/admin-api/auth/logout").header(HttpHeaders.AUTHORIZATION, bearer(first))).andExpect(status().isOk()); + mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(first))).andExpect(status().isUnauthorized()); + mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(second))).andExpect(status().isOk()); + TokenService userSideTokens = new TokenService(properties); + mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, "Bearer " + userSideTokens.issue(admin.userCode()))) + .andExpect(status().isUnauthorized()); + } + + @Test + void everyAdminBusinessRouteRequiresLoginIncludingDownloads() throws Exception { + for (String path : List.of("/admin-api/users/me", "/admin-api/components", "/admin-api/users", "/admin-api/operation-logs", + "/admin-api/component-assets/cadworld_dev/components/model.step")) { + mvc.perform(get(path).header("X-Request-Id", "admin-no-auth")) + .andExpect(status().isUnauthorized()).andExpect(jsonPath("$.code").value("UNAUTHORIZED")) + .andExpect(jsonPath("$.requestId").value("admin-no-auth")); + } + for (String path : List.of("/admin-api/components", "/admin-api/users", "/admin-api/storage/upload-signature", "/admin-api/auth/logout")) { + mvc.perform(post(path)).andExpect(status().isUnauthorized()); + } + mvc.perform(put("/admin-api/components/1")).andExpect(status().isUnauthorized()); + mvc.perform(delete("/admin-api/components/1")).andExpect(status().isUnauthorized()); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_operation_log", Long.class)).isZero(); + mvc.perform(get("/admin-api/auth/captcha").header(HttpHeaders.AUTHORIZATION, "Bearer stale")) + .andExpect(status().isOk()).andExpect(header().string(HttpHeaders.CACHE_CONTROL, "no-store")); + } + + @Test + void corsPreflightAndAuthenticationFailuresHaveCorrectHeaders() throws Exception { + mvc.perform(options("/admin-api/components").header(HttpHeaders.ORIGIN, ORIGIN) + .header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "PUT") + .header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "authorization,content-type,x-request-id")) + .andExpect(status().isOk()).andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN)); + mvc.perform(get("/admin-api/users/me").header(HttpHeaders.ORIGIN, ORIGIN)) + .andExpect(status().isUnauthorized()).andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN)); + mvc.perform(get("/admin-api/users/me").header(HttpHeaders.ORIGIN, ORIGIN).header(HttpHeaders.AUTHORIZATION, "Bearer invalid")) + .andExpect(status().isUnauthorized()).andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN)); + mvc.perform(options("/admin-api/components").header(HttpHeaders.ORIGIN, "https://untrusted.example") + .header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "POST")) + .andExpect(status().isForbidden()).andExpect(header().doesNotExist(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN)); + } + + @Test + void uploadsAndAuditUseActualAdminAndCannotReuseAnotherAdminsUploadSession() throws Exception { + JsonNode upload = data(mvc.perform(post("/admin-api/storage/upload-signature") + .header(HttpHeaders.AUTHORIZATION, "Bearer " + admin.token()).contentType(MediaType.APPLICATION_JSON).content("{}")) + .andExpect(status().isOk()).andReturn()); + String renewal = json.writeValueAsString(Map.of("uploadSessionToken", upload.path("uploadSessionToken").asText())); + mvc.perform(post("/admin-api/storage/upload-signature").header(HttpHeaders.AUTHORIZATION, "Bearer " + admin.token()) + .contentType(MediaType.APPLICATION_JSON).content(renewal)).andExpect(status().isOk()); + AdminAuthTestSupport.Session other = AdminAuthTestSupport.create(jdbc, tokens); + mvc.perform(post("/admin-api/storage/upload-signature").header(HttpHeaders.AUTHORIZATION, "Bearer " + other.token()) + .contentType(MediaType.APPLICATION_JSON).content(renewal)) + .andExpect(status().isUnprocessableEntity()).andExpect(jsonPath("$.code").value("INVALID_COMPONENT_UPLOAD_SESSION")); + mvc.perform(post("/admin-api/components").header(HttpHeaders.AUTHORIZATION, "Bearer " + admin.token()) + .contentType(MediaType.APPLICATION_JSON).content("{}")) + .andExpect(status().isUnprocessableEntity()); + assertThat(jdbc.queryForObject("SELECT operator_id FROM sys_operation_log WHERE action='CREATE'", Long.class)).isEqualTo(admin.userId()); + assertThat(jdbc.queryForObject("SELECT operator_name FROM sys_operation_log WHERE action='CREATE'", String.class)).isEqualTo("测试管理员"); + } + + @Test + void databaseFailureDuringAuthenticationUsesExistingErrorEnvelope() throws Exception { + doThrow(new DataAccessResourceFailureException("test unavailable")).when(users).requireActive(admin.userCode()); + mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, "Bearer " + admin.token())) + .andExpect(status().isServiceUnavailable()).andExpect(jsonPath("$.code").value("DATABASE_UNAVAILABLE")); + } + + @Test + void swaggerDocumentsBearerAuthenticationAndLoginRoutesArePublic() throws Exception { + mvc.perform(get("/api-docs")).andExpect(status().isOk()) + .andExpect(jsonPath("$.components.securitySchemes.adminBearer.scheme").value("bearer")); + } + + @Test + void adminAuthenticationLogsDoNotExposeTokensCaptchaOrEmail() throws Exception { + Logger logger = (Logger) LoggerFactory.getLogger("com.linkerbot.cadworld"); + ListAppender capture = new ListAppender<>(); + capture.start(); logger.addAppender(capture); + try { + JsonNode login = login("admin@example.test"); + mvc.perform(post("/admin-api/auth/logout").header(HttpHeaders.AUTHORIZATION, bearer(login))).andExpect(status().isOk()); + mvc.perform(get("/admin-api/users/me").header(HttpHeaders.AUTHORIZATION, "Bearer PRIVATE_ADMIN_TOKEN")) + .andExpect(status().isUnauthorized()); + String logs = String.join("\n", capture.list.stream().map(ILoggingEvent::getFormattedMessage).toList()); + assertThat(logs).contains("管理员登录成功", "管理员退出登录", "UNAUTHORIZED"); + assertThat(logs).doesNotContain("admin@example.test", "PRIVATE_ADMIN_TOKEN", "ABCDE", login.path("token").asText(), "data:image/png;base64,"); + } finally { + logger.detachAppender(capture); capture.stop(); + } + } + + private String captcha() throws Exception { + return data(mvc.perform(get("/admin-api/auth/captcha")).andExpect(status().isOk()).andReturn()).path("captchaCode").asText(); + } + + private JsonNode login(String email) throws Exception { + return data(mvc.perform(post("/admin-api/auth/login").header(HttpHeaders.AUTHORIZATION, "Bearer stale") + .contentType(MediaType.APPLICATION_JSON).content(body(email, captcha(), "abcde"))) + .andExpect(status().isOk()).andExpect(header().string(HttpHeaders.CACHE_CONTROL, "no-store")).andReturn()); + } + + private String body(String email, String code, String answer) throws Exception { + return json.writeValueAsString(Map.of("email", email, "captchaCode", code, "captchaAnswer", answer)); + } + + private String bearer(JsonNode login) { return "Bearer " + login.path("token").asText(); } + private JsonNode data(MvcResult result) throws Exception { return json.readTree(result.getResponse().getContentAsByteArray()).path("data"); } + + @TestConfiguration(proxyBeanMethods = false) + static class CaptchaConfiguration { + @Bean @Primary CaptchaService fixedAdminCaptcha(AuthProperties properties) { + return new CaptchaService(properties) { + @Override protected String generateAnswer() { return "ABCDE"; } + }; + } + } +} diff --git a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminAuthTestSupport.java b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminAuthTestSupport.java new file mode 100644 index 0000000..0dd778b --- /dev/null +++ b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/AdminAuthTestSupport.java @@ -0,0 +1,22 @@ +package com.linkerbot.cadworld; + +import com.linkerbot.cadworld.security.common.TokenService; +import com.linkerbot.cadworld.service.support.UserCodes; +import java.util.Locale; +import org.springframework.jdbc.core.JdbcTemplate; + +final class AdminAuthTestSupport { + private AdminAuthTestSupport() { + } + + record Session(long userId, String userCode, String token) { + } + + static Session create(JdbcTemplate jdbc, TokenService tokens) { + String code = UserCodes.generate(); + jdbc.update("INSERT INTO sys_user (user_code,email,nickname,status,user_type) VALUES (?,?,?,'ACTIVE','ADMIN')", + code, code.toLowerCase(Locale.ROOT) + "@example.test", "测试管理员"); + Long id = jdbc.queryForObject("SELECT id FROM sys_user WHERE user_code=?", Long.class, code); + return new Session(id, code, tokens.issue(code)); + } +} diff --git a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/TestSchemaSupport.java b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/TestSchemaSupport.java index 0464c1c..1c46bfe 100644 --- a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/TestSchemaSupport.java +++ b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/TestSchemaSupport.java @@ -64,11 +64,11 @@ final class TestSchemaSupport { jdbc.execute(""" CREATE TABLE IF NOT EXISTS sys_user ( id BIGINT AUTO_INCREMENT PRIMARY KEY, - phone VARCHAR(32) NOT NULL UNIQUE, + user_code CHAR(32) NOT NULL UNIQUE, + email VARCHAR(254) NOT NULL UNIQUE, nickname VARCHAR(64) NOT NULL DEFAULT '', status VARCHAR(32) NOT NULL DEFAULT 'ACTIVE', user_type VARCHAR(32) NOT NULL DEFAULT 'NORMAL', - deleted INT NOT NULL DEFAULT 0, created_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP ) diff --git a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/UploadHttpTest.java b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/UploadHttpTest.java index d1169d4..97c0b18 100644 --- a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/UploadHttpTest.java +++ b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/UploadHttpTest.java @@ -1,6 +1,7 @@ package com.linkerbot.cadworld; import com.fasterxml.jackson.databind.JsonNode; +import com.linkerbot.cadworld.security.common.TokenService; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; @@ -22,11 +23,17 @@ import static org.assertj.core.api.Assertions.*; @org.springframework.context.annotation.Import(InMemoryObjectStorageConfiguration.class) class UploadHttpTest { @Autowired TestRestTemplate http; + @Autowired TokenService tokens; @Autowired JdbcTemplate jdbc; @Autowired InMemoryObjectStorageConfiguration.InMemoryObjectStorageClient storage; @Test void oversizeDirectUploadIsRejectedAtComponentSaveWithoutCreatingRowAndAuditedOnce() { + AdminAuthTestSupport.Session admin = AdminAuthTestSupport.create(jdbc, tokens); + http.getRestTemplate().setInterceptors(List.of((request, body, execution) -> { + request.getHeaders().setBearerAuth(admin.token()); + return execution.execute(request, body); + })); JsonNode session = http.postForObject("/admin-api/storage/upload-signature",Map.of(),JsonNode.class).path("data"); String step = session.path("step").path("keyPrefix").asText()+"model.step"; String main = session.path("urdf").path("keyPrefix").asText()+"robot.urdf"; @@ -40,5 +47,7 @@ class UploadHttpTest { assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM component",Long.class)).isZero(); org.awaitility.Awaitility.await().atMost(java.time.Duration.ofSeconds(5)).untilAsserted(() -> assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_operation_log WHERE action='CREATE' AND success=FALSE",Long.class)).isEqualTo(1)); + assertThat(jdbc.queryForObject("SELECT operator_id FROM sys_operation_log WHERE action='CREATE'", Long.class)) + .isEqualTo(admin.userId()); } } diff --git a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/audit/OperationAuditInterceptorTest.java b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/audit/OperationAuditInterceptorTest.java index 05e7632..1ff2136 100644 --- a/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/audit/OperationAuditInterceptorTest.java +++ b/cadworld-adminapi/src/test/java/com/linkerbot/cadworld/audit/OperationAuditInterceptorTest.java @@ -1,6 +1,5 @@ package com.linkerbot.cadworld.audit; -import com.linkerbot.cadworld.config.AdminOperatorProperties; import com.linkerbot.cadworld.entity.OperationLog; import com.linkerbot.cadworld.service.AdminOperatorProvider; import com.linkerbot.cadworld.service.OperationLogService; @@ -19,7 +18,7 @@ class OperationAuditInterceptorTest { @Test void multipartFailureBeforeMvcIsAuditedOnce() throws Exception { OperationLogService service = mock(OperationLogService.class); - OperationAuditInterceptor audit = new OperationAuditInterceptor(service, new AdminOperatorProvider(new AdminOperatorProperties(0, "TEST_OPERATOR"))); + OperationAuditInterceptor audit = new OperationAuditInterceptor(service, operator()); RequestMappingHandlerMapping mappings = mock(RequestMappingHandlerMapping.class); MockHttpServletRequest request = new MockHttpServletRequest("POST", "/admin-api/components"); MockHttpServletResponse response = new MockHttpServletResponse(); @@ -41,7 +40,7 @@ class OperationAuditInterceptorTest { void logFailureDoesNotChangeTheBusinessResponse() throws Exception { OperationLogService service = mock(OperationLogService.class); doThrow(new IllegalStateException("database unavailable")).when(service).record(any()); - OperationAuditInterceptor audit = new OperationAuditInterceptor(service, new AdminOperatorProvider(new AdminOperatorProperties(0, "TEST_OPERATOR"))); + OperationAuditInterceptor audit = new OperationAuditInterceptor(service, operator()); MockHttpServletRequest request = new MockHttpServletRequest("POST", "/admin-api/components"); MockHttpServletResponse response = new MockHttpServletResponse(); HandlerMethod handler = new HandlerMethod(this, getClass().getDeclaredMethod("operation")); @@ -53,4 +52,11 @@ class OperationAuditInterceptorTest { @AuditOperation(module = "COMPONENT", action = "CREATE") void operation() { } + + private AdminOperatorProvider operator() { + AdminOperatorProvider operator = mock(AdminOperatorProvider.class); + when(operator.userId()).thenReturn(7L); + when(operator.name()).thenReturn("测试管理员"); + return operator; + } } diff --git a/cadworld-api/docs/api.md b/cadworld-api/docs/api.md index e1a3b3e..e6b4646 100644 --- a/cadworld-api/docs/api.md +++ b/cadworld-api/docs/api.md @@ -14,7 +14,7 @@ | GET | `/api/components/{componentCode}` | 按组件编码获取详情,包括 BOM、URDF 信息和模型地址 | | POST | `/api/robot-conversations` | 创建文字/图片需求会话,后续接口见上述联调文档 | -组件匹配和详情无需登录凭证;需求会话使用后端 HttpOnly Cookie 校验访客归属,前端需携带 Cookie。组件使用 `componentCode` 标识,不返回数据库 ID。模型通过响应中的公开 OSS/CDN 地址加载。 +所有 `/api/**` 业务接口均需要 Bearer Token,包括组件匹配和详情;先完成[邮箱与图片验证码登录](auth-api.md),请求头携带 `Authorization: Bearer `。需求会话按登录用户隔离。组件使用 `componentCode` 标识,不返回数据库 ID。模型通过响应中的公开 OSS/CDN 地址加载。 新增组件编码格式为 `CW-` 加 16 位随机数字或大写字母(排除 `I/L/O/U`),总长 19,例如 `CW-7K3M9Q2R6V8X4T5N`。旧版 35 字符编码继续有效,以下部分示例保留旧编码。前端将编码视为不透明字符串,直接使用返回值查询和加载,不按固定长度截取或重组。 diff --git a/cadworld-api/docs/auth-api.md b/cadworld-api/docs/auth-api.md new file mode 100644 index 0000000..2653fb4 --- /dev/null +++ b/cadworld-api/docs/auth-api.md @@ -0,0 +1,147 @@ +# 邮箱与图片验证码登录 + +用户端默认端口 `8991`。除 `GET /api/auth/captcha`、`POST /api/auth/login` 和跨域预检外,所有 `/api/**` 业务接口都需要 `Authorization: Bearer `,包括组件详情、匹配、需求会话、私有图片和 SSE。JSON 返回统一为 `{code, message, data, requestId}`。 + +此流程沿用参考项目:邮箱与图片验证码登录,首次自动注册;不发送邮件、不验证邮箱归属。`user_type` 不作为客户端可提交字段。用户端仅返回唯一 `userCode`,不暴露数据库主键。 + +## 1. 接口 + +### 获取验证码 + +`GET /api/auth/captcha`,无需登录,响应设置 `Cache-Control: no-store`。 + +```json +{ + "code": "OK", + "message": "success", + "data": { + "captchaCode": "一次性验证码编码", + "image": "data:image/png;base64,...", + "expiresIn": 120 + }, + "requestId": "请求编号" +} +``` + +图片为 180×60 PNG,包含 5 位数字或大写字母。`image` 可直接作为验证码图片的 `src`。有效期默认 120 秒,答案忽略大小写和首尾空格。每次有效参数的登录提交都会消费对应验证码,答错后也必须重新获取。 + +### 登录 + +`POST /api/auth/login`,`Content-Type: application/json`,无需登录。 + +```json +{"email":"user@example.com","captchaCode":"验证码编码","captchaAnswer":"ABCDE"} +``` + +邮箱去除首尾空格、转小写后校验,最长 254 字符;验证码编码和答案必填,最长分别为 64、32 字符。成功示例: + +```json +{ + "code": "OK", + "message": "success", + "data": { + "token": "登录凭证", + "tokenType": "Bearer", + "expiresIn": 86400, + "user": { + "userCode": "0123456789ABCDEF0123456789ABCDEF", + "nickname": "用户_01234567", + "email": "user@example.com" + } + }, + "requestId": "请求编号" +} +``` + +首次登录创建 `ACTIVE / NORMAL` 用户,昵称为“用户_用户编码前8位”。同邮箱并发首次登录复用同一用户。用户编码创建后不可修改。 + +Token 是 32 字节安全随机值的无填充 Base64URL 编码,有效期默认 24 小时;访问不续期。同一用户可持有多个 Token。 + +### 当前用户与退出 + +- `GET /api/users/me`:返回 `data={userCode,nickname,email}`。 +- `POST /api/auth/logout`:撤销当前 Token,返回 `data=null`,其他登录态继续有效。再次使用已撤销 Token 返回 401。 + +以上接口均须携带 Bearer Token。用户被后台禁用后,登录返回 403,已有 Token 在下一次业务请求时被拒绝。 + +| HTTP 状态 | code | 处理方式 | +| --- | --- | --- | +| 400 | `CAPTCHA_INVALID` | 验证码错误、过期或已消费,重新获取图片 | +| 401 | `UNAUTHORIZED` | 未登录、Token 无效或账号已不可用,重新登录 | +| 403 | `ACCOUNT_DISABLED` | 用户已禁用,联系管理员 | +| 422 | `INVALID_REQUEST` | 检查邮箱、必填字段、长度或未知字段 | +| 503 | `DATABASE_UNAVAILABLE` | 数据库暂不可用,稍后重试 | +| 503 | `USER_CODE_EXHAUSTED` | 用户编码分配重试失败,稍后重试 | + +## 2. 前端调用与需求归属 + +```javascript +const challenge = (await (await fetch('/api/auth/captcha')).json()).data; +// 将 challenge.image 展示给用户,answer 为用户输入的图片答案。 +const response = await fetch('/api/auth/login', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ email, captchaCode: challenge.captchaCode, captchaAnswer: answer }) +}); +if (!response.ok) throw await response.json(); +const { token } = (await response.json()).data; + +const current = await fetch('/api/users/me', { + headers: { Authorization: `Bearer ${token}` } +}); + +// 私有图片需要认证头,通过 Blob URL 展示,Token 不放在 URL 中。 +const imageResponse = await fetch(previewUrl, { + headers: { Authorization: `Bearer ${token}` } +}); +if (!imageResponse.ok) throw await imageResponse.json(); +const objectUrl = URL.createObjectURL(await imageResponse.blob()); +imageElement.src = objectUrl; +// 图片不再使用时执行 URL.revokeObjectURL(objectUrl)。 +``` + +POST SSE 同样在 fetch 的 headers 中携带 `Authorization`,详见 [需求联调文档](robot-demand-api.md)。不再需要访客 Cookie 或 `credentials: 'include'`。 + +会话归属由服务端认证的 `userCode` 决定,存储为 `SHA-256("user:" + userCode)`。同一用户在不同设备登录后可通过原业务编码访问自己的会话;其他用户访问返回 404。客户端不传 `userId`、`userCode` 或归属摘要来指定所有者。 + +历史匿名 Cookie 不授予访问权,也不会触发会话认领。历史匿名数据保留至现有过期任务清理。 + +## 3. 配置与运行 + +| 环境变量 | 默认值 | 说明 | +| --- | --- | --- | +| `APP_AUTH_CAPTCHA_TTL` | `PT2M` | 验证码有效期,至少 1 秒 | +| `APP_AUTH_TOKEN_TTL` | `PT24H` | 登录态有效期,至少 1 秒 | +| `APP_DEMAND_ALLOWED_ORIGINS` | 沿用各环境配置 | `/api/**` 跨域白名单,允许 Authorization 请求头 | + +验证码和登录态分别使用最多 10000 条的 Caffeine 缓存。当前按单实例部署;重启、缓存容量淘汰或有效期结束后凭证失效。用户和会话数据持久化保留;多实例共享登录态需后续切换为共享存储。 + +用户端和[管理端](../../cadworld-adminapi/docs/auth-api.md)分别引入自己的安全模块,独立保存 Token 和验证码。后台用户管理使用邮箱,删除入口改为禁用账号;上传与审计使用真实登录管理员。 + +## 4. 发布前手动执行的迁移 SQL + +以下 SQL 基于提供的邮箱版 `sys_user`(索引名 `uk_sys_user_phone`,索引列为 `email`),仅执行一次;已有该字段或索引的环境先核对结构。应用不自动迁移,仓库 `.sql` 文件未修改。先执行 SQL,再发布用户端和管理端新代码。 + +```sql +ALTER TABLE `sys_user` + ADD COLUMN `user_code` char(32) + CHARACTER SET ascii COLLATE ascii_bin + NULL COMMENT '用户唯一编码,对外使用且创建后不可修改' + AFTER `id`; + +UPDATE `sys_user` +SET `user_code` = UPPER(REPLACE(UUID(), '-', '')) +WHERE `user_code` IS NULL; + +ALTER TABLE `sys_user` + MODIFY COLUMN `user_code` char(32) + CHARACTER SET ascii COLLATE ascii_bin + NOT NULL COMMENT '用户唯一编码,对外使用且创建后不可修改', + ADD UNIQUE KEY `uk_sys_user_code` (`user_code`), + RENAME INDEX `uk_sys_user_phone` TO `uk_sys_user_email`; + +ALTER TABLE `robot_demand_conversation` + MODIFY COLUMN `owner_hash` char(64) + CHARACTER SET ascii COLLATE ascii_bin + NOT NULL COMMENT '登录用户归属摘要,历史匿名归属保留至过期'; +``` diff --git a/cadworld-api/docs/demand-integration.md b/cadworld-api/docs/demand-integration.md index b0463bd..1e5d8e6 100644 --- a/cadworld-api/docs/demand-integration.md +++ b/cadworld-api/docs/demand-integration.md @@ -11,7 +11,7 @@ 1. 使用已有 `component` 表,部署前按 [管理端旋转轴字段部署说明](../../cadworld-adminapi/docs/admin-api.md#43-旋转轴字段部署) 添加 `rotation_axis`。在用户端服务使用的数据库中执行 [demand-schema.md](demand-schema.md) 的五张表建表语句。代码不自动建表或迁移,不修改或执行仓库 `.sql` 文件。 2. 配置 MySQL、公开模型域名与 `ARK_API_KEY`。Key 仅提供给后端,缺失时其他组件接口仍可使用,需求解析返回不可用状态。 3. 为需求图片配置私有可写的持久化目录;不能映射为静态资源或挂载到公开模型目录。 -4. 前端通过同站点 HTTPS 代理 `/api`;开发跨端口时配置具体前端 origin。生产 Cookie 设置 Secure。 +4. 前端通过同站点 HTTPS 代理 `/api`;开发跨端口时配置具体前端 origin。先完成[邮箱登录及用户编码迁移](auth-api.md),全部业务请求携带 Bearer Token。 5. 对接组件实际接口:interfaceType 优先确定现有 category,双方 frames[].child 严格一致才可连接;每个 frames 元素是独立接口。无需填写 urdfInfo.assembly,模型摆放由前端处理。 ```bash @@ -36,7 +36,7 @@ java -jar cadworld-api/target/cadworld-api-0.0.1-SNAPSHOT.jar | `APP_DEMAND_CONCURRENT_ANALYSES` | `4`,允许 1–16;当前进程并发上限,无等待队列 | | `APP_DEMAND_ALLOWED_ORIGINS` | `/api/**` 跨域白名单;`test` 默认 `https://dev-cadworld.robotquan.com`,`prod` 默认 `https://cadworld.robotquan.com`;可用逗号分隔的完整 origin 覆盖,显式留空关闭跨域,禁止通配符 | -用户端跨域支持凭证,允许 `GET / POST / DELETE / OPTIONS`,请求头允许 `Content-Type / X-Request-Id`,向前端暴露 `X-Request-Id`,预检缓存 3600 秒。浏览器请求需要携带访客 Cookie 时,使用 `credentials: 'include'`(Axios 使用 `withCredentials: true`)。公开 OSS/CDN 资源的跨域需在对应资源服务单独配置。 +用户端跨域支持凭证,允许 `GET / POST / DELETE / OPTIONS`,请求头允许 `Content-Type / X-Request-Id / Authorization`,向前端暴露 `X-Request-Id`,预检缓存 3600 秒。浏览器统一发送 `Authorization: Bearer `,不再依赖匿名 Cookie。公开 OSS/CDN 资源的跨域需在对应资源服务单独配置。 模型调用使用严格 JSON Schema、深度思考、`stream:false`、`store:false`,不启用联网工具。SSE 为后端阶段和已校验业务结果,不透传模型推理内容。接收上游响应最多 2MiB,提取的中间 JSON 最多 150000 字符。 @@ -44,7 +44,7 @@ java -jar cadworld-api/target/cadworld-api-0.0.1-SNAPSHOT.jar ## 持久化与运行方式 -五张表分别保存会话归属和版本、私有附件元信息、服务端历史、完整解析结果、自动生成的匹配快照。对外均使用编码;原始访客 Cookie 只在浏览器,数据库保存其 SHA-256。没有账号系统时暂按浏览器访客隔离;以后接入登录,应将归属替换为服务端认证主体,不能改成信任客户端 `userId`。 +五张表分别保存会话归属和版本、私有附件元信息、服务端历史、完整解析结果、自动生成的匹配快照。对外均使用编码;会话归属使用服务端认证主体的 `SHA-256("user:" + userCode)`,不信任客户端 `userId` 或用户编码。历史匿名会话不认领,保留至过期任务清理。 新用户消息在事务中锁定会话、递增版本并使旧方案失效;相同消息编号和内容不重复创建版本、调用模型或选件。消息任务在需求规范化后立即执行自动选件和装配校验,需求结果与匹配快照在同一事务内提交,随后才发布 `ready` 和 `analysis.completed`;完成事件及 GET 查询同时返回公开的 `match`,内部 `snapshot` 始终移除。选件在会话锁外执行,提交时再次核对版本和取消状态,防止旧任务覆盖新方案。新流程不写入助手追问。 diff --git a/cadworld-api/docs/demand-schema.md b/cadworld-api/docs/demand-schema.md index 99bcfc9..6c8936e 100644 --- a/cadworld-api/docs/demand-schema.md +++ b/cadworld-api/docs/demand-schema.md @@ -4,20 +4,20 @@ 自动生成流程复用以下五张表,无需修改表结构或执行新的迁移。新消息完成需求理解、选件和装配校验后,将解析结果与匹配快照一起保存;`ready` 表示方案已生成。`needs_clarification` 仅保留兼容旧记录,新流程不生成该状态。下方已有 DDL 的确认相关注释保留作为旧结构说明。 -会话、消息、附件、解析和匹配均使用唯一编码对外访问,数据库主键只在内部使用。`owner_hash` 是匿名访客 Cookie 的 SHA-256,不保存原始 Cookie。完整解析结果只由所属访客访问;模型配置、内部匹配快照和图片磁盘路径不返回前端。 +会话、消息、附件、解析和匹配均使用唯一编码对外访问,数据库主键只在内部使用。`owner_hash` 保存服务端认证主体的 `SHA-256("user:" + userCode)`;历史匿名归属保留至过期,已有表的注释调整见[登录迁移 SQL](auth-api.md#4-发布前手动执行的迁移-sql)。完整解析结果只由所属用户访问;模型配置、内部匹配快照和图片磁盘路径不返回前端。 ```sql CREATE TABLE `robot_demand_conversation` ( `id` bigint NOT NULL AUTO_INCREMENT COMMENT '会话主键ID,仅内部使用', `conversation_code` varchar(64) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT '需求会话唯一编码', - `owner_hash` char(64) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT '匿名访客凭证SHA-256,用于归属校验', + `owner_hash` char(64) CHARACTER SET ascii COLLATE ascii_bin NOT NULL COMMENT '登录用户归属摘要,历史匿名归属保留至过期', `revision` int unsigned NOT NULL DEFAULT '0' COMMENT '当前需求版本号,每次新用户消息递增', `created_at` datetime(3) NOT NULL COMMENT '创建时间', `updated_at` datetime(3) NOT NULL COMMENT '最近更新时间', `expires_at` datetime(3) NOT NULL COMMENT '会话过期时间,默认最近新消息后七天', PRIMARY KEY (`id`), UNIQUE KEY `uk_demand_conversation_code` (`conversation_code`) COMMENT '会话编码唯一索引', - KEY `idx_demand_conversation_owner` (`owner_hash`,`updated_at`) COMMENT '访客会话查询索引', + KEY `idx_demand_conversation_owner` (`owner_hash`,`updated_at`) COMMENT '用户会话查询索引', KEY `idx_demand_conversation_expiry` (`expires_at`,`id`) COMMENT '过期会话清理索引' ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='机器人需求会话表'; diff --git a/cadworld-api/docs/robot-demand-api.md b/cadworld-api/docs/robot-demand-api.md index 7605959..e32a0f3 100644 --- a/cadworld-api/docs/robot-demand-api.md +++ b/cadworld-api/docs/robot-demand-api.md @@ -26,7 +26,7 @@ 5. 简短展示 `warnings`、缺件及未满足/未验证项;不弹出追问、确认或必须接受降级的页面。`assembly.status=blocked` 或 `status=no_match` 时展示具体原因,不伪造连接位姿。 6. 用户需要调整时,在同一会话发送新消息,例如“改成右臂扭矩至少30N·m”,后端生成新版本并返回新方案。 -浏览器需要保留后端设置的 HttpOnly Cookie,所有调用均设置 `credentials:"include"`。不需要读写 Cookie 值,也不传 `userId`、模型 Key 或系统提示词。当前按匿名浏览器访客隔离对话和图片,清除 Cookie 后不能访问之前记录。生产使用 HTTPS;前后端通过同站点 `/api` 代理接入。开发跨端口需后端配置具体允许域名,并使用一致的主机名(不要混用 localhost 与 127.0.0.1)。 +先完成[邮箱与图片验证码登录](auth-api.md),所有业务请求头携带 `Authorization: Bearer `,不再依赖匿名 Cookie 或 `credentials:"include"`。会话和图片归属服务端认证的用户,同账号换设备登录后仍可通过原业务编码访问;其他账号访问返回 404。历史匿名会话不自动认领,保留至过期清理。不传 `userId`、用户编码、模型 Key 或系统提示词。生产使用 HTTPS;开发跨端口需配置具体允许域名。 ### 接口清单 @@ -34,7 +34,7 @@ | --- | --- | --- | --- | | POST | `/api/robot-conversations` | 无请求体 | 会话编码、初始版本、有效期 | | POST | `/api/robot-conversations/{conversationId}/attachments` | multipart `file` | 图片编码、预览地址 | -| GET | `/api/robot-conversations/{conversationId}/attachments/{attachmentId}` | 无 | 私有原图,需要 Cookie | +| GET | `/api/robot-conversations/{conversationId}/attachments/{attachmentId}` | 无 | 私有原图,需要 Bearer Token | | POST | `/api/robot-conversations/{conversationId}/messages` | 消息 JSON | SSE 生成阶段、完整需求及装配方案 | | GET | `/api/robot-analyses/{analysisId}` | 无 | 当前生成状态、需求及装配方案 | | POST | `/api/robot-analyses/{analysisId}/retry` | 无请求体 | SSE,仅重试失败或停止的当前版本 | @@ -44,7 +44,7 @@ AI 对话拼装仅保留以上 7 个接口。原 `confirm`、`rematch`、按 `ma 正常文字生成只需调用“创建会话 → 发送消息”两个接口;图片生成再增加上传接口。预览、状态查询、重试和停止按实际交互调用。 -既有结构化 `POST /api/robot-matches` 和公开组件详情保留,见 [组件接口文档](api.md)。本流程的状态为小写,与既有接口的 `MATCHED/FALLBACK/PARTIAL/NO_MATCH` 分开使用。 +既有结构化 `POST /api/robot-matches` 和组件详情保留,均需登录,见 [组件接口文档](api.md)。本流程的状态为小写,与既有接口的 `MATCHED/FALLBACK/PARTIAL/NO_MATCH` 分开使用。 ## 2. 创建会话与上传图片 @@ -81,7 +81,7 @@ AI 对话拼装仅保留以上 7 个接口。原 `confirm`、`rematch`、按 `ma } ``` -图片仅能用于所属会话,一个附件只能绑定一条新消息。重复发送同一 `messageId` 无需重复上传;后续图片消息请重新上传附件。原图可用返回的 `previewUrl` 展示,仍需携带 Cookie。 +图片仅能用于所属会话,一个附件只能绑定一条新消息。重复发送同一 `messageId` 无需重复上传;后续图片消息请重新上传附件。原图通过返回的 `previewUrl` 用 fetch 携带认证头获取 Blob,再使用 `URL.createObjectURL` 展示,释放时调用 `URL.revokeObjectURL`;示例见[登录文档](auth-api.md#2-前端调用与需求归属)。 ## 3. 发送消息并直接生成 @@ -139,11 +139,10 @@ data:{"code":"OK","message":"success","data":{"analysisId":"DN-22222222222222222 使用 fetch 接收 POST SSE(`EventSource` 不支持 POST): ```javascript -async function sendMessage(conversationId, message, onEvent, signal) { +async function sendMessage(token, conversationId, message, onEvent, signal) { const response = await fetch(`/api/robot-conversations/${conversationId}/messages`, { method: "POST", - credentials: "include", - headers: { "Content-Type": "application/json", "Accept": "text/event-stream" }, + headers: { "Content-Type": "application/json", "Accept": "text/event-stream", "Authorization": `Bearer ${token}` }, body: JSON.stringify(message), signal }); @@ -993,7 +992,7 @@ async function sendMessage(conversationId, message, onEvent, signal) { 替代候选组包含目标 `instanceId`;仅替换对应实例,应用该候选返回的完整 `assembly`、`totals` 和校验结果。多个同类型实例分别有替代组,不按 category 整批替换;多个替代预览不能直接叠加。第 4 节提供包含分组外层的完整示例。 -加载模型时保留 URDF 相对路径目录;OSS/CDN 须允许前端 CORS。每个实例都独立摆放,资源 URL 可以复用或缓存;用户需求图片继续使用需要 Cookie 的私有预览接口。 +加载模型时保留 URDF 相对路径目录;OSS/CDN 须允许前端 CORS。每个实例都独立摆放,资源 URL 可以复用或缓存;用户需求图片继续使用需要 Bearer Token 的私有预览接口。 AI 接口与结构化 `POST /api/robot-matches` 共用选件连接规则,但返回包装不同:AI 使用 `components[].instanceId={matchId}:{category}:{序号}` 和 `assembly.connections[]`;结构化接口使用 `parts[].instanceId={category}:{序号}` 和顶层 `connections[]`,详见 [结构化接口文档](api.md)。 @@ -1017,7 +1016,7 @@ AI 接口与结构化 `POST /api/robot-matches` 共用选件连接规则,但 | HTTP / 错误码 | 前端处理 | | --- | --- | | 422 `INVALID_REQUEST` / `DEMAND_INPUT_TOO_LARGE` | 修正输入或新建会话 | -| 404 `DEMAND_NOT_FOUND` | 无记录、已过期或不属于当前访客;新建会话 | +| 404 `DEMAND_NOT_FOUND` | 无记录、已过期或不属于当前用户;新建会话 | | 409 `DEMAND_REVISION_CONFLICT` | 查询最新生成结果并使用其版本;重复消息编号内容须一致 | | SSE `COMPONENT_REVISION_CONFLICT` | 生成期间组件已变化,发送新消息重新生成 | | 409 `DEMAND_ATTACHMENT_MISSING` | 原图已失效,重新上传并发送新消息 | diff --git a/cadworld-api/pom.xml b/cadworld-api/pom.xml index 4b65a13..01e11a6 100644 --- a/cadworld-api/pom.xml +++ b/cadworld-api/pom.xml @@ -16,6 +16,11 @@ cadworld-api + + com.linkerbot + cadworld-security-api + ${project.version} + com.linkerbot cadworld-service @@ -31,6 +36,11 @@ h2 test + + org.springframework.security + spring-security-test + test + diff --git a/cadworld-api/src/main/java/com/linkerbot/cadworld/api/ApiApplication.java b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/ApiApplication.java index f7d34dd..c771333 100644 --- a/cadworld-api/src/main/java/com/linkerbot/cadworld/api/ApiApplication.java +++ b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/ApiApplication.java @@ -9,12 +9,14 @@ import com.linkerbot.cadworld.service.impl.ObjectStorageUrlResolver; import org.mybatis.spring.annotation.MapperScan; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Import; -@SpringBootApplication(scanBasePackages = { +@SpringBootApplication(exclude = UserDetailsServiceAutoConfiguration.class, scanBasePackages = { "com.linkerbot.cadworld.api", "com.linkerbot.cadworld.common", - "com.linkerbot.cadworld.service.matching" + "com.linkerbot.cadworld.service.matching", "com.linkerbot.cadworld.service.auth", + "com.linkerbot.cadworld.security.api" }) @EnableConfigurationProperties({StorageProperties.class, MatchingProperties.class, DemandProperties.class}) @Import({MybatisPlusConfig.class, ObjectStorageUrlResolver.class}) diff --git a/cadworld-api/src/main/java/com/linkerbot/cadworld/api/config/DemandConfiguration.java b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/config/DemandConfiguration.java index 9011f0c..30e3006 100644 --- a/cadworld-api/src/main/java/com/linkerbot/cadworld/api/config/DemandConfiguration.java +++ b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/config/DemandConfiguration.java @@ -58,7 +58,7 @@ public class DemandConfiguration { if (allowed.length == 0) return; for (String origin : allowed) if (origin.contains("*")) throw new IllegalArgumentException("需求接口凭证跨域必须配置具体前端域名"); registry.addMapping("/api/**").allowedOrigins(allowed).allowedMethods("GET", "POST", "DELETE", "OPTIONS") - .allowedHeaders("Content-Type", "X-Request-Id").exposedHeaders("X-Request-Id").allowCredentials(true).maxAge(3600); + .allowedHeaders("Content-Type", "X-Request-Id", "Authorization").exposedHeaders("X-Request-Id").allowCredentials(true).maxAge(3600); log.info("用户接口跨域配置已启用 path=/api/** allowedOrigins={}", List.of(allowed)); } }; diff --git a/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/AuthController.java b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/AuthController.java new file mode 100644 index 0000000..147db02 --- /dev/null +++ b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/AuthController.java @@ -0,0 +1,62 @@ +package com.linkerbot.cadworld.api.controller; + +import com.linkerbot.cadworld.common.api.ApiResponse; +import com.linkerbot.cadworld.common.api.RequestIdHolder; +import com.linkerbot.cadworld.dto.auth.CaptchaResponse; +import com.linkerbot.cadworld.dto.auth.LoginRequest; +import com.linkerbot.cadworld.dto.auth.LoginResponse; +import com.linkerbot.cadworld.dto.auth.LoginUserResponse; +import com.linkerbot.cadworld.entity.SysUser; +import com.linkerbot.cadworld.security.api.CurrentUser; +import com.linkerbot.cadworld.security.common.AuthProperties; +import com.linkerbot.cadworld.security.common.CaptchaService; +import com.linkerbot.cadworld.security.common.TokenService; +import com.linkerbot.cadworld.service.auth.LoginUserService; +import jakarta.servlet.http.HttpServletResponse; +import jakarta.validation.Valid; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.http.HttpHeaders; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestHeader; +import org.springframework.web.bind.annotation.RestController; + +@Slf4j +@RestController +@RequiredArgsConstructor +public class AuthController { + private final CaptchaService captcha; + private final TokenService tokens; + private final LoginUserService users; + private final AuthProperties properties; + + @GetMapping("/api/auth/captcha") + public ApiResponse captcha(HttpServletResponse response) { + response.setHeader(HttpHeaders.CACHE_CONTROL, "no-store"); + return ApiResponse.success(captcha.issue()); + } + + @PostMapping("/api/auth/login") + public ApiResponse login(@Valid @RequestBody LoginRequest input, HttpServletResponse response) { + response.setHeader(HttpHeaders.CACHE_CONTROL, "no-store"); + captcha.verify(input.captchaCode(), input.captchaAnswer()); + SysUser user = users.login(input.email()); + return ApiResponse.success(new LoginResponse(tokens.issue(user.getUserCode()), "Bearer", + properties.tokenTtl().toSeconds(), users.view(user))); + } + + @PostMapping("/api/auth/logout") + public ApiResponse logout(@RequestHeader(HttpHeaders.AUTHORIZATION) String authorization) { + String userCode = CurrentUser.required(); + tokens.revoke(authorization.substring(7)); + log.info("用户退出登录 userCode={} requestId={}", userCode, RequestIdHolder.get()); + return ApiResponse.success(null); + } + + @GetMapping("/api/users/me") + public ApiResponse me() { + return ApiResponse.success(users.view(users.requireActive(CurrentUser.required()))); + } +} diff --git a/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/DemandOwner.java b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/DemandOwner.java index 70b35e6..72f24da 100644 --- a/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/DemandOwner.java +++ b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/DemandOwner.java @@ -1,37 +1,21 @@ package com.linkerbot.cadworld.api.controller; -import com.linkerbot.cadworld.config.DemandProperties; -import jakarta.servlet.http.Cookie; -import jakarta.servlet.http.HttpServletRequest; -import jakarta.servlet.http.HttpServletResponse; +import com.linkerbot.cadworld.security.api.CurrentUser; import java.nio.charset.StandardCharsets; import java.security.MessageDigest; -import java.security.SecureRandom; -import java.util.Base64; +import java.security.NoSuchAlgorithmException; import java.util.HexFormat; -import lombok.RequiredArgsConstructor; -import org.springframework.http.HttpHeaders; -import org.springframework.http.ResponseCookie; import org.springframework.stereotype.Component; -/** 当前无账号登录,以高熵 HttpOnly 匿名会话 Cookie 隔离各访客的需求和图片。 */ +/** 仅使用服务端认证主体确定归属;历史匿名 Cookie 不参与账号会话访问。 */ @Component -@RequiredArgsConstructor public class DemandOwner { - private static final SecureRandom RANDOM = new SecureRandom(); - private final DemandProperties properties; - - public String resolve(HttpServletRequest request, HttpServletResponse response) { - String token = null; - Cookie[] cookies = request.getCookies(); - if (cookies != null) for (Cookie cookie : cookies) if ("cadworld_demand_visitor".equals(cookie.getName()) && cookie.getValue().matches("[A-Za-z0-9_-]{43}")) token = cookie.getValue(); - if (token == null) { - byte[] bytes = new byte[32]; RANDOM.nextBytes(bytes); - token = Base64.getUrlEncoder().withoutPadding().encodeToString(bytes); + public String resolve() { + try { + byte[] owner = ("user:" + CurrentUser.required()).getBytes(StandardCharsets.US_ASCII); + return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(owner)); + } catch (NoSuchAlgorithmException exception) { + throw new IllegalStateException("SHA-256 unavailable", exception); } - response.addHeader(HttpHeaders.SET_COOKIE, ResponseCookie.from("cadworld_demand_visitor", token).httpOnly(true) - .secure(properties.secureCookie() || request.isSecure()).sameSite("Lax").path("/api").maxAge(properties.retention()).build().toString()); - try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(token.getBytes(StandardCharsets.US_ASCII))); } - catch (Exception exception) { throw new IllegalStateException("SHA-256 unavailable"); } } } diff --git a/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/RobotDemandController.java b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/RobotDemandController.java index 0ca0403..1e10174 100644 --- a/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/RobotDemandController.java +++ b/cadworld-api/src/main/java/com/linkerbot/cadworld/api/controller/RobotDemandController.java @@ -7,7 +7,6 @@ import com.linkerbot.cadworld.dto.demand.DemandMessageRequest; import com.linkerbot.cadworld.service.demand.DemandAnalysisService; import com.linkerbot.cadworld.service.demand.DemandAttachmentStore; import com.linkerbot.cadworld.service.demand.DemandRepository; -import jakarta.servlet.http.HttpServletRequest; import jakarta.servlet.http.HttpServletResponse; import jakarta.validation.Valid; import jakarta.validation.constraints.NotBlank; @@ -42,51 +41,49 @@ public class RobotDemandController { private final DemandAnalysisService analyses; @PostMapping("/robot-conversations") - public ApiResponse create(HttpServletRequest request, HttpServletResponse response) { - DemandRepository.Conversation conversation = repository.create(owners.resolve(request, response)); + public ApiResponse create() { + DemandRepository.Conversation conversation = repository.create(owners.resolve()); log.info("需求会话创建 requestId={} conversationId={}", RequestIdHolder.get(), conversation.conversationId()); return ApiResponse.success(conversation); } @PostMapping(value = "/robot-conversations/{conversationId}/attachments", consumes = MediaType.MULTIPART_FORM_DATA_VALUE) - public ApiResponse upload(@PathVariable @NotBlank String conversationId, @RequestPart("file") MultipartFile file, - HttpServletRequest request, HttpServletResponse response) throws IOException { + public ApiResponse upload(@PathVariable @NotBlank String conversationId, @RequestPart("file") MultipartFile file) throws IOException { if (file.getSize() > 8 * 1024 * 1024) throw new BizException(422, "INVALID_REQUEST", "每张图片不能超过8MiB"); - DemandRepository.Attachment saved = attachments.upload(conversationId, owners.resolve(request, response), file.getBytes(), file.getContentType()); + DemandRepository.Attachment saved = attachments.upload(conversationId, owners.resolve(), file.getBytes(), file.getContentType()); log.info("需求图片保存 requestId={} conversationId={} attachmentId={} sizeBytes={}", RequestIdHolder.get(), conversationId, saved.attachmentId(), saved.sizeBytes()); return ApiResponse.success(new AttachmentView(saved.attachmentId(), saved.mimeType(), saved.sizeBytes(), "/api/robot-conversations/" + conversationId + "/attachments/" + saved.attachmentId())); } @GetMapping("/robot-conversations/{conversationId}/attachments/{attachmentId}") - public ResponseEntity image(@PathVariable @NotBlank String conversationId, @PathVariable @NotBlank String attachmentId, - HttpServletRequest request, HttpServletResponse response) { - DemandRepository.Attachment file = repository.attachment(conversationId, owners.resolve(request, response), attachmentId); + public ResponseEntity image(@PathVariable @NotBlank String conversationId, @PathVariable @NotBlank String attachmentId) { + DemandRepository.Attachment file = repository.attachment(conversationId, owners.resolve(), attachmentId); return ResponseEntity.ok().cacheControl(CacheControl.noStore()).contentType(MediaType.parseMediaType(file.mimeType())) .header("X-Content-Type-Options", "nosniff").body(attachments.read(file)); } @PostMapping(value = "/robot-conversations/{conversationId}/messages", produces = MediaType.TEXT_EVENT_STREAM_VALUE) public SseEmitter message(@PathVariable @NotBlank String conversationId, @Valid @RequestBody DemandMessageRequest input, - HttpServletRequest request, HttpServletResponse response) { + HttpServletResponse response) { response.setHeader("Cache-Control", "no-cache"); response.setHeader("X-Accel-Buffering", "no"); - return analyses.submit(conversationId, owners.resolve(request, response), input); + return analyses.submit(conversationId, owners.resolve(), input); } @GetMapping("/robot-analyses/{analysisId}") - public ApiResponse analysis(@PathVariable @NotBlank String analysisId, HttpServletRequest request, HttpServletResponse response) { + public ApiResponse analysis(@PathVariable @NotBlank String analysisId, HttpServletResponse response) { response.setHeader("Cache-Control", "no-store"); - return ApiResponse.success(analyses.get(analysisId, owners.resolve(request, response))); + return ApiResponse.success(analyses.get(analysisId, owners.resolve())); } @PostMapping(value = "/robot-analyses/{analysisId}/retry", produces = MediaType.TEXT_EVENT_STREAM_VALUE) - public SseEmitter retry(@PathVariable @NotBlank String analysisId, HttpServletRequest request, HttpServletResponse response) { + public SseEmitter retry(@PathVariable @NotBlank String analysisId, HttpServletResponse response) { response.setHeader("Cache-Control", "no-cache"); response.setHeader("X-Accel-Buffering", "no"); - return analyses.retry(analysisId, owners.resolve(request, response)); + return analyses.retry(analysisId, owners.resolve()); } @DeleteMapping("/robot-analyses/{analysisId}") - public ApiResponse cancel(@PathVariable @NotBlank String analysisId, HttpServletRequest request, HttpServletResponse response) { - return ApiResponse.success(analyses.cancel(analysisId, owners.resolve(request, response))); + public ApiResponse cancel(@PathVariable @NotBlank String analysisId) { + return ApiResponse.success(analyses.cancel(analysisId, owners.resolve())); } public record AttachmentView(String attachmentId, String mimeType, long sizeBytes, String previewUrl) { } diff --git a/cadworld-api/src/main/resources/application.yml b/cadworld-api/src/main/resources/application.yml index 16821af..fae8a51 100644 --- a/cadworld-api/src/main/resources/application.yml +++ b/cadworld-api/src/main/resources/application.yml @@ -25,6 +25,9 @@ mybatis-plus: configuration: map-underscore-to-camel-case: true app: + auth: + captcha-ttl: ${APP_AUTH_CAPTCHA_TTL:PT2M} + token-ttl: ${APP_AUTH_TOKEN_TTL:PT24H} demand: api-key: ${ARK_API_KEY:} model: ${ARK_MODEL:doubao-seed-2-1-lite-260915} diff --git a/cadworld-api/src/test/java/com/linkerbot/cadworld/api/ApiAuthTestSupport.java b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/ApiAuthTestSupport.java new file mode 100644 index 0000000..8fd476c --- /dev/null +++ b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/ApiAuthTestSupport.java @@ -0,0 +1,30 @@ +package com.linkerbot.cadworld.api; + +import com.linkerbot.cadworld.security.common.TokenService; +import com.linkerbot.cadworld.service.auth.LoginUserService; +import java.util.UUID; +import org.springframework.jdbc.core.JdbcTemplate; + +final class ApiAuthTestSupport { + private ApiAuthTestSupport() { + } + + static void createSchema(JdbcTemplate jdbc) { + jdbc.execute(""" + CREATE TABLE IF NOT EXISTS sys_user ( + id BIGINT AUTO_INCREMENT PRIMARY KEY, + user_code CHAR(32) NOT NULL UNIQUE, + email VARCHAR(254) NOT NULL UNIQUE, + nickname VARCHAR(64) NOT NULL DEFAULT '', + status VARCHAR(32) NOT NULL DEFAULT 'ACTIVE', + user_type VARCHAR(32) NOT NULL DEFAULT 'NORMAL', + created_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP) + """); + jdbc.update("DELETE FROM sys_user"); + } + + static String token(LoginUserService users, TokenService tokens) { + return tokens.issue(users.login(UUID.randomUUID() + "@example.test").getUserCode()); + } +} diff --git a/cadworld-api/src/test/java/com/linkerbot/cadworld/api/AuthApiTest.java b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/AuthApiTest.java new file mode 100644 index 0000000..6d37b08 --- /dev/null +++ b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/AuthApiTest.java @@ -0,0 +1,247 @@ +package com.linkerbot.cadworld.api; + +import ch.qos.logback.classic.Logger; +import ch.qos.logback.classic.spi.ILoggingEvent; +import ch.qos.logback.core.read.ListAppender; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.linkerbot.cadworld.security.common.AuthProperties; +import com.linkerbot.cadworld.security.common.CaptchaService; +import com.linkerbot.cadworld.service.auth.LoginUserService; +import jakarta.servlet.http.Cookie; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.context.TestConfiguration; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Import; +import org.springframework.context.annotation.Primary; +import org.springframework.dao.DataAccessResourceFailureException; +import org.springframework.http.HttpHeaders; +import org.springframework.http.MediaType; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.test.context.bean.override.mockito.MockitoSpyBean; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.MvcResult; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.doThrow; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.options; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +@SpringBootTest(classes = ApiApplication.class, properties = { + "spring.datasource.url=jdbc:h2:mem:auth;MODE=MySQL;DB_CLOSE_DELAY=-1", + "spring.datasource.driver-class-name=org.h2.Driver", "spring.datasource.username=sa", "spring.datasource.password=", + "app.storage.public-base-url=https://models.example.test", "logging.file.path=target/test-logs", + "logging.level.com.linkerbot.cadworld=DEBUG", "app.demand.allowed-origins=http://localhost:5173" +}) +@AutoConfigureMockMvc(print = org.springframework.boot.test.autoconfigure.web.servlet.MockMvcPrint.NONE) +@Import(AuthApiTest.CaptchaConfiguration.class) +class AuthApiTest { + private static final String ORIGIN = "http://localhost:5173"; + @Autowired private MockMvc mvc; + @Autowired private JdbcTemplate jdbc; + @Autowired private ObjectMapper json; + @MockitoSpyBean private LoginUserService users; + + @BeforeEach + void prepare() { + assertThat(jdbc.execute((org.springframework.jdbc.core.ConnectionCallback) connection -> + connection.getMetaData().getDatabaseProductName())).isEqualTo("H2"); + ApiAuthTestSupport.createSchema(jdbc); + } + + @Test + void firstLoginNormalizesEmailAndMeDoesNotExposeDatabaseId() throws Exception { + JsonNode first = login(" USER@EXAMPLE.TEST "); + JsonNode second = login("user@example.test"); + assertThat(first.path("tokenType").asText()).isEqualTo("Bearer"); + assertThat(first.path("expiresIn").asLong()).isEqualTo(86400); + assertThat(first.path("user").path("userCode").asText()).matches("[A-F0-9]{32}"); + assertThat(first.path("user").path("email").asText()).isEqualTo("user@example.test"); + assertThat(first.path("user").size()).isEqualTo(3); + assertThat(first.path("user")).isEqualTo(second.path("user")); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_user", Long.class)).isEqualTo(1); + mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(first))) + .andExpect(status().isOk()).andExpect(jsonPath("$.data.id").doesNotExist()) + .andExpect(jsonPath("$.data.email").value("user@example.test")) + .andExpect(jsonPath("$.data.userCode").value(first.path("user").path("userCode").asText())) + .andExpect(header().doesNotExist(HttpHeaders.SET_COOKIE)); + mvc.perform(get("/api/users/me")).andExpect(status().isUnauthorized()); + } + + @Test + void wrongCaptchaIsConsumedAndInvalidInputCannotCreateUsers() throws Exception { + String code = captcha(); + mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON) + .content(body("user@example.test", code, "WRONG"))) + .andExpect(status().isBadRequest()).andExpect(jsonPath("$.code").value("CAPTCHA_INVALID")); + mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON) + .content(body("user@example.test", code, "ABCDE"))) + .andExpect(status().isBadRequest()); + for (String email : List.of("", "not-an-email", "a".repeat(255) + "@example.test")) { + mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON) + .content(body(email, captcha(), "ABCDE"))) + .andExpect(status().isUnprocessableEntity()).andExpect(jsonPath("$.code").value("INVALID_REQUEST")); + } + mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON) + .content("{\"email\":\"user@example.test\",\"captchaCode\":\"x\",\"captchaAnswer\":\"ABCDE\",\"userType\":\"ADMIN\"}")) + .andExpect(status().isUnprocessableEntity()); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_user", Long.class)).isZero(); + } + + @Test + void logoutRevokesOnlyCurrentSession() throws Exception { + JsonNode first = login("user@example.test"); + JsonNode second = login("user@example.test"); + mvc.perform(post("/api/auth/logout").header(HttpHeaders.AUTHORIZATION, bearer(first))).andExpect(status().isOk()); + mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(first))) + .andExpect(status().isUnauthorized()).andExpect(jsonPath("$.code").value("UNAUTHORIZED")); + mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(second))).andExpect(status().isOk()); + mvc.perform(post("/api/auth/logout").header(HttpHeaders.AUTHORIZATION, bearer(first))).andExpect(status().isUnauthorized()); + } + + @Test + void disablingUserRejectsLoginAndExistingTokensImmediately() throws Exception { + JsonNode user = login("user@example.test"); + jdbc.update("UPDATE sys_user SET status='DISABLED'"); + mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(user))) + .andExpect(status().isUnauthorized()).andExpect(jsonPath("$.code").value("UNAUTHORIZED")); + mvc.perform(post("/api/auth/login").header(HttpHeaders.ORIGIN, ORIGIN).contentType(MediaType.APPLICATION_JSON) + .content(body("user@example.test", captcha(), "ABCDE"))) + .andExpect(status().isForbidden()).andExpect(jsonPath("$.code").value("ACCOUNT_DISABLED")) + .andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN)); + } + + @Test + void allBusinessRoutesRequireAuthenticationAndAnonymousCookieHasNoAuthority() throws Exception { + for (String path : List.of("/api/users/me", "/api/components/CW-A", "/api/robot-analyses/test", + "/api/robot-conversations/test/attachments/test")) { + mvc.perform(get(path).cookie(new Cookie("cadworld_demand_visitor", "A".repeat(43)))) + .andExpect(status().isUnauthorized()).andExpect(jsonPath("$.code").value("UNAUTHORIZED")); + } + for (String path : List.of("/api/robot-matches", "/api/robot-conversations", "/api/auth/logout", + "/api/robot-conversations/test/attachments", "/api/robot-conversations/test/messages", "/api/robot-analyses/test/retry")) { + mvc.perform(post(path)).andExpect(status().isUnauthorized()); + } + mvc.perform(delete("/api/robot-analyses/test")).andExpect(status().isUnauthorized()); + for (String value : List.of("Bearer invalid", "Basic invalid", "Bearer ")) { + mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, value).header("X-Request-Id", "auth-invalid")) + .andExpect(status().isUnauthorized()).andExpect(jsonPath("$.requestId").value("auth-invalid")); + } + mvc.perform(get("/api/auth/captcha").header(HttpHeaders.AUTHORIZATION, "Bearer stale")) + .andExpect(status().isOk()).andExpect(header().string(HttpHeaders.CACHE_CONTROL, "no-store")); + } + + @Test + void corsPreflightAndAuthenticationErrorsKeepCorsHeaders() throws Exception { + mvc.perform(options("/api/robot-matches").header(HttpHeaders.ORIGIN, ORIGIN) + .header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "POST") + .header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "authorization,content-type,x-request-id")) + .andExpect(status().isOk()).andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN)); + mvc.perform(get("/api/users/me").header(HttpHeaders.ORIGIN, ORIGIN)) + .andExpect(status().isUnauthorized()).andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN)); + mvc.perform(get("/api/users/me").header(HttpHeaders.ORIGIN, ORIGIN).header(HttpHeaders.AUTHORIZATION, "Bearer invalid")) + .andExpect(status().isUnauthorized()).andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, ORIGIN)); + mvc.perform(options("/api/robot-matches").header(HttpHeaders.ORIGIN, "https://untrusted.example") + .header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "POST")) + .andExpect(status().isForbidden()).andExpect(header().doesNotExist(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN)); + } + + @Test + void authenticationDatabaseFailureUsesExistingErrorEnvelope() throws Exception { + JsonNode login = login("user@example.test"); + doThrow(new DataAccessResourceFailureException("test unavailable")).when(users) + .requireActive(login.path("user").path("userCode").asText()); + mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, bearer(login)).header("X-Request-Id", "auth-database")) + .andExpect(status().isServiceUnavailable()).andExpect(jsonPath("$.code").value("DATABASE_UNAVAILABLE")) + .andExpect(jsonPath("$.requestId").value("auth-database")); + } + + @Test + void concurrentFirstLoginsCreateExactlyOneUser() throws Exception { + CountDownLatch start = new CountDownLatch(1); + List> results = new ArrayList<>(); + Set codes = new HashSet<>(); + try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) { + for (int index = 0; index < 10; index++) results.add(executor.submit(() -> { + start.await(); + return users.login(" RACE@EXAMPLE.TEST ").getUserCode(); + })); + start.countDown(); + for (Future result : results) codes.add(result.get(10, TimeUnit.SECONDS)); + } + assertThat(codes).hasSize(1); + assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM sys_user", Long.class)).isEqualTo(1); + } + + @Test + void authenticationLogsDoNotContainCredentialsOrEmail() throws Exception { + Logger logger = (Logger) LoggerFactory.getLogger("com.linkerbot.cadworld"); + ListAppender capture = new ListAppender<>(); + capture.start(); + logger.addAppender(capture); + try { + String code = captcha(); + JsonNode login = data(mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON) + .content(body("private.email@example.test", code, "ABCDE"))).andExpect(status().isOk()).andReturn()); + mvc.perform(post("/api/auth/logout").header(HttpHeaders.AUTHORIZATION, bearer(login))).andExpect(status().isOk()); + mvc.perform(get("/api/users/me").header(HttpHeaders.AUTHORIZATION, "Bearer PRIVATE_TOKEN")).andExpect(status().isUnauthorized()); + mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON) + .content(body("private.email@example.test", captcha(), "PRIVATE_ANSWER"))).andExpect(status().isBadRequest()); + String logs = String.join("\n", capture.list.stream().map(ILoggingEvent::getFormattedMessage).toList()); + assertThat(logs).contains("用户登录成功", "用户退出登录", "CAPTCHA_INVALID", "UNAUTHORIZED"); + assertThat(logs).doesNotContain("private.email@example.test", "PRIVATE_TOKEN", "PRIVATE_ANSWER", "ABCDE", + code, login.path("token").asText(), "data:image/png;base64,"); + } finally { + logger.detachAppender(capture); + capture.stop(); + } + } + + private String captcha() throws Exception { + return data(mvc.perform(get("/api/auth/captcha")).andExpect(status().isOk()).andReturn()).path("captchaCode").asText(); + } + + private JsonNode login(String email) throws Exception { + return data(mvc.perform(post("/api/auth/login").contentType(MediaType.APPLICATION_JSON) + .content(body(email, captcha(), "abcde"))).andExpect(status().isOk()) + .andExpect(header().string(HttpHeaders.CACHE_CONTROL, "no-store")).andReturn()); + } + + private String body(String email, String code, String answer) throws Exception { + return json.writeValueAsString(Map.of("email", email, "captchaCode", code, "captchaAnswer", answer)); + } + + private String bearer(JsonNode login) { return "Bearer " + login.path("token").asText(); } + private JsonNode data(MvcResult result) throws Exception { return json.readTree(result.getResponse().getContentAsByteArray()).path("data"); } + + @TestConfiguration(proxyBeanMethods = false) + static class CaptchaConfiguration { + @Bean + @Primary + CaptchaService fixedAnswerCaptcha(AuthProperties properties) { + return new CaptchaService(properties) { + @Override protected String generateAnswer() { return "ABCDE"; } + }; + } + } +} diff --git a/cadworld-api/src/test/java/com/linkerbot/cadworld/api/DemandFlowApiTest.java b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/DemandFlowApiTest.java index 053022b..f4c0302 100644 --- a/cadworld-api/src/test/java/com/linkerbot/cadworld/api/DemandFlowApiTest.java +++ b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/DemandFlowApiTest.java @@ -3,10 +3,12 @@ package com.linkerbot.cadworld.api; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.node.ObjectNode; +import com.linkerbot.cadworld.common.web.RequestIdFilter; +import com.linkerbot.cadworld.security.common.TokenService; +import com.linkerbot.cadworld.service.auth.LoginUserService; +import com.linkerbot.cadworld.service.demand.DemandMatchService; import com.linkerbot.cadworld.service.demand.DemandMessage; import com.linkerbot.cadworld.service.demand.DemandModelClient; -import com.linkerbot.cadworld.service.demand.DemandMatchService; -import jakarta.servlet.http.Cookie; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; @@ -34,12 +36,15 @@ import org.springframework.test.context.bean.override.mockito.MockitoBean; import org.springframework.test.context.bean.override.mockito.MockitoSpyBean; import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MvcResult; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.context.WebApplicationContext; import org.springframework.web.method.HandlerMethod; import org.springframework.web.servlet.mvc.method.RequestMappingInfo; import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping; import static org.assertj.core.api.Assertions.assertThat; +import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity; import static org.mockito.ArgumentMatchers.anyList; import static org.mockito.Mockito.when; import static org.mockito.Mockito.doAnswer; @@ -62,6 +67,9 @@ class DemandFlowApiTest { private static final String TEXT = "我要机器人躯干和右臂,整体4自由度,质量不超过4kg,右臂扭矩至少20N·m"; private static final Path DIRECTORY = directory(); @Autowired private MockMvc mvc; + @Autowired private WebApplicationContext webContext; + @Autowired private LoginUserService loginUsers; + @Autowired private TokenService tokens; @Autowired private ObjectMapper json; @Autowired private JdbcTemplate jdbc; @Autowired private com.linkerbot.cadworld.service.demand.DemandRepository repository; @@ -97,6 +105,10 @@ class DemandFlowApiTest { """); for (String table : List.of("robot_demand_match", "robot_demand_analysis", "robot_demand_message", "robot_demand_attachment", "robot_demand_conversation", "component")) jdbc.update("DELETE FROM " + table); when(model.analyze(anyList())).thenAnswer(invocation -> raw(invocation.getArgument(0))); + ApiAuthTestSupport.createSchema(jdbc); + mvc = MockMvcBuilders.webAppContextSetup(webContext).apply(springSecurity()) + .addFilters(new RequestIdFilter()) + .defaultRequest(get("/").header("Authorization", "Bearer " + ApiAuthTestSupport.token(loginUsers, tokens))).build(); } @Test void demandControllerExposesExactlySevenRoutesAndRemovedEndpointsReturn404() throws Exception { @@ -120,12 +132,12 @@ class DemandFlowApiTest { String analysisId = generated.path("analysisId").asText(); String matchId = generated.path("match").path("matchId").asText(); for (String action : List.of("confirm", "rematch")) { - mvc.perform(post("/api/robot-analyses/" + analysisId + "/" + action).cookie(session.cookie()) + mvc.perform(post("/api/robot-analyses/" + analysisId + "/" + action).header("Authorization", "Bearer " + session.token()) .contentType(MediaType.APPLICATION_JSON).content("{\"revision\":1,\"confirmed\":true}")) .andExpect(status().isNotFound()); } - mvc.perform(get("/api/robot-demand-matches/" + matchId).cookie(session.cookie())).andExpect(status().isNotFound()); - mvc.perform(post("/api/robot-demand-matches/" + matchId + "/accept-degradation").cookie(session.cookie()) + mvc.perform(get("/api/robot-demand-matches/" + matchId).header("Authorization", "Bearer " + session.token())).andExpect(status().isNotFound()); + mvc.perform(post("/api/robot-demand-matches/" + matchId + "/accept-degradation").header("Authorization", "Bearer " + session.token()) .contentType(MediaType.APPLICATION_JSON).content("{\"revision\":1,\"accepted\":true}")) .andExpect(status().isNotFound()); } @@ -170,11 +182,11 @@ class DemandFlowApiTest { assertThat(alternate.path("component").path("urdfInfo").path("rootLink").asText()).isEqualTo("ARM_V2_ROOT"); assertThat(alternate.path("assembly").path("connections").get(0).path("childRootLink").asText()).isEqualTo("ARM_V2_ROOT"); assertThat(generatedMatch(session, analysis, 1).path("matchId").asText()).isEqualTo(match.path("matchId").asText()); - JsonNode queried = data(mvc.perform(get("/api/robot-analyses/" + analysis).cookie(session.cookie())).andExpect(status().isOk()).andReturn()); + JsonNode queried = data(mvc.perform(get("/api/robot-analyses/" + analysis).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()).andReturn()); assertThat(queried.path("match")).isEqualTo(match); assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM robot_demand_match", Integer.class)).isEqualTo(1); assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM robot_demand_message WHERE message_role='assistant'", Integer.class)).isZero(); - mvc.perform(get("/api/robot-analyses/" + analysis).cookie(session.cookie())).andExpect(status().isOk()) + mvc.perform(get("/api/robot-analyses/" + analysis).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()) .andExpect(jsonPath("$.data.match.snapshot").doesNotExist()); } @@ -425,7 +437,7 @@ class DemandFlowApiTest { try { assertThat(selecting.await(5, TimeUnit.SECONDS)).isTrue(); String id = jdbc.queryForObject("SELECT analysis_code FROM robot_demand_analysis", String.class); - mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk()) + mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()) .andExpect(jsonPath("$.data.status").value("processing")) .andExpect(jsonPath("$.data.result").isEmpty()).andExpect(jsonPath("$.data.match").isEmpty()); assertThat(jdbc.queryForObject("SELECT result_json FROM robot_demand_analysis", String.class)).isEqualTo("{}"); @@ -445,7 +457,7 @@ class DemandFlowApiTest { mvc.perform(asyncDispatch(pending)).andExpect(status().isOk()); assertThat(pending.getResponse().getContentAsString()).contains("event:analysis.failed").doesNotContain("event:analysis.completed"); String id = jdbc.queryForObject("SELECT analysis_code FROM robot_demand_analysis", String.class); - mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk()) + mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()) .andExpect(jsonPath("$.data.status").value("failed")) .andExpect(jsonPath("$.data.result").isEmpty()).andExpect(jsonPath("$.data.match").isEmpty()); assertThat(jdbc.queryForObject("SELECT result_json FROM robot_demand_analysis", String.class)).isEqualTo("{}"); @@ -469,7 +481,7 @@ class DemandFlowApiTest { String id = jdbc.queryForObject("SELECT analysis_code FROM robot_demand_analysis", String.class); assertThat(jdbc.queryForObject("SELECT result_json FROM robot_demand_analysis", String.class)).isEqualTo("{}"); assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM robot_demand_match WHERE analysis_code=?", Integer.class, id)).isZero(); - mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk()) + mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()) .andExpect(jsonPath("$.data.status").value("failed")).andExpect(jsonPath("$.data.match").isEmpty()); } @@ -492,11 +504,11 @@ class DemandFlowApiTest { for (jakarta.servlet.AsyncListener listener : context.getListeners()) { listener.onError(new jakarta.servlet.AsyncEvent(context, pending.getRequest(), pending.getResponse(), new IOException("Stream disconnected"))); } - mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk()) + mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()) .andExpect(jsonPath("$.data.status").value("processing")); } finally { release.countDown(); } org.awaitility.Awaitility.await().atMost(5, TimeUnit.SECONDS).untilAsserted(() -> - mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk()) + mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()) .andExpect(jsonPath("$.data.status").value("ready")) .andExpect(jsonPath("$.data.match.components.length()").value(2))); org.mockito.Mockito.verify(model, org.mockito.Mockito.times(1)).analyze(anyList()); @@ -523,7 +535,7 @@ class DemandFlowApiTest { assertThat(current.path("revision").asInt()).isEqualTo(2); assertThat(current.path("match").path("assembly").path("status").asText()).isEqualTo("ready"); first.getAsyncResult(5000); - mvc.perform(get("/api/robot-analyses/" + old).cookie(session.cookie())).andExpect(status().isOk()) + mvc.perform(get("/api/robot-analyses/" + old).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()) .andExpect(jsonPath("$.data.status").value("superseded")).andExpect(jsonPath("$.data.match").isEmpty()); assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM robot_demand_match", Integer.class)).isEqualTo(1); assertThat(jdbc.queryForObject("SELECT revision FROM robot_demand_match", Integer.class)).isEqualTo(2); @@ -723,7 +735,7 @@ class DemandFlowApiTest { @Test void expiredConversationsCleanOnlyOwnedDemandRowsAndPrivateFiles() throws Exception { Session expired = create(); Session active = create(); - JsonNode file = data(mvc.perform(multipart("/api/robot-conversations/" + expired.id() + "/attachments").file(image()).cookie(expired.cookie())).andExpect(status().isOk()).andReturn()); + JsonNode file = data(mvc.perform(multipart("/api/robot-conversations/" + expired.id() + "/attachments").file(image()).header("Authorization", "Bearer " + expired.token())).andExpect(status().isOk()).andReturn()); Path saved = DIRECTORY.resolve(file.path("attachmentId").asText() + ".bin"); assertThat(saved).exists(); submit(expired, "m1", TEXT, List.of()); @@ -740,7 +752,7 @@ class DemandFlowApiTest { result.getAsyncResult(10000); mvc.perform(asyncDispatch(result)).andExpect(status().isOk()); assertThat(result.getResponse().getContentAsString()).contains("event:analysis.failed", "DEMAND_INVALID_OUTPUT").doesNotContain("伪造用户证据"); String analysis = jdbc.queryForObject("SELECT analysis_code FROM robot_demand_analysis WHERE conversation_code=?", String.class, session.id()); - mvc.perform(get("/api/robot-analyses/" + analysis).cookie(session.cookie())).andExpect(status().isOk()).andExpect(jsonPath("$.data.status").value("failed")).andExpect(jsonPath("$.data.result").isEmpty()); + mvc.perform(get("/api/robot-analyses/" + analysis).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()).andExpect(jsonPath("$.data.status").value("failed")).andExpect(jsonPath("$.data.result").isEmpty()); } @Test void newMessageInvalidatesOldRobotAndMessageReplayDoesNotCreateRevision() throws Exception { @@ -753,26 +765,62 @@ class DemandFlowApiTest { org.mockito.Mockito.verify(matches, org.mockito.Mockito.times(1)).match(org.mockito.ArgumentMatchers.anyString(), org.mockito.ArgumentMatchers.any()); assertThat(jdbc.queryForObject("SELECT revision FROM robot_demand_conversation WHERE conversation_code=?", Integer.class, session.id())).isEqualTo(1); submit(session, "m2", TEXT, List.of()); - mvc.perform(get("/api/robot-analyses/" + first.path("analysisId").asText()).cookie(session.cookie())) + mvc.perform(get("/api/robot-analyses/" + first.path("analysisId").asText()).header("Authorization", "Bearer " + session.token())) .andExpect(status().isOk()).andExpect(jsonPath("$.data.status").value("superseded")).andExpect(jsonPath("$.data.canSubmit").value(false)) .andExpect(jsonPath("$.data.result").isEmpty()).andExpect(jsonPath("$.data.match").isEmpty()); } - @Test void anonymousOwnersCannotAccessOtherVisitorsTasksOrAttachments() throws Exception { + @Test void accountsCannotAccessOtherUsersTasksOrAttachments() throws Exception { Session first = create(); Session other = create(); JsonNode analysis = submit(first, "m1", TEXT, List.of()); - mvc.perform(get("/api/robot-analyses/" + analysis.path("analysisId").asText()).cookie(other.cookie())).andExpect(status().isNotFound()); - mvc.perform(post("/api/robot-analyses/" + analysis.path("analysisId").asText() + "/retry").cookie(other.cookie())) + mvc.perform(get("/api/robot-analyses/" + analysis.path("analysisId").asText()).header("Authorization", "Bearer " + other.token())).andExpect(status().isNotFound()); + mvc.perform(post("/api/robot-analyses/" + analysis.path("analysisId").asText() + "/retry").header("Authorization", "Bearer " + other.token())) .andExpect(status().isNotFound()); - mvc.perform(delete("/api/robot-analyses/" + analysis.path("analysisId").asText()).cookie(other.cookie())) + mvc.perform(delete("/api/robot-analyses/" + analysis.path("analysisId").asText()).header("Authorization", "Bearer " + other.token())) .andExpect(status().isNotFound()); - mvc.perform(multipart("/api/robot-conversations/" + first.id() + "/attachments").file(image()).cookie(other.cookie())).andExpect(status().isNotFound()); + mvc.perform(multipart("/api/robot-conversations/" + first.id() + "/attachments").file(image()).header("Authorization", "Bearer " + other.token())).andExpect(status().isNotFound()); + } + + @Test void sameAccountCanAccessConversationAndImagesWithAnotherToken() throws Exception { + Session first = create(); + JsonNode file = data(mvc.perform(multipart("/api/robot-conversations/" + first.id() + "/attachments") + .file(image()).header("Authorization", "Bearer " + first.token())).andExpect(status().isOk()).andReturn()); + JsonNode analysis = submit(first, "m1", TEXT, List.of()); + String secondToken = tokens.issue(tokens.resolve(first.token())); + tokens.revoke(first.token()); + mvc.perform(get("/api/robot-analyses/" + analysis.path("analysisId").asText()) + .header("Authorization", "Bearer " + secondToken)) + .andExpect(status().isOk()).andExpect(jsonPath("$.data.analysisId").value(analysis.path("analysisId").asText())); + mvc.perform(get(file.path("previewUrl").asText()).header("Authorization", "Bearer " + secondToken)).andExpect(status().isOk()); + String owner = java.util.HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-256") + .digest(("user:" + tokens.resolve(secondToken)).getBytes(java.nio.charset.StandardCharsets.US_ASCII))); + assertThat(jdbc.queryForObject("SELECT owner_hash FROM robot_demand_conversation WHERE conversation_code=?", + String.class, first.id())).isEqualTo(owner); + } + + @Test void legacyAnonymousCookieDoesNotClaimHistoricalConversation() throws Exception { + String visitor = "A".repeat(43); + String owner = java.util.HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-256") + .digest(visitor.getBytes(java.nio.charset.StandardCharsets.US_ASCII))); + String conversation = repository.create(owner).conversationId(); + Session user = create(); + mvc.perform(get("/api/robot-conversations/" + conversation + "/attachments/DA-MISSING") + .cookie(new jakarta.servlet.http.Cookie("cadworld_demand_visitor", visitor)) + .header("Authorization", "Bearer " + user.token())) + .andExpect(status().isNotFound()); + mvc.perform(post("/api/robot-conversations/" + conversation + "/messages") + .cookie(new jakarta.servlet.http.Cookie("cadworld_demand_visitor", visitor)) + .header("Authorization", "Bearer " + user.token()).contentType(MediaType.APPLICATION_JSON) + .content(json.writeValueAsBytes(Map.of("messageId", "m1", "text", TEXT, "attachmentIds", List.of())))) + .andExpect(status().isNotFound()); + assertThat(jdbc.queryForObject("SELECT owner_hash FROM robot_demand_conversation WHERE conversation_code=?", + String.class, conversation)).isEqualTo(owner); } @Test void imageOnlyMessagesUseOwnedPrivateAttachmentsAndPreserveOcrSources() throws Exception { components(true, 20); Session session = create(); - MvcResult uploaded = mvc.perform(multipart("/api/robot-conversations/" + session.id() + "/attachments").file(image()).cookie(session.cookie())).andExpect(status().isOk()).andReturn(); + MvcResult uploaded = mvc.perform(multipart("/api/robot-conversations/" + session.id() + "/attachments").file(image()).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()).andReturn(); JsonNode file = data(uploaded); String id = file.path("attachmentId").asText(); doAnswer(invocation -> { @@ -790,8 +838,8 @@ class DemandFlowApiTest { assertThat(completed.path("match").path("assembly").path("status").asText()).isEqualTo("ready"); assertThat(completed.path("result").path("request").path("userInput").asText()).isEqualTo("[图片:" + id + "]"); assertThat(completed.path("result").path("analysis").path("observations").get(0).path("kind").asText()).isEqualTo("image_text"); - mvc.perform(get(file.path("previewUrl").asText()).cookie(session.cookie())).andExpect(status().isOk()); - mvc.perform(get(file.path("previewUrl").asText()).cookie(create().cookie())).andExpect(status().isNotFound()); + mvc.perform(get(file.path("previewUrl").asText()).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()); + mvc.perform(get(file.path("previewUrl").asText()).header("Authorization", "Bearer " + create().token())).andExpect(status().isNotFound()); } @Test void missingUnitsGeneratePartialAssemblyAndLaterUserEditsApplyWithoutQuestions() throws Exception { @@ -839,11 +887,11 @@ class DemandFlowApiTest { MvcResult pending = message(session, "m1", TEXT, List.of()); assertThat(entered.await(5, TimeUnit.SECONDS)).isTrue(); String id = jdbc.queryForObject("SELECT analysis_code FROM robot_demand_analysis WHERE conversation_code=?", String.class, session.id()); - mvc.perform(delete("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk()).andExpect(jsonPath("$.data.status").value("cancelled")).andExpect(jsonPath("$.data.canSubmit").value(false)); + mvc.perform(delete("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()).andExpect(jsonPath("$.data.status").value("cancelled")).andExpect(jsonPath("$.data.canSubmit").value(false)); assertThat(exited.await(5, TimeUnit.SECONDS)).isTrue(); pending.getAsyncResult(5000); doAnswer(invocation -> raw(invocation.getArgument(0))).when(model).analyze(anyList()); - MvcResult retry = mvc.perform(post("/api/robot-analyses/" + id + "/retry").cookie(session.cookie())).andExpect(status().isOk()).andReturn(); + MvcResult retry = mvc.perform(post("/api/robot-analyses/" + id + "/retry").header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()).andReturn(); JsonNode result = completed(retry); assertThat(result.path("analysisId").asText()).isEqualTo(id); assertThat(result.path("status").asText()).isEqualTo("ready"); @@ -880,31 +928,31 @@ class DemandFlowApiTest { JsonNode refreshed = regenerated.path("match"); assertThat(refreshed.path("matchId").asText()).isNotEqualTo(original.path("matchId").asText()); assertThat(refreshed.path("components").get(1).path("component").path("version").asInt()).isEqualTo(2); - mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie())).andExpect(status().isOk()) + mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())).andExpect(status().isOk()) .andExpect(jsonPath("$.data.status").value("superseded")).andExpect(jsonPath("$.data.match").isEmpty()); org.mockito.Mockito.verify(model, org.mockito.Mockito.times(2)).analyze(anyList()); } @Test void invalidPayloadsImagesAndPublicRuleDownloadsAreRejected() throws Exception { Session session = create(); - mvc.perform(post("/api/robot-conversations/" + session.id() + "/messages").cookie(session.cookie()).contentType(MediaType.APPLICATION_JSON).content("{\"messageId\":\"m1\",\"text\":\"abc\",\"role\":\"system\"}")) + mvc.perform(post("/api/robot-conversations/" + session.id() + "/messages").header("Authorization", "Bearer " + session.token()).contentType(MediaType.APPLICATION_JSON).content("{\"messageId\":\"m1\",\"text\":\"abc\",\"role\":\"system\"}")) .andExpect(status().isUnprocessableEntity()); - mvc.perform(post("/api/robot-conversations/" + session.id() + "/messages").cookie(session.cookie()).contentType(MediaType.APPLICATION_JSON).content("{\"messageId\":\"m1\",\"text\":\"\",\"attachmentIds\":[]}")) + mvc.perform(post("/api/robot-conversations/" + session.id() + "/messages").header("Authorization", "Bearer " + session.token()).contentType(MediaType.APPLICATION_JSON).content("{\"messageId\":\"m1\",\"text\":\"\",\"attachmentIds\":[]}")) .andExpect(status().isUnprocessableEntity()); - mvc.perform(multipart("/api/robot-conversations/" + session.id() + "/attachments").file(new MockMultipartFile("file", "fake.png", "image/png", "invalid".getBytes(java.nio.charset.StandardCharsets.UTF_8))).cookie(session.cookie())) + mvc.perform(multipart("/api/robot-conversations/" + session.id() + "/attachments").file(new MockMultipartFile("file", "fake.png", "image/png", "invalid".getBytes(java.nio.charset.StandardCharsets.UTF_8))).header("Authorization", "Bearer " + session.token())) .andExpect(status().isUnprocessableEntity()); for (String path : List.of("/robot-demand/system-prompt.txt", "/robot-demand/model-output.schema.json", "/robot-demand/part-catalog.json")) mvc.perform(get(path)).andExpect(status().isNotFound()); } private Session create() throws Exception { - MvcResult result = mvc.perform(post("/api/robot-conversations")).andExpect(status().isOk()).andReturn(); - String header = result.getResponse().getHeader("Set-Cookie"); - assertThat(header).contains("HttpOnly", "SameSite=Lax"); - String[] pair = header.substring(0, header.indexOf(';')).split("=", 2); - return new Session(data(result).path("conversationId").asText(), new Cookie(pair[0], pair[1])); + String token = ApiAuthTestSupport.token(loginUsers, tokens); + MvcResult result = mvc.perform(post("/api/robot-conversations").header("Authorization", "Bearer " + token)) + .andExpect(status().isOk()).andReturn(); + assertThat(result.getResponse().getHeader("Set-Cookie")).isNull(); + return new Session(data(result).path("conversationId").asText(), token); } private MvcResult message(Session session, String id, String text, List images) throws Exception { - return mvc.perform(post("/api/robot-conversations/" + session.id() + "/messages").cookie(session.cookie()).contentType(MediaType.APPLICATION_JSON) + return mvc.perform(post("/api/robot-conversations/" + session.id() + "/messages").header("Authorization", "Bearer " + session.token()).contentType(MediaType.APPLICATION_JSON) .content(json.writeValueAsBytes(Map.of("messageId", id, "text", text, "attachmentIds", images)))).andExpect(status().isOk()).andReturn(); } private JsonNode submit(Session session, String id, String text, List images) throws Exception { return completed(message(session, id, text, images)); } @@ -919,7 +967,7 @@ class DemandFlowApiTest { throw new AssertionError("No completed event: " + events); } private JsonNode generatedMatch(Session session, String id, int revision) throws Exception { - JsonNode generated = data(mvc.perform(get("/api/robot-analyses/" + id).cookie(session.cookie())) + JsonNode generated = data(mvc.perform(get("/api/robot-analyses/" + id).header("Authorization", "Bearer " + session.token())) .andExpect(status().isOk()).andReturn()); assertThat(generated.path("revision").asInt()).isEqualTo(revision); return generated.path("match"); @@ -1021,5 +1069,5 @@ class DemandFlowApiTest { try (java.util.stream.Stream paths = Files.list(DIRECTORY)) { for (Path path : paths.toList()) Files.deleteIfExists(path); } Files.deleteIfExists(DIRECTORY); } - private record Session(String id, Cookie cookie) { } + private record Session(String id, String token) { } } diff --git a/cadworld-api/src/test/java/com/linkerbot/cadworld/api/MatchingApiTest.java b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/MatchingApiTest.java index e948cba..73d4ccb 100644 --- a/cadworld-api/src/test/java/com/linkerbot/cadworld/api/MatchingApiTest.java +++ b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/MatchingApiTest.java @@ -5,10 +5,13 @@ import ch.qos.logback.classic.spi.ILoggingEvent; import ch.qos.logback.core.read.ListAppender; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; +import com.linkerbot.cadworld.common.web.RequestIdFilter; import com.linkerbot.cadworld.config.MatchingProperties; import com.linkerbot.cadworld.dto.matching.RobotMatchRequest; import com.linkerbot.cadworld.dto.matching.RobotMatchResponse; +import com.linkerbot.cadworld.security.common.TokenService; import com.linkerbot.cadworld.service.AdminOperatorProvider; +import com.linkerbot.cadworld.service.auth.LoginUserService; import com.linkerbot.cadworld.service.client.ObjectStorageClient; import com.linkerbot.cadworld.service.matching.AssemblySearchEngine; import com.linkerbot.cadworld.service.matching.PublicComponentQueryService; @@ -33,8 +36,11 @@ import org.springframework.http.MediaType; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MvcResult; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; +import org.springframework.web.context.WebApplicationContext; import static org.assertj.core.api.Assertions.assertThat; +import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; @@ -46,9 +52,12 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers. "spring.datasource.password=", "spring.sql.init.mode=never", "app.storage.public-base-url=https://models.example.test", "logging.file.path=target/test-logs" }) -@AutoConfigureMockMvc +@AutoConfigureMockMvc(print = org.springframework.boot.test.autoconfigure.web.servlet.MockMvcPrint.NONE) class MatchingApiTest { @Autowired private MockMvc mvc; + @Autowired private WebApplicationContext webContext; + @Autowired private LoginUserService loginUsers; + @Autowired private TokenService tokens; @Autowired private ObjectMapper json; @Autowired private JdbcTemplate jdbc; @Autowired private ApplicationContext context; @@ -79,6 +88,10 @@ class MatchingApiTest { updated_at TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP) """); jdbc.update("DELETE FROM component"); + ApiAuthTestSupport.createSchema(jdbc); + mvc = MockMvcBuilders.webAppContextSetup(webContext).apply(springSecurity()) + .addFilters(new RequestIdFilter()) + .defaultRequest(get("/").header("Authorization", "Bearer " + ApiAuthTestSupport.token(loginUsers, tokens))).build(); } @Test diff --git a/cadworld-api/src/test/java/com/linkerbot/cadworld/api/config/ApiCorsConfigurationTest.java b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/config/ApiCorsConfigurationTest.java index 2a49bcd..56fc674 100644 --- a/cadworld-api/src/test/java/com/linkerbot/cadworld/api/config/ApiCorsConfigurationTest.java +++ b/cadworld-api/src/test/java/com/linkerbot/cadworld/api/config/ApiCorsConfigurationTest.java @@ -47,7 +47,7 @@ class ApiCorsConfigurationTest { for (String method : List.of("GET", "POST", "DELETE")) { mvc.perform(options("/api/cors-probe").header(HttpHeaders.ORIGIN, allowedOrigin) .header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, method) - .header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "content-type,x-request-id")) + .header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "content-type,x-request-id,authorization")) .andExpect(status().isOk()) .andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, allowedOrigin)) .andExpect(header().string(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS, "true")) diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/CaptchaResponse.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/CaptchaResponse.java new file mode 100644 index 0000000..9d918f8 --- /dev/null +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/CaptchaResponse.java @@ -0,0 +1,8 @@ +package com.linkerbot.cadworld.dto.auth; + +public record CaptchaResponse(String captchaCode, String image, long expiresIn) { + @Override + public String toString() { + return "CaptchaResponse[expiresIn=" + expiresIn + "]"; + } +} diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/LoginRequest.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/LoginRequest.java new file mode 100644 index 0000000..24874b1 --- /dev/null +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/LoginRequest.java @@ -0,0 +1,20 @@ +package com.linkerbot.cadworld.dto.auth; + +import com.linkerbot.cadworld.common.util.EmailAddresses; +import jakarta.validation.constraints.Email; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.Size; + +public record LoginRequest( + @NotBlank @Email(message = "邮箱格式不正确") @Size(max = 254) String email, + @NotBlank @Size(max = 64) String captchaCode, + @NotBlank @Size(max = 32) String captchaAnswer) { + public LoginRequest { + email = EmailAddresses.normalize(email); + } + + @Override + public String toString() { + return "LoginRequest[redacted]"; + } +} diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/LoginResponse.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/LoginResponse.java new file mode 100644 index 0000000..e17d8c9 --- /dev/null +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/LoginResponse.java @@ -0,0 +1,8 @@ +package com.linkerbot.cadworld.dto.auth; + +public record LoginResponse(String token, String tokenType, long expiresIn, LoginUserResponse user) { + @Override + public String toString() { + return "LoginResponse[tokenType=" + tokenType + ", expiresIn=" + expiresIn + "]"; + } +} diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/LoginUserResponse.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/LoginUserResponse.java new file mode 100644 index 0000000..03e072a --- /dev/null +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/auth/LoginUserResponse.java @@ -0,0 +1,4 @@ +package com.linkerbot.cadworld.dto.auth; + +public record LoginUserResponse(String userCode, String nickname, String email) { +} diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/user/SaveUserRequest.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/user/SaveUserRequest.java index d44164a..8ec1add 100644 --- a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/user/SaveUserRequest.java +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/user/SaveUserRequest.java @@ -1,15 +1,19 @@ package com.linkerbot.cadworld.dto.user; +import com.linkerbot.cadworld.common.util.EmailAddresses; import com.linkerbot.cadworld.enums.UserStatus; import com.linkerbot.cadworld.enums.UserType; +import jakarta.validation.constraints.Email; import jakarta.validation.constraints.NotBlank; -import jakarta.validation.constraints.Pattern; import jakarta.validation.constraints.Size; public record SaveUserRequest( - @NotBlank @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确") String phone, + @NotBlank @Email(message = "邮箱格式不正确") @Size(max = 254) String email, @NotBlank @Size(max = 64) String nickname, UserStatus status, UserType userType ) { + public SaveUserRequest { + email = EmailAddresses.normalize(email); + } } diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/user/UserResponse.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/user/UserResponse.java index 1b015dd..9827856 100644 --- a/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/user/UserResponse.java +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/dto/user/UserResponse.java @@ -4,6 +4,6 @@ import com.linkerbot.cadworld.enums.UserStatus; import com.linkerbot.cadworld.enums.UserType; import java.time.LocalDateTime; -public record UserResponse(Long id, String phone, String nickname, UserStatus status, UserType userType, +public record UserResponse(Long id, String userCode, String email, String nickname, UserStatus status, UserType userType, LocalDateTime createdAt, LocalDateTime updatedAt) { } diff --git a/cadworld-bean/src/main/java/com/linkerbot/cadworld/entity/SysUser.java b/cadworld-bean/src/main/java/com/linkerbot/cadworld/entity/SysUser.java index 8668146..23fa79c 100644 --- a/cadworld-bean/src/main/java/com/linkerbot/cadworld/entity/SysUser.java +++ b/cadworld-bean/src/main/java/com/linkerbot/cadworld/entity/SysUser.java @@ -1,6 +1,8 @@ package com.linkerbot.cadworld.entity; +import com.baomidou.mybatisplus.annotation.FieldStrategy; import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.linkerbot.cadworld.enums.UserStatus; @@ -16,7 +18,10 @@ public class SysUser extends BaseEntity { @TableId(type = IdType.AUTO) private Long id; - private String phone; + @TableField(updateStrategy = FieldStrategy.NEVER) + private String userCode; + + private String email; private String nickname; @@ -24,6 +29,4 @@ public class SysUser extends BaseEntity { private UserType userType; - @com.baomidou.mybatisplus.annotation.TableLogic - private Integer deleted; } diff --git a/cadworld-common/src/main/java/com/linkerbot/cadworld/common/util/EmailAddresses.java b/cadworld-common/src/main/java/com/linkerbot/cadworld/common/util/EmailAddresses.java new file mode 100644 index 0000000..7c8db50 --- /dev/null +++ b/cadworld-common/src/main/java/com/linkerbot/cadworld/common/util/EmailAddresses.java @@ -0,0 +1,12 @@ +package com.linkerbot.cadworld.common.util; + +import java.util.Locale; + +public final class EmailAddresses { + private EmailAddresses() { + } + + public static String normalize(String email) { + return email == null ? null : email.trim().toLowerCase(Locale.ROOT); + } +} diff --git a/cadworld-security/cadworld-security-admin/pom.xml b/cadworld-security/cadworld-security-admin/pom.xml index bcd08a8..8b02937 100644 --- a/cadworld-security/cadworld-security-admin/pom.xml +++ b/cadworld-security/cadworld-security-admin/pom.xml @@ -14,4 +14,16 @@ cadworld-security-admin jar cadworld-security-admin + + + com.linkerbot + cadworld-service + ${project.version} + + + com.linkerbot + cadworld-security-common + ${project.version} + + diff --git a/cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/AdminBearerTokenFilter.java b/cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/AdminBearerTokenFilter.java new file mode 100644 index 0000000..ec04327 --- /dev/null +++ b/cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/AdminBearerTokenFilter.java @@ -0,0 +1,67 @@ +package com.linkerbot.cadworld.security.admin; + +import com.linkerbot.cadworld.common.api.RequestIdHolder; +import com.linkerbot.cadworld.common.exception.BizException; +import com.linkerbot.cadworld.entity.SysUser; +import com.linkerbot.cadworld.security.common.TokenService; +import com.linkerbot.cadworld.service.auth.AdminLoginService; +import jakarta.servlet.FilterChain; +import jakarta.servlet.ServletException; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.util.List; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.http.HttpHeaders; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.core.authority.SimpleGrantedAuthority; +import org.springframework.security.core.context.SecurityContext; +import org.springframework.security.core.context.SecurityContextHolder; +import org.springframework.security.web.context.SecurityContextRepository; +import org.springframework.web.filter.OncePerRequestFilter; +import org.springframework.web.servlet.HandlerExceptionResolver; + +@Slf4j +@RequiredArgsConstructor +public class AdminBearerTokenFilter extends OncePerRequestFilter { + private final TokenService tokens; + private final AdminLoginService users; + private final SecurityContextRepository contexts; + private final HandlerExceptionResolver exceptions; + + @Override + protected boolean shouldNotFilter(HttpServletRequest request) { + String path = request.getRequestURI().substring(request.getContextPath().length()); + return "OPTIONS".equals(request.getMethod()) + || ("GET".equals(request.getMethod()) && "/admin-api/auth/captcha".equals(path)) + || ("POST".equals(request.getMethod()) && "/admin-api/auth/login".equals(path)); + } + + @Override + protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) + throws ServletException, IOException { + String header = request.getHeader(HttpHeaders.AUTHORIZATION); + if (header != null) { + try { + String token = header.startsWith("Bearer ") ? header.substring(7) : null; + String userCode = tokens.resolve(token); + if (userCode == null) throw new BizException(401, "UNAUTHORIZED", "登录已失效,请重新登录"); + SysUser user = users.requireActive(userCode); + SecurityContext context = SecurityContextHolder.createEmptyContext(); + context.setAuthentication(new UsernamePasswordAuthenticationToken( + new CurrentAdmin.Principal(user.getId(), user.getUserCode(), user.getNickname()), null, + List.of(new SimpleGrantedAuthority("ROLE_ADMIN")))); + SecurityContextHolder.setContext(context); + contexts.saveContext(context, request, response); + } catch (RuntimeException exception) { + SecurityContextHolder.clearContext(); + String reason = exception instanceof BizException business ? business.getCode() : exception.getClass().getSimpleName(); + log.warn("管理员认证失败 method={} reason={} requestId={}", request.getMethod(), reason, RequestIdHolder.get()); + if (exceptions.resolveException(request, response, null, exception) == null) throw exception; + return; + } + } + chain.doFilter(request, response); + } +} diff --git a/cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/AdminSecurityConfiguration.java b/cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/AdminSecurityConfiguration.java new file mode 100644 index 0000000..b5999ee --- /dev/null +++ b/cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/AdminSecurityConfiguration.java @@ -0,0 +1,80 @@ +package com.linkerbot.cadworld.security.admin; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.linkerbot.cadworld.common.api.ApiResponse; +import com.linkerbot.cadworld.common.api.RequestIdHolder; +import com.linkerbot.cadworld.security.common.AuthProperties; +import com.linkerbot.cadworld.security.common.CaptchaService; +import com.linkerbot.cadworld.security.common.TokenService; +import com.linkerbot.cadworld.service.auth.AdminLoginService; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.boot.web.servlet.FilterRegistrationBean; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.http.HttpMethod; +import org.springframework.security.config.Customizer; +import org.springframework.security.config.annotation.web.builders.HttpSecurity; +import org.springframework.security.config.http.SessionCreationPolicy; +import org.springframework.security.web.SecurityFilterChain; +import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; +import org.springframework.security.web.context.RequestAttributeSecurityContextRepository; +import org.springframework.security.web.context.SecurityContextRepository; +import org.springframework.web.servlet.HandlerExceptionResolver; + +@Slf4j +@Configuration(proxyBeanMethods = false) +@EnableConfigurationProperties(AuthProperties.class) +public class AdminSecurityConfiguration { + @Bean CaptchaService captchaService(AuthProperties properties) { return new CaptchaService(properties); } + @Bean TokenService tokenService(AuthProperties properties) { return new TokenService(properties); } + @Bean SecurityContextRepository securityContextRepository() { return new RequestAttributeSecurityContextRepository(); } + + @Bean + AdminBearerTokenFilter adminBearerTokenFilter(TokenService tokens, AdminLoginService users, SecurityContextRepository contexts, + @Qualifier("handlerExceptionResolver") HandlerExceptionResolver exceptions) { + return new AdminBearerTokenFilter(tokens, users, contexts, exceptions); + } + + @Bean + FilterRegistrationBean disableAdminServletRegistration(AdminBearerTokenFilter filter) { + FilterRegistrationBean registration = new FilterRegistrationBean<>(filter); + registration.setEnabled(false); + return registration; + } + + @Bean + SecurityFilterChain adminSecurityFilterChain(HttpSecurity http, AdminBearerTokenFilter filter, ObjectMapper json, + SecurityContextRepository contexts) throws Exception { + http.securityMatcher("/admin-api/**") + .cors(Customizer.withDefaults()) + .csrf(csrf -> csrf.disable()) + .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) + .securityContext(context -> context.securityContextRepository(contexts)) + .requestCache(cache -> cache.disable()) + .formLogin(form -> form.disable()).httpBasic(basic -> basic.disable()).logout(logout -> logout.disable()) + .authorizeHttpRequests(auth -> auth + .requestMatchers(HttpMethod.OPTIONS, "/**").permitAll() + .requestMatchers(HttpMethod.GET, "/admin-api/auth/captcha").permitAll() + .requestMatchers(HttpMethod.POST, "/admin-api/auth/login").permitAll() + .anyRequest().hasRole("ADMIN")) + .exceptionHandling(errors -> errors + .authenticationEntryPoint((request, response, exception) -> { + log.warn("管理员认证失败 method={} reason=UNAUTHORIZED requestId={}", request.getMethod(), RequestIdHolder.get()); + response.setStatus(401); + response.setContentType("application/json;charset=UTF-8"); + request.setAttribute("cadworld.runtimeLogResultCode", "UNAUTHORIZED"); + json.writeValue(response.getOutputStream(), ApiResponse.failure("UNAUTHORIZED", "请先登录管理端")); + }) + .accessDeniedHandler((request, response, exception) -> { + log.warn("管理员访问拒绝 method={} reason=FORBIDDEN requestId={}", request.getMethod(), RequestIdHolder.get()); + response.setStatus(403); + response.setContentType("application/json;charset=UTF-8"); + request.setAttribute("cadworld.runtimeLogResultCode", "FORBIDDEN"); + json.writeValue(response.getOutputStream(), ApiResponse.failure("FORBIDDEN", "无管理端访问权限")); + })) + .addFilterBefore(filter, UsernamePasswordAuthenticationFilter.class); + return http.build(); + } +} diff --git a/cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/AuthenticatedAdminOperatorProvider.java b/cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/AuthenticatedAdminOperatorProvider.java new file mode 100644 index 0000000..4770425 --- /dev/null +++ b/cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/AuthenticatedAdminOperatorProvider.java @@ -0,0 +1,13 @@ +package com.linkerbot.cadworld.security.admin; + +import com.linkerbot.cadworld.service.AdminOperatorProvider; +import org.springframework.stereotype.Component; + +@Component +public class AuthenticatedAdminOperatorProvider implements AdminOperatorProvider { + @Override + public Long userId() { return CurrentAdmin.required().userId(); } + + @Override + public String name() { return CurrentAdmin.required().nickname(); } +} diff --git a/cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/CurrentAdmin.java b/cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/CurrentAdmin.java new file mode 100644 index 0000000..caa7973 --- /dev/null +++ b/cadworld-security/cadworld-security-admin/src/main/java/com/linkerbot/cadworld/security/admin/CurrentAdmin.java @@ -0,0 +1,21 @@ +package com.linkerbot.cadworld.security.admin; + +import com.linkerbot.cadworld.common.exception.BizException; +import org.springframework.security.core.Authentication; +import org.springframework.security.core.context.SecurityContextHolder; + +public final class CurrentAdmin { + private CurrentAdmin() { + } + + /** 主键仅用于服务端上传会话和审计,不作为接口响应。 */ + public record Principal(Long userId, String userCode, String nickname) { + } + + public static Principal required() { + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + if (authentication != null && authentication.isAuthenticated() + && authentication.getPrincipal() instanceof Principal principal) return principal; + throw new BizException(401, "UNAUTHORIZED", "请先登录管理端"); + } +} diff --git a/cadworld-security/cadworld-security-api/pom.xml b/cadworld-security/cadworld-security-api/pom.xml index 8f33967..72a3d12 100644 --- a/cadworld-security/cadworld-security-api/pom.xml +++ b/cadworld-security/cadworld-security-api/pom.xml @@ -14,4 +14,16 @@ cadworld-security-api jar cadworld-security-api + + + com.linkerbot + cadworld-service + ${project.version} + + + com.linkerbot + cadworld-security-common + ${project.version} + + diff --git a/cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/ApiSecurityConfiguration.java b/cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/ApiSecurityConfiguration.java new file mode 100644 index 0000000..ee05116 --- /dev/null +++ b/cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/ApiSecurityConfiguration.java @@ -0,0 +1,77 @@ +package com.linkerbot.cadworld.security.api; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.linkerbot.cadworld.common.api.ApiResponse; +import com.linkerbot.cadworld.common.api.RequestIdHolder; +import com.linkerbot.cadworld.security.common.AuthProperties; +import com.linkerbot.cadworld.security.common.CaptchaService; +import com.linkerbot.cadworld.security.common.TokenService; +import com.linkerbot.cadworld.service.auth.LoginUserService; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.boot.web.servlet.FilterRegistrationBean; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.http.HttpMethod; +import org.springframework.security.config.annotation.web.builders.HttpSecurity; +import org.springframework.security.config.http.SessionCreationPolicy; +import org.springframework.security.web.SecurityFilterChain; +import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; +import org.springframework.security.web.context.RequestAttributeSecurityContextRepository; +import org.springframework.security.web.context.SecurityContextRepository; +import org.springframework.web.servlet.HandlerExceptionResolver; + +@Slf4j +@Configuration(proxyBeanMethods = false) +@EnableConfigurationProperties(AuthProperties.class) +public class ApiSecurityConfiguration { + @Bean CaptchaService captchaService(AuthProperties properties) { return new CaptchaService(properties); } + @Bean TokenService tokenService(AuthProperties properties) { return new TokenService(properties); } + @Bean SecurityContextRepository securityContextRepository() { return new RequestAttributeSecurityContextRepository(); } + + @Bean + BearerTokenFilter bearerTokenFilter(TokenService tokens, LoginUserService users, SecurityContextRepository contexts, + @Qualifier("handlerExceptionResolver") HandlerExceptionResolver exceptions) { + return new BearerTokenFilter(tokens, users, contexts, exceptions); + } + + @Bean + FilterRegistrationBean disableServletRegistration(BearerTokenFilter filter) { + FilterRegistrationBean registration = new FilterRegistrationBean<>(filter); + registration.setEnabled(false); + return registration; + } + + @Bean + SecurityFilterChain apiSecurityFilterChain(HttpSecurity http, BearerTokenFilter filter, ObjectMapper json, + SecurityContextRepository contexts) throws Exception { + http.securityMatcher("/api/**") + .cors(cors -> { }) + .csrf(csrf -> csrf.disable()) + .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) + .securityContext(context -> context.securityContextRepository(contexts)) + .requestCache(cache -> cache.disable()) + .formLogin(form -> form.disable()).httpBasic(basic -> basic.disable()).logout(logout -> logout.disable()) + .authorizeHttpRequests(auth -> auth + .requestMatchers(HttpMethod.OPTIONS, "/**").permitAll() + .requestMatchers(HttpMethod.GET, "/api/auth/captcha").permitAll() + .requestMatchers(HttpMethod.POST, "/api/auth/login").permitAll() + .anyRequest().authenticated()) + .exceptionHandling(errors -> errors + .authenticationEntryPoint((request, response, exception) -> { + log.warn("用户认证失败 method={} reason=UNAUTHORIZED requestId={}", request.getMethod(), RequestIdHolder.get()); + response.setStatus(401); + response.setContentType("application/json;charset=UTF-8"); + json.writeValue(response.getOutputStream(), ApiResponse.failure("UNAUTHORIZED", "请先登录")); + }) + .accessDeniedHandler((request, response, exception) -> { + log.warn("用户访问拒绝 method={} reason=FORBIDDEN requestId={}", request.getMethod(), RequestIdHolder.get()); + response.setStatus(403); + response.setContentType("application/json;charset=UTF-8"); + json.writeValue(response.getOutputStream(), ApiResponse.failure("FORBIDDEN", "无权访问")); + })) + .addFilterBefore(filter, UsernamePasswordAuthenticationFilter.class); + return http.build(); + } +} diff --git a/cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/BearerTokenFilter.java b/cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/BearerTokenFilter.java new file mode 100644 index 0000000..7cca849 --- /dev/null +++ b/cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/BearerTokenFilter.java @@ -0,0 +1,65 @@ +package com.linkerbot.cadworld.security.api; + +import com.linkerbot.cadworld.common.api.RequestIdHolder; +import com.linkerbot.cadworld.common.exception.BizException; +import com.linkerbot.cadworld.security.common.TokenService; +import com.linkerbot.cadworld.service.auth.LoginUserService; +import jakarta.servlet.FilterChain; +import jakarta.servlet.ServletException; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.util.List; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.http.HttpHeaders; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.core.authority.SimpleGrantedAuthority; +import org.springframework.security.core.context.SecurityContext; +import org.springframework.security.core.context.SecurityContextHolder; +import org.springframework.security.web.context.SecurityContextRepository; +import org.springframework.web.filter.OncePerRequestFilter; +import org.springframework.web.servlet.HandlerExceptionResolver; + +@Slf4j +@RequiredArgsConstructor +public class BearerTokenFilter extends OncePerRequestFilter { + private final TokenService tokens; + private final LoginUserService users; + private final SecurityContextRepository contexts; + private final HandlerExceptionResolver exceptions; + + @Override + protected boolean shouldNotFilter(HttpServletRequest request) { + String path = request.getRequestURI().substring(request.getContextPath().length()); + return "OPTIONS".equals(request.getMethod()) + || ("GET".equals(request.getMethod()) && "/api/auth/captcha".equals(path)) + || ("POST".equals(request.getMethod()) && "/api/auth/login".equals(path)); + } + + @Override + protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) + throws ServletException, IOException { + String header = request.getHeader(HttpHeaders.AUTHORIZATION); + if (header != null) { + try { + String token = header.startsWith("Bearer ") ? header.substring(7) : null; + String userCode = tokens.resolve(token); + if (userCode == null) throw new BizException(401, "UNAUTHORIZED", "登录已失效,请重新登录"); + users.requireActive(userCode); + SecurityContext context = SecurityContextHolder.createEmptyContext(); + context.setAuthentication(new UsernamePasswordAuthenticationToken(new CurrentUser.Principal(userCode), null, + List.of(new SimpleGrantedAuthority("ROLE_USER")))); + SecurityContextHolder.setContext(context); + contexts.saveContext(context, request, response); + } catch (RuntimeException exception) { + SecurityContextHolder.clearContext(); + String reason = exception instanceof BizException business ? business.getCode() : exception.getClass().getSimpleName(); + log.warn("用户认证失败 method={} reason={} requestId={}", request.getMethod(), reason, RequestIdHolder.get()); + if (exceptions.resolveException(request, response, null, exception) == null) throw exception; + return; + } + } + chain.doFilter(request, response); + } +} diff --git a/cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/CurrentUser.java b/cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/CurrentUser.java new file mode 100644 index 0000000..3945c77 --- /dev/null +++ b/cadworld-security/cadworld-security-api/src/main/java/com/linkerbot/cadworld/security/api/CurrentUser.java @@ -0,0 +1,20 @@ +package com.linkerbot.cadworld.security.api; + +import com.linkerbot.cadworld.common.exception.BizException; +import org.springframework.security.core.Authentication; +import org.springframework.security.core.context.SecurityContextHolder; + +public final class CurrentUser { + private CurrentUser() { + } + + public record Principal(String userCode) { + } + + public static String required() { + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + if (authentication != null && authentication.isAuthenticated() + && authentication.getPrincipal() instanceof Principal principal) return principal.userCode(); + throw new BizException(401, "UNAUTHORIZED", "请先登录"); + } +} diff --git a/cadworld-security/cadworld-security-common/pom.xml b/cadworld-security/cadworld-security-common/pom.xml index d608248..6cdd66b 100644 --- a/cadworld-security/cadworld-security-common/pom.xml +++ b/cadworld-security/cadworld-security-common/pom.xml @@ -14,4 +14,19 @@ cadworld-security-common jar cadworld-security-common + + + com.linkerbot + cadworld-bean + ${project.version} + + + org.springframework.boot + spring-boot-starter-security + + + com.github.ben-manes.caffeine + caffeine + + diff --git a/cadworld-security/cadworld-security-common/src/main/java/com/linkerbot/cadworld/security/common/AuthProperties.java b/cadworld-security/cadworld-security-common/src/main/java/com/linkerbot/cadworld/security/common/AuthProperties.java new file mode 100644 index 0000000..9321a65 --- /dev/null +++ b/cadworld-security/cadworld-security-common/src/main/java/com/linkerbot/cadworld/security/common/AuthProperties.java @@ -0,0 +1,19 @@ +package com.linkerbot.cadworld.security.common; + +import jakarta.validation.constraints.AssertTrue; +import java.time.Duration; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.boot.context.properties.bind.DefaultValue; +import org.springframework.validation.annotation.Validated; + +@Validated +@ConfigurationProperties(prefix = "app.auth") +public record AuthProperties( + @DefaultValue("PT2M") Duration captchaTtl, + @DefaultValue("PT24H") Duration tokenTtl) { + @AssertTrue(message = "验证码和登录态有效期必须至少为1秒") + public boolean isDurationValid() { + return captchaTtl != null && captchaTtl.compareTo(Duration.ofSeconds(1)) >= 0 + && tokenTtl != null && tokenTtl.compareTo(Duration.ofSeconds(1)) >= 0; + } +} diff --git a/cadworld-security/cadworld-security-common/src/main/java/com/linkerbot/cadworld/security/common/CaptchaService.java b/cadworld-security/cadworld-security-common/src/main/java/com/linkerbot/cadworld/security/common/CaptchaService.java new file mode 100644 index 0000000..b523696 --- /dev/null +++ b/cadworld-security/cadworld-security-common/src/main/java/com/linkerbot/cadworld/security/common/CaptchaService.java @@ -0,0 +1,87 @@ +package com.linkerbot.cadworld.security.common; + +import com.github.benmanes.caffeine.cache.Cache; +import com.github.benmanes.caffeine.cache.Caffeine; +import com.github.benmanes.caffeine.cache.Ticker; +import com.linkerbot.cadworld.common.api.RequestIdHolder; +import com.linkerbot.cadworld.common.exception.BizException; +import com.linkerbot.cadworld.dto.auth.CaptchaResponse; +import java.awt.Color; +import java.awt.Font; +import java.awt.Graphics2D; +import java.awt.image.BufferedImage; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.security.SecureRandom; +import java.util.Base64; +import java.util.Locale; +import java.util.UUID; +import javax.imageio.ImageIO; +import lombok.extern.slf4j.Slf4j; + +@Slf4j +public class CaptchaService { + private static final String ALPHABET = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ"; + private final SecureRandom random = new SecureRandom(); + private final Cache challenges; + private final AuthProperties properties; + + public CaptchaService(AuthProperties properties) { + this(properties, Ticker.systemTicker()); + } + + CaptchaService(AuthProperties properties, Ticker ticker) { + this.properties = properties; + challenges = Caffeine.newBuilder().maximumSize(10000) + .expireAfterWrite(properties.captchaTtl()).ticker(ticker).build(); + } + + protected String generateAnswer() { + StringBuilder answer = new StringBuilder(5); + for (int index = 0; index < 5; index++) answer.append(ALPHABET.charAt(random.nextInt(ALPHABET.length()))); + return answer.toString(); + } + + public CaptchaResponse issue() { + String answer = generateAnswer(); + BufferedImage image = new BufferedImage(180, 60, BufferedImage.TYPE_INT_RGB); + Graphics2D graphics = image.createGraphics(); + try { + graphics.setColor(new Color(245, 247, 250)); + graphics.fillRect(0, 0, 180, 60); + for (int index = 0; index < 10; index++) { + graphics.setColor(new Color(random.nextInt(160), random.nextInt(160), random.nextInt(160))); + graphics.drawLine(random.nextInt(180), random.nextInt(60), random.nextInt(180), random.nextInt(60)); + } + graphics.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 30)); + for (int index = 0; index < answer.length(); index++) { + graphics.setColor(new Color(random.nextInt(100), random.nextInt(100), random.nextInt(100))); + graphics.drawString(String.valueOf(answer.charAt(index)), 15 + index * 30, 38 + random.nextInt(8)); + } + } finally { + graphics.dispose(); + } + try (ByteArrayOutputStream bytes = new ByteArrayOutputStream()) { + if (!ImageIO.write(image, "png", bytes)) throw new IOException("PNG writer unavailable"); + String code = UUID.randomUUID().toString().replace("-", ""); + challenges.put(code, answer); + log.debug("图片验证码生成成功 requestId={}", RequestIdHolder.get()); + return new CaptchaResponse(code, "data:image/png;base64," + Base64.getEncoder().encodeToString(bytes.toByteArray()), + properties.captchaTtl().toSeconds()); + } catch (IOException exception) { + log.error("图片验证码生成失败 requestId={}", RequestIdHolder.get(), exception); + throw new BizException(500, "CAPTCHA_ERROR", "验证码生成失败"); + } + } + + public void verify(String code, String answer) { + String expected = code == null ? null : challenges.asMap().remove(code); + String actual = answer == null ? "" : answer.trim().toUpperCase(Locale.ROOT); + if (expected == null || !MessageDigest.isEqual(expected.getBytes(StandardCharsets.US_ASCII), actual.getBytes(StandardCharsets.UTF_8))) { + log.warn("图片验证码校验失败 reason=CAPTCHA_INVALID requestId={}", RequestIdHolder.get()); + throw new BizException(400, "CAPTCHA_INVALID", "图片验证码错误、已使用或已过期"); + } + } +} diff --git a/cadworld-security/cadworld-security-common/src/main/java/com/linkerbot/cadworld/security/common/TokenService.java b/cadworld-security/cadworld-security-common/src/main/java/com/linkerbot/cadworld/security/common/TokenService.java new file mode 100644 index 0000000..a29e0ac --- /dev/null +++ b/cadworld-security/cadworld-security-common/src/main/java/com/linkerbot/cadworld/security/common/TokenService.java @@ -0,0 +1,36 @@ +package com.linkerbot.cadworld.security.common; + +import com.github.benmanes.caffeine.cache.Cache; +import com.github.benmanes.caffeine.cache.Caffeine; +import com.github.benmanes.caffeine.cache.Ticker; +import java.security.SecureRandom; +import java.util.Base64; + +public class TokenService { + private final SecureRandom random = new SecureRandom(); + private final Cache sessions; + + public TokenService(AuthProperties properties) { + this(properties, Ticker.systemTicker()); + } + + TokenService(AuthProperties properties, Ticker ticker) { + sessions = Caffeine.newBuilder().maximumSize(10000).expireAfterWrite(properties.tokenTtl()).ticker(ticker).build(); + } + + public String issue(String userCode) { + byte[] bytes = new byte[32]; + random.nextBytes(bytes); + String token = Base64.getUrlEncoder().withoutPadding().encodeToString(bytes); + sessions.put(token, userCode); + return token; + } + + public String resolve(String token) { + return token == null ? null : sessions.getIfPresent(token); + } + + public void revoke(String token) { + if (token != null) sessions.invalidate(token); + } +} diff --git a/cadworld-security/cadworld-security-common/src/test/java/com/linkerbot/cadworld/security/common/AuthPropertiesTest.java b/cadworld-security/cadworld-security-common/src/test/java/com/linkerbot/cadworld/security/common/AuthPropertiesTest.java new file mode 100644 index 0000000..906db7a --- /dev/null +++ b/cadworld-security/cadworld-security-common/src/test/java/com/linkerbot/cadworld/security/common/AuthPropertiesTest.java @@ -0,0 +1,37 @@ +package com.linkerbot.cadworld.security.common; + +import java.time.Duration; +import org.junit.jupiter.api.Test; +import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.boot.test.context.runner.ApplicationContextRunner; +import org.springframework.context.annotation.Configuration; + +import static org.assertj.core.api.Assertions.assertThat; + +class AuthPropertiesTest { + private final ApplicationContextRunner runner = new ApplicationContextRunner().withUserConfiguration(ConfigurationUnderTest.class); + + @Test + void defaultsAndOverridesBind() { + runner.run(context -> { + assertThat(context).hasNotFailed(); + assertThat(context.getBean(AuthProperties.class).captchaTtl()).isEqualTo(Duration.ofMinutes(2)); + assertThat(context.getBean(AuthProperties.class).tokenTtl()).isEqualTo(Duration.ofHours(24)); + }); + runner.withPropertyValues("app.auth.captcha-ttl=PT30S", "app.auth.token-ttl=PT2H").run(context -> { + assertThat(context).hasNotFailed(); + assertThat(context.getBean(AuthProperties.class).tokenTtl()).isEqualTo(Duration.ofHours(2)); + }); + } + + @Test + void invalidTtlFailsStartup() { + runner.withPropertyValues("app.auth.captcha-ttl=PT0S").run(context -> assertThat(context).hasFailed()); + runner.withPropertyValues("app.auth.token-ttl=-PT1S").run(context -> assertThat(context).hasFailed()); + } + + @Configuration(proxyBeanMethods = false) + @EnableConfigurationProperties(AuthProperties.class) + static class ConfigurationUnderTest { + } +} diff --git a/cadworld-security/cadworld-security-common/src/test/java/com/linkerbot/cadworld/security/common/SessionTest.java b/cadworld-security/cadworld-security-common/src/test/java/com/linkerbot/cadworld/security/common/SessionTest.java new file mode 100644 index 0000000..af3f067 --- /dev/null +++ b/cadworld-security/cadworld-security-common/src/test/java/com/linkerbot/cadworld/security/common/SessionTest.java @@ -0,0 +1,104 @@ +package com.linkerbot.cadworld.security.common; + +import com.linkerbot.cadworld.common.exception.BizException; +import com.linkerbot.cadworld.dto.auth.CaptchaResponse; +import java.io.ByteArrayInputStream; +import java.time.Duration; +import java.util.ArrayList; +import java.util.Base64; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicLong; +import javax.imageio.ImageIO; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +class SessionTest { + private final AuthProperties properties = new AuthProperties(Duration.ofMinutes(2), Duration.ofHours(24)); + private final AtomicLong time = new AtomicLong(); + + private CaptchaService captcha() { + return new CaptchaService(properties, time::get) { + @Override protected String generateAnswer() { return "ABCDE"; } + }; + } + + @Test + void captchaIsDecodablePngAndCanOnlyBeConsumedOnce() throws Exception { + CaptchaService captcha = captcha(); + CaptchaResponse response = captcha.issue(); + assertThat(response.expiresIn()).isEqualTo(120); + assertThat(response.image()).startsWith("data:image/png;base64,"); + byte[] png = Base64.getDecoder().decode(response.image().substring(response.image().indexOf(',') + 1)); + assertThat(ImageIO.read(new ByteArrayInputStream(png)).getWidth()).isEqualTo(180); + captcha.verify(response.captchaCode(), " abcde "); + invalid(captcha, response.captchaCode(), "ABCDE"); + invalid(captcha, "missing", "ABCDE"); + invalid(captcha, null, null); + } + + @Test + void wrongAnswerConsumesChallengeAndExpiredChallengeIsRejected() { + CaptchaService captcha = captcha(); + String wrong = captcha.issue().captchaCode(); + invalid(captcha, wrong, "WRONG"); + invalid(captcha, wrong, "ABCDE"); + String expired = captcha.issue().captchaCode(); + time.addAndGet(Duration.ofMinutes(2).toNanos()); + invalid(captcha, expired, "ABCDE"); + } + + @Test + void concurrentCaptchaVerificationHasExactlyOneWinner() throws Exception { + CaptchaService captcha = captcha(); + String code = captcha.issue().captchaCode(); + CountDownLatch start = new CountDownLatch(1); + List> results = new ArrayList<>(); + try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) { + for (int index = 0; index < 12; index++) results.add(executor.submit(() -> { + start.await(); + try { + captcha.verify(code, "ABCDE"); + return true; + } catch (BizException exception) { + assertThat(exception.getCode()).isEqualTo("CAPTCHA_INVALID"); + return false; + } + })); + start.countDown(); + int winners = 0; + for (Future result : results) if (result.get(5, TimeUnit.SECONDS)) winners++; + assertThat(winners).isEqualTo(1); + } + } + + @Test + void tokensAreIndependentRandomAndExpireWithoutSlidingRenewal() { + TokenService tokens = new TokenService(properties, time::get); + String first = tokens.issue("USER"); + String second = tokens.issue("USER"); + assertThat(first).isNotEqualTo(second); + assertThat(Base64.getUrlDecoder().decode(first)).hasSize(32); + tokens.revoke(first); + assertThat(tokens.resolve(first)).isNull(); + assertThat(tokens.resolve(second)).isEqualTo("USER"); + time.addAndGet(Duration.ofHours(23).toNanos()); + assertThat(tokens.resolve(second)).isEqualTo("USER"); + time.addAndGet(Duration.ofHours(1).toNanos()); + assertThat(tokens.resolve(second)).isNull(); + assertThat(tokens.resolve(null)).isNull(); + } + + private void invalid(CaptchaService captcha, String code, String answer) { + assertThatThrownBy(() -> captcha.verify(code, answer)).isInstanceOfSatisfying(BizException.class, exception -> { + assertThat(exception.getHttpStatus()).isEqualTo(400); + assertThat(exception.getCode()).isEqualTo("CAPTCHA_INVALID"); + }); + } +} diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/config/AdminOperatorProperties.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/config/AdminOperatorProperties.java deleted file mode 100644 index 0d68826..0000000 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/config/AdminOperatorProperties.java +++ /dev/null @@ -1,12 +0,0 @@ -package com.linkerbot.cadworld.config; - -import jakarta.validation.constraints.Min; -import jakarta.validation.constraints.NotBlank; -import jakarta.validation.constraints.Size; -import org.springframework.boot.context.properties.ConfigurationProperties; -import org.springframework.validation.annotation.Validated; - -@Validated -@ConfigurationProperties(prefix = "app.admin.operator") -public record AdminOperatorProperties(@Min(0) long id, @NotBlank @Size(max = 64) String name) { -} diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/AdminOperatorProvider.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/AdminOperatorProvider.java index 885ee5b..6184209 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/AdminOperatorProvider.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/AdminOperatorProvider.java @@ -1,15 +1,7 @@ package com.linkerbot.cadworld.service; -import com.linkerbot.cadworld.config.AdminOperatorProperties; -import lombok.RequiredArgsConstructor; -import org.springframework.stereotype.Component; - -/** A configured test identity, to be replaced when account authentication is enabled. */ -@Component -@RequiredArgsConstructor -public class AdminOperatorProvider { - private final AdminOperatorProperties properties; - - public Long userId() { return properties.id(); } - public String name() { return properties.name(); } +/** 管理端认证模块提供当前操作人,业务服务不依赖具体认证实现。 */ +public interface AdminOperatorProvider { + Long userId(); + String name(); } diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/auth/AdminLoginService.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/auth/AdminLoginService.java new file mode 100644 index 0000000..4d3ae31 --- /dev/null +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/auth/AdminLoginService.java @@ -0,0 +1,49 @@ +package com.linkerbot.cadworld.service.auth; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.linkerbot.cadworld.common.api.RequestIdHolder; +import com.linkerbot.cadworld.common.exception.BizException; +import com.linkerbot.cadworld.common.util.EmailAddresses; +import com.linkerbot.cadworld.entity.SysUser; +import com.linkerbot.cadworld.enums.UserStatus; +import com.linkerbot.cadworld.enums.UserType; +import com.linkerbot.cadworld.mapper.SysUserMapper; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; + +@Slf4j +@Service +@RequiredArgsConstructor +public class AdminLoginService { + private final SysUserMapper users; + + /** 管理端只接受预先授权的管理员,禁止通过登录入口注册或提升权限。 */ + public SysUser login(String email) { + SysUser user = users.selectOne(new LambdaQueryWrapper() + .eq(SysUser::getEmail, EmailAddresses.normalize(email))); + if (user == null || user.getUserType() != UserType.ADMIN) { + log.warn("管理员登录拒绝 reason=ADMIN_ACCESS_DENIED requestId={}", RequestIdHolder.get()); + throw forbidden(); + } + if (user.getStatus() != UserStatus.ACTIVE) { + log.warn("管理员登录拒绝 userCode={} reason=ACCOUNT_DISABLED requestId={}", user.getUserCode(), RequestIdHolder.get()); + throw new BizException(403, "ACCOUNT_DISABLED", "账号已禁用"); + } + log.info("管理员登录成功 userCode={} requestId={}", user.getUserCode(), RequestIdHolder.get()); + return user; + } + + public SysUser requireActive(String userCode) { + SysUser user = users.selectOne(new LambdaQueryWrapper().eq(SysUser::getUserCode, userCode)); + if (user == null || user.getStatus() != UserStatus.ACTIVE) { + throw new BizException(401, "UNAUTHORIZED", "登录已失效,请重新登录"); + } + if (user.getUserType() != UserType.ADMIN) throw forbidden(); + return user; + } + + private BizException forbidden() { + return new BizException(403, "ADMIN_ACCESS_DENIED", "该账号无管理端访问权限"); + } +} diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/auth/LoginUserService.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/auth/LoginUserService.java new file mode 100644 index 0000000..d9a7a9a --- /dev/null +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/auth/LoginUserService.java @@ -0,0 +1,77 @@ +package com.linkerbot.cadworld.service.auth; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.linkerbot.cadworld.common.api.RequestIdHolder; +import com.linkerbot.cadworld.common.exception.BizException; +import com.linkerbot.cadworld.common.util.EmailAddresses; +import com.linkerbot.cadworld.dto.auth.LoginUserResponse; +import com.linkerbot.cadworld.entity.SysUser; +import com.linkerbot.cadworld.enums.UserStatus; +import com.linkerbot.cadworld.enums.UserType; +import com.linkerbot.cadworld.mapper.SysUserMapper; +import com.linkerbot.cadworld.service.support.UserCodes; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.dao.DuplicateKeyException; +import org.springframework.stereotype.Service; + +@Slf4j +@Service +@RequiredArgsConstructor +public class LoginUserService { + private static final int MAX_CODE_ATTEMPTS = 5; + private final SysUserMapper users; + + // 不开启外层事务:唯一索引冲突后的查询必须能看到并发请求已提交的用户。 + public SysUser login(String email) { + String normalized = EmailAddresses.normalize(email); + SysUser user = findByEmail(normalized); + if (user == null) user = create(normalized); + if (user.getStatus() != UserStatus.ACTIVE) { + log.warn("用户登录拒绝 userCode={} reason=ACCOUNT_DISABLED requestId={}", user.getUserCode(), RequestIdHolder.get()); + throw new BizException(403, "ACCOUNT_DISABLED", "账号已禁用"); + } + log.info("用户登录成功 userCode={} requestId={}", user.getUserCode(), RequestIdHolder.get()); + return user; + } + + public SysUser requireActive(String userCode) { + SysUser user = users.selectOne(new LambdaQueryWrapper().eq(SysUser::getUserCode, userCode)); + if (user == null || user.getStatus() != UserStatus.ACTIVE) { + throw new BizException(401, "UNAUTHORIZED", "登录已失效,请重新登录"); + } + return user; + } + + public LoginUserResponse view(SysUser user) { + return new LoginUserResponse(user.getUserCode(), user.getNickname(), user.getEmail()); + } + + private SysUser create(String email) { + for (int attempt = 1; attempt <= MAX_CODE_ATTEMPTS; attempt++) { + SysUser candidate = new SysUser(); + candidate.setUserCode(UserCodes.generate()); + candidate.setEmail(email); + candidate.setNickname("用户_" + candidate.getUserCode().substring(0, 8)); + candidate.setStatus(UserStatus.ACTIVE); + candidate.setUserType(UserType.NORMAL); + try { + users.insert(candidate); + log.info("首次登录创建用户 userCode={} requestId={}", candidate.getUserCode(), RequestIdHolder.get()); + return candidate; + } catch (DuplicateKeyException exception) { + SysUser existing = findByEmail(email); + if (existing != null) return existing; + Long conflicts = users.selectCount(new LambdaQueryWrapper() + .eq(SysUser::getUserCode, candidate.getUserCode())); + if (conflicts == 0) throw exception; + log.warn("用户编码冲突 userCode={} attempt={} requestId={}", candidate.getUserCode(), attempt, RequestIdHolder.get()); + } + } + throw new BizException(503, "USER_CODE_EXHAUSTED", "用户编码分配失败,请稍后重试"); + } + + private SysUser findByEmail(String email) { + return users.selectOne(new LambdaQueryWrapper().eq(SysUser::getEmail, email)); + } +} diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/UserManagementServiceImpl.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/UserManagementServiceImpl.java index 3013fad..00ce811 100644 --- a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/UserManagementServiceImpl.java +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/impl/UserManagementServiceImpl.java @@ -3,6 +3,7 @@ package com.linkerbot.cadworld.service.impl; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.linkerbot.cadworld.common.api.PageResponse; +import com.linkerbot.cadworld.common.api.RequestIdHolder; import com.linkerbot.cadworld.common.exception.BizException; import com.linkerbot.cadworld.dto.user.SaveUserRequest; import com.linkerbot.cadworld.dto.user.UserResponse; @@ -11,7 +12,9 @@ import com.linkerbot.cadworld.enums.UserStatus; import com.linkerbot.cadworld.enums.UserType; import com.linkerbot.cadworld.mapper.SysUserMapper; import com.linkerbot.cadworld.service.UserManagementService; +import com.linkerbot.cadworld.service.support.UserCodes; import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; import org.springframework.dao.DuplicateKeyException; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @@ -19,7 +22,9 @@ import org.springframework.util.StringUtils; @Service @RequiredArgsConstructor +@Slf4j public class UserManagementServiceImpl implements UserManagementService { + private static final int MAX_CODE_ATTEMPTS = 5; private final SysUserMapper mapper; @Override @@ -28,7 +33,7 @@ public class UserManagementServiceImpl implements UserManagementService { .eq(type != null, SysUser::getUserType, type).eq(status != null, SysUser::getStatus, status); if (StringUtils.hasText(keyword)) { String term = keyword.trim(); - query.and(q -> q.like(SysUser::getPhone, term).or().like(SysUser::getNickname, term)); + query.and(q -> q.like(SysUser::getEmail, term).or().like(SysUser::getNickname, term)); } Page result = mapper.selectPage(new Page<>(page, size), query.orderByDesc(SysUser::getUpdatedAt).orderByDesc(SysUser::getId)); @@ -39,17 +44,27 @@ public class UserManagementServiceImpl implements UserManagementService { public UserResponse get(Long id) { return response(require(id)); } @Override - @Transactional public UserResponse create(SaveUserRequest request) { SysUser user = new SysUser(); - user.setDeleted(0); apply(user, request); - try { - mapper.insert(user); - } catch (DuplicateKeyException exception) { - throw duplicatePhone(); + for (int attempt = 1; attempt <= MAX_CODE_ATTEMPTS; attempt++) { + user.setUserCode(UserCodes.generate()); + try { + mapper.insert(user); + log.info("后台创建用户 userCode={} requestId={}", user.getUserCode(), RequestIdHolder.get()); + return response(require(user.getId())); + } catch (DuplicateKeyException exception) { + if (mapper.selectCount(new LambdaQueryWrapper().eq(SysUser::getEmail, user.getEmail())) > 0) { + throw duplicateEmail(); + } + if (mapper.selectCount(new LambdaQueryWrapper().eq(SysUser::getUserCode, user.getUserCode())) == 0) { + throw exception; + } + user.setId(null); + log.warn("后台创建用户编码冲突 userCode={} attempt={} requestId={}", user.getUserCode(), attempt, RequestIdHolder.get()); + } } - return response(require(user.getId())); + throw new BizException(503, "USER_CODE_EXHAUSTED", "用户编码分配失败,请稍后重试"); } @Override @@ -60,20 +75,26 @@ public class UserManagementServiceImpl implements UserManagementService { try { if (mapper.updateById(user) == 0) throw notFound(); } catch (DuplicateKeyException exception) { - throw duplicatePhone(); + throw duplicateEmail(); } + log.info("后台更新用户 userCode={} status={} requestId={}", user.getUserCode(), user.getStatus(), RequestIdHolder.get()); return response(require(id)); } @Override @Transactional public void delete(Long id) { - require(id); - if (mapper.deleteById(id) == 0) throw notFound(); + SysUser user = require(id); + // 删除入口仅禁用账号,保留唯一邮箱和历史业务归属。 + SysUser disabled = new SysUser(); + disabled.setId(id); + disabled.setStatus(UserStatus.DISABLED); + if (mapper.updateById(disabled) == 0) throw notFound(); + log.info("后台禁用用户 userCode={} requestId={}", user.getUserCode(), RequestIdHolder.get()); } private void apply(SysUser user, SaveUserRequest request) { - user.setPhone(request.phone().trim()); + user.setEmail(request.email()); user.setNickname(request.nickname().trim()); user.setStatus(request.status() == null ? (user.getStatus() == null ? UserStatus.ACTIVE : user.getStatus()) : request.status()); user.setUserType(request.userType() == null ? (user.getUserType() == null ? UserType.NORMAL : user.getUserType()) : request.userType()); @@ -86,8 +107,8 @@ public class UserManagementServiceImpl implements UserManagementService { } private BizException notFound() { return new BizException(404, "USER_NOT_FOUND", "用户不存在"); } - private BizException duplicatePhone() { return new BizException(409, "USER_PHONE_DUPLICATE", "手机号已存在,包括已删除的用户"); } + private BizException duplicateEmail() { return new BizException(409, "USER_EMAIL_DUPLICATE", "邮箱已存在"); } private UserResponse response(SysUser user) { - return new UserResponse(user.getId(), user.getPhone(), user.getNickname(), user.getStatus(), user.getUserType(), user.getCreatedAt(), user.getUpdatedAt()); + return new UserResponse(user.getId(), user.getUserCode(), user.getEmail(), user.getNickname(), user.getStatus(), user.getUserType(), user.getCreatedAt(), user.getUpdatedAt()); } } diff --git a/cadworld-service/src/main/java/com/linkerbot/cadworld/service/support/UserCodes.java b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/support/UserCodes.java new file mode 100644 index 0000000..17b0d40 --- /dev/null +++ b/cadworld-service/src/main/java/com/linkerbot/cadworld/service/support/UserCodes.java @@ -0,0 +1,13 @@ +package com.linkerbot.cadworld.service.support; + +import java.util.Locale; +import java.util.UUID; + +public final class UserCodes { + private UserCodes() { + } + + public static String generate() { + return UUID.randomUUID().toString().replace("-", "").toUpperCase(Locale.ROOT); + } +} diff --git a/cadworld-service/src/test/java/com/linkerbot/cadworld/service/auth/LoginUserServiceTest.java b/cadworld-service/src/test/java/com/linkerbot/cadworld/service/auth/LoginUserServiceTest.java new file mode 100644 index 0000000..fdb3401 --- /dev/null +++ b/cadworld-service/src/test/java/com/linkerbot/cadworld/service/auth/LoginUserServiceTest.java @@ -0,0 +1,82 @@ +package com.linkerbot.cadworld.service.auth; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.linkerbot.cadworld.common.exception.BizException; +import com.linkerbot.cadworld.entity.SysUser; +import com.linkerbot.cadworld.enums.UserStatus; +import com.linkerbot.cadworld.enums.UserType; +import com.linkerbot.cadworld.mapper.SysUserMapper; +import org.junit.jupiter.api.Test; +import org.springframework.dao.DuplicateKeyException; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +class LoginUserServiceTest { + private final SysUserMapper mapper = mock(SysUserMapper.class); + private final LoginUserService service = new LoginUserService(mapper); + + @Test + void firstLoginCreatesNormalUserWithNormalizedEmailAndOpaqueCode() { + SysUser user = service.login(" USER@EXAMPLE.TEST "); + assertThat(user.getEmail()).isEqualTo("user@example.test"); + assertThat(user.getUserCode()).matches("[A-F0-9]{32}"); + assertThat(user.getStatus()).isEqualTo(UserStatus.ACTIVE); + assertThat(user.getUserType()).isEqualTo(UserType.NORMAL); + assertThat(user.getNickname()).isEqualTo("用户_" + user.getUserCode().substring(0, 8)); + } + + @Test + void concurrentEmailInsertReusesCommittedUser() { + SysUser existing = existing(UserStatus.ACTIVE); + when(mapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(null, existing); + when(mapper.insert(any(SysUser.class))).thenThrow(new DuplicateKeyException("test duplicate")); + assertThat(service.login("user@example.test")).isSameAs(existing); + verify(mapper, times(1)).insert(any(SysUser.class)); + } + + @Test + void concurrentInsertStillChecksDisabledStatus() { + when(mapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(null, existing(UserStatus.DISABLED)); + when(mapper.insert(any(SysUser.class))).thenThrow(new DuplicateKeyException("test duplicate")); + assertThatThrownBy(() -> service.login("user@example.test")).isInstanceOfSatisfying(BizException.class, + exception -> assertThat(exception.getCode()).isEqualTo("ACCOUNT_DISABLED")); + } + + @Test + void codeCollisionRetriesAndIsBounded() { + when(mapper.insert(any(SysUser.class))).thenThrow(new DuplicateKeyException("test duplicate")); + when(mapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(1L); + assertThatThrownBy(() -> service.login("user@example.test")).isInstanceOfSatisfying(BizException.class, + exception -> assertThat(exception.getCode()).isEqualTo("USER_CODE_EXHAUSTED")); + verify(mapper, times(5)).insert(any(SysUser.class)); + } + + @Test + void codeCollisionCanRecover() { + when(mapper.insert(any(SysUser.class))).thenThrow(new DuplicateKeyException("test duplicate")).thenReturn(1); + when(mapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(1L); + assertThat(service.login("user@example.test").getUserCode()).matches("[A-F0-9]{32}"); + verify(mapper, times(2)).insert(any(SysUser.class)); + } + + @Test + void unexpectedDuplicatePropagates() { + when(mapper.insert(any(SysUser.class))).thenThrow(new DuplicateKeyException("test duplicate")); + when(mapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(0L); + assertThatThrownBy(() -> service.login("user@example.test")).isInstanceOf(DuplicateKeyException.class); + verify(mapper, times(1)).insert(any(SysUser.class)); + } + + private SysUser existing(UserStatus status) { + SysUser user = new SysUser(); + user.setUserCode("A".repeat(32)); + user.setStatus(status); + return user; + } +}