fix(鉴权): 任务归属身份从会话推导,user_id 与不符即 403

客户端任务接口原先把"这单是谁的"交给调用方自报:请求体/查询串带 user_id,服务端拿它当范围
条件。身份应只信会话(JWT),桌面执行器与内部代理通道也不例外:

- AdminAuthSupport 增加 mayActForOtherUsers / resolveOwnershipUserId /
  requireOwnershipUserId / bindOwnershipUserId:会话身份与请求 user_id 不一致直接 403,
  只有平台超管与被授权管理员能代他人;
- 上架(PublishController/PublishTaskService)先接:user_id 缺失即 401,
  仅两个桌面执行器端点允许留空;外观专利/相似 ASIN 的归属谓词补上
  Objects.equals(userId, task.getUserId()),不再只比 moduleType;
- AdminApiGuardFilter 把入口口径与新helper 对齐,护栏测试 AdminAuthSupportOwnershipTest +
  PublishOwnershipGuardrailTest 双向钉(放行面与拒绝面都有样本)。

同族的进度类模块(原先仍以请求体 user_id 为范围)在 cp-item7 一次接完;这一支只管会改状态/花钱的出口。
另外 resolveOwnershipUserId 的 [ownership-anonymous] 日志按 URI 限流也在这支——桌面执行器 4.0.44
不带凭据,只有分得清是哪个端点在打匿名请求,才敢逐支把它们从 resolve 换成 require。
This commit is contained in:
2026-10-07 20:01:10 +08:00
parent 54411c6446
commit 7c7a7f2665
9 changed files with 577 additions and 43 deletions
@@ -21,6 +21,8 @@ import org.springframework.beans.factory.annotation.Value;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@Slf4j
@Component
@@ -159,7 +161,7 @@ public class AdminAuthSupport {
return grants != null && grants > 0;
}
/** 计算当前用户的管理角色:super_admin / admin / null。 */
/** 计算当前用户的管理角色:super_admin / company_super_admin / admin / null(老数据 role 为空时按 is_admin + created_by_id 推断)。 */
public String currentRole(AdminUserEntity user) {
if (user == null) {
return null;
@@ -193,6 +195,93 @@ public class AdminAuthSupport {
}
}
/**
* 该身份能否代他人操作数据:三个管理角色(super_admin / company_super_admin / admin)的本职
* 就是按客户查任务,参与归属绑定只会挡掉正当功能。
*
* <p>2026-10-07 口径:company_super_admin 与 super_admin 在业务数据面逻辑一致,差别只在管理动作。
* 因此这里按"有管理角色即豁免"判定,不逐个列角色名——上一版只列了 admin/super_admin,
* 公司超管在网页端按客户查任务会被自己的守卫挡成 403。</p>
*/
public boolean mayActForOtherUsers(AdminUserEntity identity) {
return currentRole(identity) != null;
}
/**
* 归属用户 id 以<b>会话身份</b>为准,请求参数退化为兼容性输入。
*
* <p>解析得出身份时:参数缺省就用会话 id("省略 user_id 时由 taskId 反查"从此不再是无归属通道);
* 参数与会话不一致直接 403(数据归属不再由请求参数说了算);管理角色豁免。
* 解析不出身份时原样返回参数——桌面客户端不带凭据也不带 operatorId,这条给它们留滚动窗口,
* "必须带凭据"那一步由 aiimage.security.user-tool-guard-enabled 开关控制。</p>
*/
public Long resolveOwnershipUserId(HttpServletRequest request, Long requestedUserId) {
AdminUserEntity identity;
try {
identity = requireUserOrInternal(request);
} catch (BusinessException noIdentity) {
logAnonymousOwnershipFallback(request, requestedUserId);
return requestedUserId;
}
return bindOwnershipUserId(identity, requestedUserId);
}
/** 匿名兜底日志的节流窗口(每个 uri 一分钟内只打一条)。 */
private static final long ANONYMOUS_FALLBACK_LOG_INTERVAL_MILLIS = 60_000L;
private static final Map<String, Long> LAST_ANONYMOUS_FALLBACK_AT = new ConcurrentHashMap<>();
/**
* 记下「这一笔归属判定是靠请求参数过的」——它就是匿名执行器通道<b>还在被哪条端点用</b>的
* 直接计数,也是 {@code PublishController.items} 那类端点能不能从 resolve 翻成 require 的唯一现网证据。
*
* <p>节流必须按 uri 分桶:全局一分钟一条的话,39 条新接上的写类端点会互相挤掉,
* 归零判据就只剩下"猜"——那正是 2026-10-02 通知放大事故的反面(那次是不节流刷屏,这次是不能不节流)。</p>
*
* <p>翻 require 的前置条件不是日期而是<b>这条 uri 的日志归零</b>:客户端 4.0.45 起才会给自家 Java
* 调用带上登录 JWT({@code crawler_core/user_token.py} 的请求钩子仍未出厂),现在翻会把已装机的
* 执行器整批打成 401。</p>
*/
private void logAnonymousOwnershipFallback(HttpServletRequest request, Long requestedUserId) {
String uri = request.getRequestURI();
long now = System.currentTimeMillis();
Long previous = LAST_ANONYMOUS_FALLBACK_AT.get(uri);
if (previous != null && now - previous < ANONYMOUS_FALLBACK_LOG_INTERVAL_MILLIS) {
return;
}
if (previous == null) {
if (LAST_ANONYMOUS_FALLBACK_AT.putIfAbsent(uri, now) != null) {
return;
}
} else if (!LAST_ANONYMOUS_FALLBACK_AT.replace(uri, previous, now)) {
return;
}
log.warn("[ownership-anonymous] 无身份,按参数定归属 uri={} user_id={}", uri, requestedUserId);
}
/**
* {@link #resolveOwnershipUserId} 的 fail-closed 版本:解析不出身份就是 401。
*
* <p>只用于<b>已取证没有匿名调用方</b>的端点——调用方一律是带 JWT 的网页端/后台,
* 桌面执行器不碰它们。这类端点此前 user_id 可选或不传,匿名请求即可读写他人任务;
* 改用本方法后"没登录"和"冒名"都拿不到数据,且不影响真正带凭据的执行器接口。</p>
*/
public Long requireOwnershipUserId(HttpServletRequest request, Long requestedUserId) {
return bindOwnershipUserId(requireUserOrInternal(request), requestedUserId);
}
private Long bindOwnershipUserId(AdminUserEntity identity, Long requestedUserId) {
if (mayActForOtherUsers(identity)) {
return requestedUserId;
}
if (requestedUserId == null) {
return identity.getId();
}
if (!requestedUserId.equals(identity.getId())) {
throw new BusinessException(403, "无权访问该 user_id 的数据:登录账号与请求参数不一致,请重新登录");
}
return requestedUserId;
}
/**
* Flask 传统后台用 session 登录、无法签发 Java JWT,只能凭共享密钥
* (显式配置或每个用户的本地 token 文件)标识已认证管理员。这里仍会
@@ -94,6 +94,12 @@ public class AdminApiGuardFilter extends OncePerRequestFilter {
// /api/tasks/{taskId}/interrupted 仅凭 taskId 即可把 RUNNING 任务置为 FAILED,
// 匿名遍历 taskId 就能批量打断线上任务
"/api/tasks",
// 2026-10-07 补:上架此前完全在守卫范围之外——12 个端点没有一个出现在兜底名单里,
// 控制器也不调 require*。取证:网页端 activate 三兄弟根本不传 user_id
// (frontend-vue/src/shared/api/types/modules/publish.ts),桌面执行器只调
// items 与 result(app_client/amazon/add_product.py:973,1048),所以带 JWT 的
// 请求一旦被解析出身份就得按会话归属对齐,匿名执行器路径行为不变。
"/api/publish",
};
/**
@@ -239,10 +245,9 @@ public class AdminApiGuardFilter extends OncePerRequestFilter {
}
}
/** 管理员/超管本来就是代客操作的(后台按客户查任务是常态),不参与绑定。 */
/** 管理角色本来就是代客操作的(后台按客户查任务是常态),不参与绑定。 */
private boolean mayActForOtherUsers(AdminUserEntity identity) {
String role = adminAuthSupport.currentRole(identity);
return "admin".equals(role) || "super_admin".equals(role);
return adminAuthSupport.mayActForOtherUsers(identity);
}
private void writeFailure(HttpServletResponse response, Integer code, String message) throws IOException {
@@ -287,7 +287,7 @@ public class AppearancePatentTaskService {
@Transactional
public void activateTask(Long taskId, Long userId) {
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || userId != null && !Objects.equals(userId, task.getUserId())) {
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || !Objects.equals(userId, task.getUserId())) {
throw new BusinessException("任务不存在");
}
// 2026-09-30 起外观专利已整体迁移 Linux 后台执行(无浏览器抓取):
@@ -3158,7 +3158,7 @@ public class AppearancePatentTaskService {
public AppearancePatentParsedPayloadDto queuePayload(Long taskId, Long userId) {
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || userId != null && !Objects.equals(userId, task.getUserId())) {
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || !Objects.equals(userId, task.getUserId())) {
throw new BusinessException("任务不存在");
}
ensureTaskOwnedByCurrentInstance(task, "queue payload");
@@ -44,25 +44,28 @@ public class PublishController {
description = "按文件名(去扩展名)先匹配已管理店铺,再查询紫鸟索引;解析每个非空 Sheet。源文件前五列表头必须依次为 id、ASIN、国家、品牌、价格,第六列及以后不解析;状态、同步状态、同步国家由 Python 回传并写入最终结果文件。匹配并解析成功的文件为 PENDING,失败文件为 FAILED;只要存在可处理文件,任务为 PENDING,否则任务为 FAILED。")
public ApiResponse<PublishParseVo> parse(@Valid @RequestBody PublishParseRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(publishTaskService.parseAndCreateTask(request,
adminAuthSupport.currentDeviceId(httpRequest)));
}
@PostMapping("/tasks/{taskId}/activate")
@Operation(summary = "激活上架任务", description = "按 taskId 激活上架任务,将状态从 PENDING 修改为 RUNNING。user_id 可省略;如传入则校验任务归属。文件仍需通过单文件激活接口逐个激活。")
@Operation(summary = "激活上架任务", description = "按 taskId 激活上架任务,将状态从 PENDING 修改为 RUNNING。user_id 可省略,省略时按当前登录身份归属;与登录账号不一致即拒绝(管理角色可代客操作)。文件仍需通过单文件激活接口逐个激活。")
public ApiResponse<Void> activateTask(
@Parameter(description = "上架任务 ID", required = true, example = "9001")
@PathVariable Long taskId,
@Parameter(description = "可选的任务所属用户 ID;省略时由 taskId 反查", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId) {
publishTaskService.activateTask(taskId, userId);
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest httpRequest) {
publishTaskService.activateTask(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId));
return ApiResponse.success(null);
}
@PostMapping("/tasks/{taskId}/files/{fileId}/activate")
@Operation(
summary = "激活任务中的单个文件",
description = "前端派发 Python 队列前调用。taskId 和 fileId 用于定位文件,user_id 可省略;如传入则校验任务归属。同一任务同一时间只允许一个 RUNNING 文件;重复激活当前 RUNNING 文件为幂等操作。"
description = "前端派发 Python 队列前调用。taskId 和 fileId 用于定位文件,user_id 可省略,省略时按当前登录身份归属;与登录账号不一致即拒绝(管理角色可代客操作)。同一任务同一时间只允许一个 RUNNING 文件;重复激活当前 RUNNING 文件为幂等操作。"
+ "店铺互斥按 (发起方设备, 店铺) 判定:同一台机器上同一店铺只允许一个任务在跑(该机器上该店铺只有一个紫鸟浏览器会话,并发会互相切换国家);不同设备各自持有独立会话,允许同一店铺并行跑不同国家。"
+ "设备号取自 JWT 签名的 deviceId claim,缺失时退回按店铺全局互斥。")
public ApiResponse<Void> activateFile(
@@ -70,29 +73,33 @@ public class PublishController {
@PathVariable Long taskId,
@Parameter(description = "任务内文件 ID", required = true, example = "9101")
@PathVariable Long fileId,
@Parameter(description = "可选的任务所属用户 ID;省略时由 taskId 反查", required = false, example = "1")
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest request) {
publishTaskService.activateFile(taskId, fileId, userId, adminAuthSupport.currentDeviceId(request));
HttpServletRequest httpRequest) {
publishTaskService.activateFile(taskId, fileId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId),
adminAuthSupport.currentDeviceId(httpRequest));
return ApiResponse.success(null);
}
@GetMapping("/tasks/{taskId}/items")
@Operation(
summary = "按文件分页获取上架原始数据,供 Python 拉取",
description = "Python 只需提供 taskId、file_id、page 和 page_size;后端按 taskId 反查任务所属用户并返回原 Excel 行序数据,同时携带店铺信息、发布国家和同步国家。user_id 仅作为旧客户端的可选归属校验。页码从 1 开始,每页最多 200 行。")
description = "Python 只需提供 taskId、file_id、page 和 page_size;后端按 taskId 反查任务所属用户并返回原 Excel 行序数据,同时携带店铺信息、发布国家和同步国家。user_id 仅作为旧客户端的可选归属校验:不带凭据的执行器照旧按 taskId 取数,带 JWT 的请求必须与登录身份一致。页码从 1 开始,每页最多 200 行。")
public ApiResponse<PublishItemsPageVo> items(
@Parameter(description = "上架任务 ID", required = true, example = "9001")
@PathVariable Long taskId,
@Parameter(description = "可选的任务所属用户 ID;省略时由 taskId 反查", required = false, example = "1")
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
@Parameter(description = "任务内文件 ID", required = true, example = "9101")
@RequestParam("file_id") Long fileId,
@Parameter(description = "页码,从 1 开始", example = "1")
@RequestParam(value = "page", defaultValue = "1") Integer page,
@Parameter(description = "每页条数,默认 50,最大 200", example = "50")
@RequestParam(value = "page_size", defaultValue = "50") Integer pageSize) {
return ApiResponse.success(publishTaskService.getItemsPage(taskId, userId, fileId, page, pageSize));
@RequestParam(value = "page_size", defaultValue = "50") Integer pageSize,
HttpServletRequest httpRequest) {
return ApiResponse.success(publishTaskService.getItemsPage(taskId,
adminAuthSupport.resolveOwnershipUserId(httpRequest, userId), fileId, page, pageSize));
}
@GetMapping("/tasks/{taskId}")
@@ -100,26 +107,30 @@ public class PublishController {
public ApiResponse<PublishTaskDetailVo> task(
@Parameter(description = "上架任务 ID", required = true, example = "9001")
@PathVariable Long taskId,
@Parameter(description = "可选的任务所属用户 ID;省略时由 taskId 反查", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId) {
return ApiResponse.success(publishTaskService.getTaskDetail(taskId, userId));
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest httpRequest) {
return ApiResponse.success(publishTaskService.getTaskDetail(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId)));
}
@PostMapping("/tasks/progress/batch")
@Operation(
summary = "批量获取任务、文件进度和最终结果",
description = "按 task_ids 批量返回任务、文件进度和最终结果。task_ids 会过滤空值和非正数、去重并最多处理前 50 个;user_id 可省略,省略时按任务 ID 查询,传入时仅返回该用户的任务,未找到的 ID 放入 missingTaskIds。")
description = "按 task_ids 批量返回任务、文件进度和最终结果。task_ids 会过滤空值和非正数、去重并最多处理前 50 个;必须携带登录身份(网页端/后台);user_id 可省略,省略时按当前登录身份过滤,未找到的 ID 放入 missingTaskIds。")
public ApiResponse<PublishTaskBatchVo> progressBatch(
@Valid @RequestBody PublishTaskBatchRequest request) {
@Valid @RequestBody PublishTaskBatchRequest request, HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(publishTaskService.getTaskProgress(request.getUserId(), request.getTaskIds()));
}
@PostMapping("/tasks/progress/light")
@Operation(summary = "批量查询任务轻量进度(前端轮询专用)",
description = "与 progress/batch 同输入,只返回轻量字段(taskId/status/statusCode/fileStatus/fileError/fileReady/updatedAt/rowsVersion),"
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。user_id 可省略,传入时仅返回该用户的任务。")
+ "不返回行明细内容(仅多一次结果行版本聚合查询),响应体更小;旧 progress/batch 端点保留不动。必须携带登录身份(网页端/后台);user_id 可省略,省略时按当前登录身份过滤。")
public ApiResponse<TaskProgressLightBatchVo> progressLight(
@Valid @RequestBody TaskProgressLightRequest request) {
@Valid @RequestBody TaskProgressLightRequest request, HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.requireOwnershipUserId(httpRequest, request.getUserId()));
return ApiResponse.success(publishTaskService.progressLight(request.getUserId(), request.getTaskIds()));
}
@@ -130,7 +141,9 @@ public class PublishController {
public ApiResponse<Void> submitResult(
@Parameter(description = "上架任务 ID", required = true, example = "9001")
@PathVariable Long taskId,
@Valid @RequestBody PublishSubmitResultRequest request) {
@Valid @RequestBody PublishSubmitResultRequest request,
HttpServletRequest httpRequest) {
request.setUserId(adminAuthSupport.resolveOwnershipUserId(httpRequest, request.getUserId()));
publishTaskService.submitResult(taskId, request);
return ApiResponse.success(null);
}
@@ -138,31 +151,37 @@ public class PublishController {
@GetMapping("/dashboard")
@Operation(summary = "获取上架任务总览", description = "返回当前用户各状态任务数量和最近任务详情。")
public ApiResponse<PublishDashboardVo> dashboard(
@Parameter(description = "当前用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
return ApiResponse.success(publishTaskService.dashboard(userId));
@Parameter(description = "当前登录用户 ID;服务端按会话身份校验,与登录账号不一致即拒绝", required = true, example = "1")
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
return ApiResponse.success(publishTaskService.dashboard(
adminAuthSupport.requireOwnershipUserId(httpRequest, userId)));
}
@GetMapping("/history")
@Operation(summary = "获取上架任务历史", description = "按创建时间倒序返回当前用户的任务详情,最多返回 100 条。")
public ApiResponse<PublishHistoryVo> history(
@Parameter(description = "当前用户 ID", required = true, example = "1")
@Parameter(description = "当前登录用户 ID;服务端按会话身份校验,与登录账号不一致即拒绝", required = true, example = "1")
@RequestParam("user_id") Long userId,
@Parameter(description = "返回数量上限,默认 50,最大 100", example = "50")
@RequestParam(value = "limit", defaultValue = "50") Integer limit) {
@RequestParam(value = "limit", defaultValue = "50") Integer limit,
HttpServletRequest httpRequest) {
// 上限钳制(2026-09):文档写"最多返回 100 条"但此前无实际校验
int safeLimit = limit == null ? 100 : Math.min(Math.max(1, limit), 100);
return ApiResponse.success(publishTaskService.history(userId, safeLimit));
return ApiResponse.success(publishTaskService.history(
adminAuthSupport.requireOwnershipUserId(httpRequest, userId), safeLimit));
}
@DeleteMapping("/tasks/{taskId}")
@Operation(summary = "删除上架任务", description = "按 taskId 删除任务、文件明细、解析行、结果记录和关联结果文件 Job。user_id 可省略;如传入则校验任务归属。")
@Operation(summary = "删除上架任务", description = "按 taskId 删除任务、文件明细、解析行、结果记录和关联结果文件 Job。user_id 可省略,省略时按当前登录身份归属;与登录账号不一致即拒绝(管理角色可代客操作)。")
public ApiResponse<Void> deleteTask(
@Parameter(description = "上架任务 ID", required = true, example = "9001")
@PathVariable Long taskId,
@Parameter(description = "可选的任务所属用户 ID;省略时由 taskId 反查", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId) {
publishTaskService.deleteTask(taskId, userId);
@Parameter(description = "任务所属用户 ID;省略时取当前登录身份", required = false, example = "1")
@RequestParam(value = "user_id", required = false) Long userId,
HttpServletRequest httpRequest) {
publishTaskService.deleteTask(taskId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId));
return ApiResponse.success(null);
}
@@ -171,9 +190,11 @@ public class PublishController {
public ApiResponse<Void> deleteHistory(
@Parameter(description = "上架结果记录 ID", required = true, example = "9201")
@PathVariable Long resultId,
@Parameter(description = "结果所属用户 ID", required = true, example = "1")
@RequestParam("user_id") Long userId) {
publishTaskService.deleteHistory(resultId, userId);
@Parameter(description = "结果所属用户 ID;必须与登录账号一致(管理角色可代客操作)", required = true, example = "1")
@RequestParam("user_id") Long userId,
HttpServletRequest httpRequest) {
publishTaskService.deleteHistory(resultId,
adminAuthSupport.requireOwnershipUserId(httpRequest, userId));
return ApiResponse.success(null);
}
}
@@ -1356,6 +1356,10 @@ public class PublishTaskService {
if (taskId == null || taskId <= 0) {
throw new BusinessException("taskId 不合法");
}
// user_id 为空**不**等于跳过归属校验:这里留空只允许出现在桌面执行器的两个端点上
// (GET /tasks/{id}/items 与 POST /tasks/{id}/result,它们带 X-Internal-Token 但不带 operatorId,
// 服务端解析不出身份)。其余端点一律由 PublishController 用 requireOwnershipUserId 传入会话身份,
// 缺失即 401、冒名即 403。
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !MODULE_TYPE.equals(task.getModuleType())
|| (userId != null && !userId.equals(task.getUserId()))) {
@@ -543,7 +543,7 @@ public class SimilarAsinTaskService implements SimilarAsinPipelineHost {
public void activateTask(Long taskId, Long userId) {
try (TaskDistributedLockService.LockHandle ignored = ownershipSupport().requireTaskLock(taskId, TASK_LOCK_WAIT_MILLIS)) {
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || userId != null && !Objects.equals(userId, task.getUserId())) {
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || !Objects.equals(userId, task.getUserId())) {
throw new BusinessException("任务不存在");
}
ownershipSupport().ensureTaskOwnedByCurrentInstance(task, "activate");
@@ -1726,7 +1726,7 @@ public class SimilarAsinTaskService implements SimilarAsinPipelineHost {
public SimilarAsinParsedPayloadDto parsedPayload(Long taskId, Long userId) {
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || userId != null && !Objects.equals(userId, task.getUserId())) {
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || !Objects.equals(userId, task.getUserId())) {
throw new BusinessException("任务不存在");
}
ownershipSupport().ensureTaskOwnedByCurrentInstance(task, "parsed payload");
@@ -0,0 +1,221 @@
package com.nanri.aiimage.common.security;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import io.jsonwebtoken.Claims;
import org.junit.jupiter.api.Test;
import org.springframework.http.HttpHeaders;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.test.util.ReflectionTestUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.catchThrowableOfType;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
/**
* 归属用户 id 由会话推导(2026-10-07)的六面判定。
*
* <p>背景:用户态工具接口把"这批数据属于谁"完全交给请求参数 {@code user_id},
* 前端从 localStorage 取一个数字填进去,改这个数字就能读别人的任务。
* {@link AdminAuthSupport#resolveOwnershipUserId} 与 {@link AdminAuthSupport#requireOwnershipUserId}
* 把这层关系反过来:先认会话身份,参数只是兼容性输入。</p>
*
* <p>两个变体的分工必须是可证的,否则"fail-closed"只是一句注释:
* resolve 给还带不动凭据的存量客户端留窗口(解析不出身份就原样返回),
* require 只用在已取证**没有匿名调用方**的端点上(解析不出身份即 401)。</p>
*/
class AdminAuthSupportOwnershipTest {
private static final String INTERNAL_TOKEN = "internal-token-value";
// ---------- 会话身份优先:参数缺省 / 一致 / 冒名 ----------
@Test
void sessionIdentityFillsInOmittedUserId() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 0, null));
assertThat(support.resolveOwnershipUserId(jwtRequest("t"), null)).isEqualTo(7L);
}
@Test
void matchingUserIdIsPassedThroughUnchanged() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 0, null));
assertThat(support.resolveOwnershipUserId(jwtRequest("t"), 7L)).isEqualTo(7L);
}
@Test
void foreignUserIdIsRejectedWith403NotSilentlyTrusted() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 0, null));
BusinessException ex = catchThrowableOfType(
() -> support.resolveOwnershipUserId(jwtRequest("t"), 8L), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
assertThat(ex.getMessage()).contains("user_id");
}
/** 冒名在 require 变体上是同一个结果:不能因为"这个端点要求登录"就漏掉归属比对。 */
@Test
void requireVariantRejectsForeignUserIdToo() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 0, null));
BusinessException ex = catchThrowableOfType(
() -> support.requireOwnershipUserId(jwtRequest("t"), 8L), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
}
// ---------- 管理角色豁免:但不得替它凭空造一个归属 ----------
@Test
void adminMayActForAnotherUser() {
AdminAuthSupport support = withJwtUser(user(1L, "admin", 1, 1L));
assertThat(support.resolveOwnershipUserId(jwtRequest("t"), 8L)).isEqualTo(8L);
}
/**
* 公司超管与超管在业务数据面逻辑一致(2026-10-07 口径)。
* 上一版豁免逐个列角色名,漏了 company_super_admin,公司超管在网页端按客户查任务被自己的守卫挡成 403。
*/
@Test
void companySuperAdminIsExemptedToo() {
AdminAuthSupport support = withJwtUser(user(2L, "company_super_admin", 0, 1L));
assertThat(support.resolveOwnershipUserId(jwtRequest("t"), 8L)).isEqualTo(8L);
assertThat(support.mayActForOtherUsers(user(2L, "company_super_admin", 0, 1L))).isTrue();
}
/** 管理角色不传 user_id 时保持"不预设范围",而不是悄悄换成它自己的 id(后台默认看全量)。 */
@Test
void adminOmittingUserIdGetsNoImplicitOwner() {
AdminAuthSupport support = withJwtUser(user(1L, "super_admin", 1, null));
assertThat(support.resolveOwnershipUserId(jwtRequest("t"), null)).isNull();
}
@Test
void ordinaryRoleIsNotExemptedFromBinding() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 1, 1L));
assertThat(support.mayActForOtherUsers(user(7L, "normal", 1, 1L))).isFalse();
assertThat(support.mayActForOtherUsers(null)).isFalse();
}
// ---------- 两个变体的分界线:解析不出身份时 ----------
/** 存量桌面客户端不带凭据:resolve 必须原样返回,否则线上集采/跟价整条 401。 */
@Test
void resolveKeepsRequestParamWhenNoIdentityResolves() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 0, null));
assertThat(support.resolveOwnershipUserId(new MockHttpServletRequest("GET", "/api/publish/tasks/1/items"), 8L))
.isEqualTo(8L);
}
/** require 正相反:没登录就没有"归属"可谈,直接 401。 */
@Test
void requireRejectsAnonymousWith401() {
AdminAuthSupport support = withJwtUser(user(7L, "normal", 0, null));
BusinessException ex = catchThrowableOfType(
() -> support.requireOwnershipUserId(new MockHttpServletRequest("GET", "/api/publish/dashboard"), 8L),
BusinessException.class);
assertThat(ex.getCode()).isEqualTo(401);
}
// ---------- 内部令牌不是冒名通行证 ----------
/**
* X-Internal-Token + operatorId 解析得出身份后按该身份绑定:令牌是硬编码在分发包里的静态密钥,
* 证明得了"走了内部通道",证明不了"这个 user_id 是谁"。
*/
@Test
void internalOperatorIsBoundToItsOwnIdentity() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.selectById(3L)).thenReturn(user(3L, "normal", 0, null));
AdminAuthSupport support = internalTokenSupport(userMapper);
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/publish/tasks/1/items");
request.addHeader("X-Internal-Token", INTERNAL_TOKEN);
request.setParameter("operatorId", "3");
BusinessException ex = catchThrowableOfType(
() -> support.resolveOwnershipUserId(request, 8L), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
}
/** 纯令牌(不带 JWT、不带 operatorId)解析不出身份 —— 这条形状是存量客户端的实际形态,必须零影响。 */
@Test
void internalTokenWithoutOperatorIdStaysUnbound() {
AdminAuthSupport support = internalTokenSupport(defaultMapper());
MockHttpServletRequest request = new MockHttpServletRequest("POST", "/api/publish/tasks/1/result");
request.addHeader("X-Internal-Token", INTERNAL_TOKEN);
assertThat(support.resolveOwnershipUserId(request, 8L)).isEqualTo(8L);
}
@Test
void untrustedTokenIsNotAnInternalIdentity() {
AdminAuthSupport support = internalTokenSupport(defaultMapper());
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/publish/dashboard");
request.addHeader("X-Internal-Token", "guessed-token");
assertThat(support.resolveOwnershipUserId(request, 8L)).isEqualTo(8L);
BusinessException ex = catchThrowableOfType(
() -> support.requireOwnershipUserId(request, 8L), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(401);
}
// ---------- 夹具 ----------
private AdminUserMapper defaultMapper() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.selectById(any())).thenReturn(null);
return userMapper;
}
/** 只装内部令牌通道:JWT 一律解析失败,用来单独验操作者身份那半条链。 */
private AdminAuthSupport internalTokenSupport(AdminUserMapper userMapper) {
JwtService jwtService = mock(JwtService.class);
when(jwtService.parse(any())).thenReturn(null);
AdminAuthSupport support = new AdminAuthSupport(
jwtService, userMapper, mock(AuthProperties.class), mock(AccountExpiryService.class));
ReflectionTestUtils.setField(support, "internalToken", INTERNAL_TOKEN);
ReflectionTestUtils.setField(support, "internalTokenFile", "");
return support;
}
private AdminAuthSupport withJwtUser(AdminUserEntity user) {
JwtService jwtService = mock(JwtService.class);
Claims claims = mock(Claims.class);
when(claims.getSubject()).thenReturn(String.valueOf(user.getId()));
when(jwtService.parse("t")).thenReturn(claims);
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.selectById(user.getId())).thenReturn(user);
AuthProperties props = mock(AuthProperties.class);
when(props.isSingleDeviceEnabled()).thenReturn(false);
return new AdminAuthSupport(jwtService, userMapper, props, mock(AccountExpiryService.class));
}
private MockHttpServletRequest jwtRequest(String token) {
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/publish/dashboard");
request.addHeader(HttpHeaders.AUTHORIZATION, "Bearer " + token);
return request;
}
private AdminUserEntity user(Long id, String role, int isAdmin, Long createdById) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
user.setUsername("u" + id);
user.setRole(role);
user.setIsAdmin(isAdmin);
user.setCreatedById(createdById);
return user;
}
}
@@ -425,7 +425,9 @@ class AdminApiGuardFilterTest {
void adminJwtMayActForAnotherUser() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.requireUserOrInternal(any())).thenReturn(user(1L, "admin"));
when(authSupport.currentRole(any())).thenReturn("admin");
// 豁免判定只有一个出口(AdminAuthSupport.mayActForOtherUsers),守卫不再自己抄一份角色名单:
// 上一版这里 stub currentRole,改成委托后如果谁把两处又写回各判各的,这两支会一起红。
when(authSupport.mayActForOtherUsers(any())).thenReturn(true);
AdminApiGuardFilter filter = newFilter(authSupport, true, "", false);
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/query-asin/tasks/detail");
request.setParameter("user_id", "8");
@@ -435,6 +437,7 @@ class AdminApiGuardFilterTest {
filter.doFilter(request, response, chain);
assertThat(chain.getRequest()).isNotNull();
verify(authSupport).mayActForOtherUsers(any());
}
/** 桌面端不带 JWT、也就没有身份可绑:这条约束对存量匿名客户端零影响。 */
@@ -556,7 +559,7 @@ class AdminApiGuardFilterTest {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.isTrustedInternalToken(any())).thenReturn(true);
when(authSupport.requireUserOrInternal(any())).thenReturn(user(1L, "admin"));
when(authSupport.currentRole(any())).thenReturn("admin");
when(authSupport.mayActForOtherUsers(any())).thenReturn(true);
AdminApiGuardFilter filter = newFilter(authSupport, true, "", false);
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/query-asin/tasks/detail");
request.setParameter("user_id", "8");
@@ -568,6 +571,63 @@ class AdminApiGuardFilterTest {
assertThat(chain.getRequest()).isNotNull();
}
// ---- /api/publish 纳入绑定(2026-10-07)----
// 取证:网页端调 publish 的 activate 三兄弟时**根本不传 user_id**
// (frontend-vue/src/shared/api/types/modules/publish.ts:180,189),桌面执行器只调
// items 与 result(app_client/amazon/add_product.py:973,1048)。此前 publish 一个都不在
// 守卫名单里,控制器也不 require*,匿名请求即可激活/删除任意任务。
@Test
void publishJwtCannotReadAnotherUsersItems() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.requireUserOrInternal(any())).thenReturn(user(7L, "normal"));
when(authSupport.mayActForOtherUsers(any())).thenReturn(false);
AdminApiGuardFilter filter = newFilter(authSupport, true, "", false);
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/publish/tasks/9001/items");
request.setParameter("user_id", "8");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
assertThat(chain.getRequest()).as("带 JWT 却填别人的 user_id 必须挡下").isNull();
JsonNode body = objectMapper.readTree(response.getContentAsString());
assertThat(body.path("code").asInt()).isEqualTo(403);
}
/** 不带凭据的执行器(X-Internal-Token、无 operatorId、无 user_id)解析不出身份,绑定不触发。 */
@Test
void publishExecutorRequestWithoutIdentityIsNotBound() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
when(authSupport.isTrustedInternalToken(any())).thenReturn(true);
when(authSupport.requireUserOrInternal(any())).thenThrow(new BusinessException(401, "未登录"));
AdminApiGuardFilter filter = newFilter(authSupport, true, "", false);
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/publish/tasks/9001/items");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
assertThat(chain.getRequest()).isNotNull();
assertThat(response.getContentAsString()).isEmpty();
}
/** 前缀边界:/publishing-tools 这类同前缀名字不能被卷进来。 */
@Test
void publishLikeOtherPathsAreNotSweptIn() throws Exception {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
AdminApiGuardFilter filter = newFilter(authSupport, true, "", false);
MockHttpServletRequest request = new MockHttpServletRequest("GET", "/api/publishing-tools/list");
request.setParameter("user_id", "8");
MockHttpServletResponse response = new MockHttpServletResponse();
MockFilterChain chain = new MockFilterChain();
filter.doFilter(request, response, chain);
assertThat(chain.getRequest()).isNotNull();
verify(authSupport, never()).requireUserOrInternal(any());
}
private AdminUserEntity user(Long id, String role) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
@@ -0,0 +1,134 @@
package com.nanri.aiimage.modules.publish.controller;
import com.nanri.aiimage.testutil.SourceScan;
import org.junit.jupiter.api.Test;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import static org.assertj.core.api.Assertions.assertThat;
/**
* 上架(publish)归属绑定的绊线(2026-10-07)。
*
* <p>publish 此前的形状:12 个端点没有一个在兜底守卫名单里,控制器不调 require*,
* {@code user_id} 要么可选要么由前端从 localStorage 取——也就是"数据属于谁"完全由请求说了算。
* 本轮收口后的形状必须是可证的,否则下次有人"顺手"改回参数判定不会有任何东西变红:</p>
*
* <ol>
* <li>带 user_id 的端点分母钉死(查询参数 8 个 + 请求体 4 个 = 12 个走会话推导)。
* 其中 10 个走 {@code requireOwnershipUserId}(解析不出登录身份即 401,网页端/后台专用),
* 2 个走 {@code resolveOwnershipUserId}——只有执行器可达的 {@code items}(取数)和
* {@code result}(回传):桌面端只带 X-Internal-Token、不带 operatorId,给它俩加 require
* 等于把上架整条链路挡在 401。resolve 对匿名请求是原样透传,对带凭据的请求仍然冒名即 403。</li>
* <li>"null 即跳过归属校验"这个形状在服务层只能剩 1 处(publish 的 requireTaskRecord,
* 为执行器留的口子),外观专利与货源的 4 处已改为无条件比对。</li>
* </ol>
*
* <p>数字判据一律打在 {@link SourceScan#withoutComments} 上:javadoc 里提一句 {@code requireOwnershipUserId}
* 就能把"次数等于 N"喂成假绿。只有"豁免必须写明理由"那支刻意吃原文,因为它要钉的就是注释本身。</p>
*/
class PublishOwnershipGuardrailTest {
private static final Pattern QUERY_USER_ID = Pattern.compile(
"@RequestParam\\(\\s*(?:value\\s*=\\s*)?\"user_id\"[^)]*\\)\\s+Long\\s+\\w+");
@Test
void everyUserIdCarryingPublishEndpointIsDerivedFromSession() {
String controller = SourceScan.withoutComments(SourceScan.sourceText("PublishController.java"));
Matcher query = QUERY_USER_ID.matcher(controller);
int queryBindings = 0;
while (query.find()) {
queryBindings++;
}
assertThat(queryBindings)
.as("publish 控制器里 user_id 查询参数绑定数")
.isEqualTo(8);
// 请求体里带 user_id 的四个:parse / progress/batch / progress/light / result
long bodyBindings = Stream.of("PublishParseRequest request",
"PublishTaskBatchRequest request",
"TaskProgressLightRequest request",
"PublishSubmitResultRequest request")
.filter(controller::contains)
.count();
assertThat(bodyBindings).as("publish 控制器里请求体带 user_id 的端点数").isEqualTo(4);
int require = count(controller, "adminAuthSupport.requireOwnershipUserId(");
int resolve = count(controller, "adminAuthSupport.resolveOwnershipUserId(");
assertThat(require)
.as("requireOwnershipUserId 调用数(网页端/后台专用,解析不出身份即 401)")
.isEqualTo(10);
assertThat(resolve)
.as("resolveOwnershipUserId 调用数(执行器可达的两条:items 取数、result 回传)")
.isEqualTo(2);
assertThat(require + resolve)
.as("12 个带归属的端点必须逐个接上会话推导,一个都不能只靠请求参数")
.isEqualTo(queryBindings + bodyBindings);
}
/**
* 执行器回传端点是刻意的例外:给它加 require 等于把上架整条链路挡在 401。
*
* <p>反向钉必须配一条正向取样,否则"方法体切不到"和"方法体真的没调用"这两种情况都是绿的。</p>
*/
@Test
void resultSubmissionStaysReachableWithoutLoginIdentity() {
String controller = SourceScan.withoutComments(SourceScan.sourceText("PublishController.java"));
String body = SourceScan.methodBody(controller, "submitResult");
assertThat(body)
.as("submitResult 只能走透传的 resolve(带凭据时依旧校验归属,匿名执行器不被 401)")
.contains("adminAuthSupport.resolveOwnershipUserId(");
assertThat(body)
.as("给 submitResult 加 require 会把无登录身份的桌面执行器挡在 401")
.doesNotContain("requireOwnershipUserId");
}
/** 同理,items 是执行器唯一的取数口,也只能透传、不能 require。 */
@Test
void executorReadPathStaysReachableWithoutLoginIdentity() {
String controller = SourceScan.withoutComments(SourceScan.sourceText("PublishController.java"));
String body = SourceScan.methodBody(controller, "items");
assertThat(body).contains("adminAuthSupport.resolveOwnershipUserId(");
assertThat(body).doesNotContain("requireOwnershipUserId");
}
/**
* "userId != null 才校验归属"在服务层只剩一处出口,且那一处必须带写明理由的注释
* (匿名执行器 items/result 走 requireTaskRecord)。
*/
@Test
void nullSkipsOwnershipCheckOnlyOnTheExecutorReadPath() {
String publishService = SourceScan.sourceText("PublishTaskService.java");
String publishCode = SourceScan.withoutComments(publishService);
String appearanceCode = SourceScan.withoutComments(SourceScan.sourceText("AppearancePatentTaskService.java"));
String similarAsinCode = SourceScan.withoutComments(SourceScan.sourceText("SimilarAsinTaskService.java"));
assertThat(count(appearanceCode, "userId != null && !Objects.equals(userId, task.getUserId())"))
.as("外观专利的两处条件归属校验必须已改成无条件比对")
.isZero();
assertThat(count(similarAsinCode, "userId != null && !Objects.equals(userId, task.getUserId())"))
.as("货源的两处条件归属校验必须已改成无条件比对")
.isZero();
assertThat(count(publishCode, "userId != null && !userId.equals(task.getUserId())"))
.as("publish 保留的那一处是唯一登记在册的口子,多一处就是有人新开了免校验通道")
.isEqualTo(1);
assertThat(publishService)
.as("保留口子必须写明它只服务于哪个匿名执行器路径(这支刻意扫原文:要钉的就是注释)")
.contains("GET /tasks/{id}/items 与 POST /tasks/{id}/result");
}
private static int count(String haystack, String needle) {
int index = 0;
int total = 0;
while ((index = haystack.indexOf(needle, index)) >= 0) {
total++;
index += needle.length();
}
return total;
}
}