fix(鉴权): 到期级联改标量聚合,后台入口按菜单授权放开

三件事同源于 10-06「非默认公司账号进不了数富后台」这条事故链,四种死法在界面上长得一样。

1) AccountExpiryService 读本公司公司超管的 expires_at 时把单列投影成实体列表再遍历——
   MyBatis 对所选列全为 NULL 的行交出的是 null 元素,而"没设到期"是绝大多数公司的常态,
   于是只要有一个永不过期的公司超管,该公司所有账号的登录与每个鉴权请求全部 500。
   改成 mapper 侧一条 MIN(expires_at) 标量聚合;AuthChainQueryShapeTest 扫鉴权链路的
   "单列投影"形状——这个判据落在 mock 边界外,单测挡不住,只能做源码扫描。

2) 后台入口放开:requireConsoleOperator = 管理员角色链 或 本公司树里 >=1 条后台菜单授权
   (探针是带 company_id 条件的标量 COUNT,与下发口径一致,否则进得来而菜单树是空的)。
   逐页另设 requireConsolePageAccess 锚住本页 key,勾父分组覆盖后代的既有语义照旧。
   管理类 10 支控制器继续 requireAdmin,并且出口 2 不再把这些页下发给普通账号——
   下发出去就是一排点了必 403 的死链。内部令牌通道绕过到期与会话校验,不随入口放宽。
   护栏 ConsoleWideningGuardrailTest 双向钉:管理页不得被授权打开、入口落点恰好那 13 支。

3) 前端:后端失败一律 HTTP 200 + success=false,登录页从未解包,所以"什么都不提示"。
   补 login-feedback 归一文案(技术串不外露、兜底不再伪装成用户名或密码错误),
   并修 isLoginLocation 拿路由内路径比 location.pathname——生产实际是 /admin-vue/login,
   那条"已在登录页就别整页重刷"的守卫一次都没生效过。

验证:后端 mvn -o -B test 3924 例 0 红(457 支类);前端 node --test 1738 例 0 红;
vue-tsc --noEmit rc=0;入口探针 SQL 已在生产库只读三档空跑(本公司 1 / 错公司 0 / 无授权 0)。
This commit is contained in:
2026-10-07 00:18:35 +08:00
parent b0444f0903
commit 34113aff8b
32 changed files with 1369 additions and 76 deletions
+14 -2
View File
@@ -1,4 +1,5 @@
/** API 响应解包与错误归一化(任务 22):纯函数,无框架依赖。 */
/** API 响应解包与错误归一化(任务 22):纯函数,无框架依赖(只借 config/app 的 base 常量)。 */
import { joinAdminPath } from '../config/app.ts'
export const REQUEST_FALLBACK_MESSAGE = '网络异常,请稍后重试'
@@ -78,11 +79,22 @@ export function loginRedirectTarget(location: { pathname: string; search: string
/** 登录页统一入口;401 一律跳此路径。 */
export const LOGIN_PATH = '/login'
/**
* 浏览器地址栏里的登录页形态。
*
* <p>LOGIN_PATH 是路由内的相对路径(axios 的 url 也用它比较),而 `window.location.pathname`
* 带 History base,生产实际值是 `/admin-vue/login`。少这一条,"已经在登录页就别再跳"
* 的守卫在真机上一次都没生效过:2026-10-06 那次登录失败,拦截器把整页重刷成
* `/admin-vue/login?redirect=…`,连刚填的用户名和错误原因一起没了。</p>
*/
export const LOGIN_LOCATION_PATH = joinAdminPath('login')
/** 当前 pathname 是否处于登录页(去掉可能携带的查询串后比较)。 */
export function isLoginLocation(pathname: string): boolean {
if (typeof pathname !== 'string') return false
const queryAt = pathname.indexOf('?')
return (queryAt >= 0 ? pathname.slice(0, queryAt) : pathname) === LOGIN_PATH
const path = queryAt >= 0 ? pathname.slice(0, queryAt) : pathname
return path === LOGIN_PATH || path === LOGIN_LOCATION_PATH || path === `${LOGIN_LOCATION_PATH}/`
}
/** 把请求 URL(相对或绝对)规整为相对路径,便于与登录入口比较。 */
@@ -4,6 +4,7 @@ import { computed, onMounted, ref } from 'vue'
import { useRoute, useRouter } from 'vue-router'
import { http } from '@/api/http'
import { joinAdminPath } from '@/config/app'
import { loginErrorText, unwrapLoginResponse } from './login-feedback'
import { useAdminSessionStore } from '@/stores/admin-session'
const route = useRoute()
@@ -59,13 +60,19 @@ async function submit() {
loading.value = true
try {
const did = deviceId()
await http.post<unknown>('/login', { username: user, password: password.value, deviceId: did })
const { data } = await http.post<unknown>('/login', {
username: user,
password: password.value,
deviceId: did,
})
// 后端失败是 HTTP 200 + success=false,不解包就等于没提示
unwrapLoginResponse(data)
session.$reset()
await session.initialize()
const target = safeRedirect(route.query.redirect)
await router.replace(target)
} catch (error) {
errorMessage.value = error instanceof Error && error.message ? error.message : '用户名或密码错误'
errorMessage.value = loginErrorText(error)
loading.value = false
}
}
@@ -0,0 +1,31 @@
/** 登录失败反馈(纯逻辑):把「Java 的 HTTP 200 + success=false」和各类传输层错误都归一成一句能给人看的文案。 */
import { REQUEST_FALLBACK_MESSAGE, requestErrorMessage, unwrap } from '../../api/envelope.ts'
/** 没有可展示原因时的兜底文案(不再伪装成「用户名或密码错误」)。 */
export const LOGIN_FALLBACK_MESSAGE = '登录失败,请稍后重试'
/**
* 解包登录响应:后端所有失败(密码错、账号到期、失败次数锁定、缺少设备ID)都是 HTTP 200 +
* `success:false`,axios 视为成功。不经过这里,登录页就拿不到失败原因——于是"什么都不提示"。
*/
export function unwrapLoginResponse(payload: unknown): void {
unwrap<unknown>(payload)
}
/** 传输层/网关的技术串,对用户没有信息量;命中则换成兜底文案。 */
function isTechnicalText(text: string): boolean {
if (/^request failed with status code \d+$/i.test(text)) return true
if (/^(network error|err_network|timeout of \d+ms exceeded)/i.test(text)) return true
// nginx / 网关的 HTML 错误页:axios 未解析时会把整页原样交出来
return text.startsWith('<')
}
/** 登录失败可展示文案:优先服务端原因,缺省回兜底。 */
export function loginErrorText(error: unknown): string {
const message = requestErrorMessage(error).trim()
// 通用兜底串意味着"没有拿到任何服务端原因",登录页要换成登录语境的文案
if (!message || message === REQUEST_FALLBACK_MESSAGE || isTechnicalText(message)) {
return LOGIN_FALLBACK_MESSAGE
}
return message
}
@@ -0,0 +1,120 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { missingImports, readSource } from './helpers.ts'
import {
isLoginLocation,
shouldRedirectForbidden,
shouldRedirectUnauthorized,
} from '../src/api/envelope.ts'
import {
LOGIN_FALLBACK_MESSAGE,
loginErrorText,
unwrapLoginResponse,
} from '../src/pages/login/login-feedback.ts'
/**
* 登录失败必须有提示(2026-10-06)。
*
* 两个各自独立的"吞掉提示"出口:
* 1. Java 的登录失败一律 HTTP 200 + `success:false`(GlobalExceptionHandler 把 BusinessException
* 编成 ApiResponse.fail),axios 视为成功 → 登录页不解包就永远走不到 catch,`errorMessage` 恒空;
* 2. 紧接着 `session.initialize()` 打 current-user 拿到 401/403,拦截器整页
* `window.location.assign('/admin-vue/login?...')` —— 页面重刷,错误文案连同已填用户名一起没了。
* 守卫本该拦下"已经在登录页"的跳转,但它只比过路由内的 `/login`,而真实 pathname 是 `/admin-vue/login`。
*/
/** 线上真实的登录失败响应体(Java:success/message/data/code,HTTP 200)。 */
const FAIL_BODIES: Array<{ name: string; body: unknown; reason: string }> = [
{
name: '密码错',
body: { success: false, message: '用户名或密码错误', data: null, code: null },
reason: '用户名或密码错误',
},
{
name: '撞库锁定',
body: { success: false, message: '登录失败次数过多,请 12 分钟后再试', data: null, code: null },
reason: '登录失败次数过多,请 12 分钟后再试',
},
{
name: '账号到期',
body: { success: false, message: '账号已于 2026-10-01 到期,请联系管理员续费', data: null, code: 403 },
reason: '账号已于 2026-10-01 到期,请联系管理员续费',
},
{
name: '正常账号无后台权限',
body: { success: false, message: '需要管理员权限', data: null, code: 403 },
reason: '需要管理员权限',
},
]
test('解包登录响应:每一种 HTTP 200 失败都要抛出服务端原因', () => {
for (const { name, body, reason } of FAIL_BODIES) {
assert.throws(() => unwrapLoginResponse(body), (error: unknown) => {
assert.ok(error instanceof Error, `${name} 应抛出 Error`)
assert.equal(error.message, reason, `${name} 要把服务端文案原样带出来`)
return true
})
}
})
test('解包登录响应:成功体不得抛错(否则上面四支会恒真)', () => {
assert.doesNotThrow(() => unwrapLoginResponse({
success: true,
message: '登录成功',
data: { userId: 1201, token: 'jwt', role: 'admin' },
code: null,
}))
})
test('服务端原因空时也有文案,不出现空提示', () => {
assert.throws(() => unwrapLoginResponse({ success: false, message: '', data: null }))
assert.equal(loginErrorText(new Error('')), LOGIN_FALLBACK_MESSAGE)
assert.equal(loginErrorText(undefined), LOGIN_FALLBACK_MESSAGE)
})
test('传输层技术串不外露:状态码串/网络错/HTML 错误页一律回兜底', () => {
const cases: Array<[unknown, string]> = [
[new Error('Request failed with status code 500'), LOGIN_FALLBACK_MESSAGE],
[{ response: { data: { success: false, message: '服务器内部错误,请稍后重试' } } }, '服务器内部错误,请稍后重试'],
[new Error('Network Error'), LOGIN_FALLBACK_MESSAGE],
[new Error('Timeout of 30000ms exceeded.'), LOGIN_FALLBACK_MESSAGE],
[{ response: { data: '<html><body>502 Bad Gateway</body></html>' } }, LOGIN_FALLBACK_MESSAGE],
]
for (const [error, expected] of cases) {
assert.equal(loginErrorText(error), expected)
}
})
test('登录页上的会话引导失败不再整页重刷:这是"啥都没提示"的那一步', () => {
for (const pathname of ['/admin-vue/login', '/admin-vue/login?redirect=%2Fadmin-vue%2Faccount%2Fusers']) {
assert.equal(isLoginLocation(pathname), true, `${pathname} 应在登录页判定内`)
for (const url of ['/api/admin/current-user', '/api/admin/current-user/menus']) {
assert.equal(
shouldRedirectUnauthorized(pathname, url),
false,
`${pathname} 上 ${url} 的 401 不许再跳(跳了就是把提示刷没)`,
)
}
}
})
test('收窄到登录页之外一律照旧:业务页 401 仍跳、引导端点 403 仍跳', () => {
assert.equal(shouldRedirectUnauthorized('/admin-vue/account/users', '/api/admin/current-user'), true)
assert.equal(shouldRedirectUnauthorized('/admin-vue/', '/api/admin/current-user'), true)
// 10-04 那条 403 分流没动:只有会话引导端点的 403 按"进不了后台"处理
assert.equal(shouldRedirectForbidden('/api/admin/current-user'), true)
assert.equal(shouldRedirectForbidden('/api/admin/companies'), false)
// 相邻路径不许被误判成登录页(尾斜杠才算,/admin-vue/login-x 不算)
assert.equal(isLoginLocation('/admin-vue/login-x'), false)
assert.equal(isLoginLocation('/admin-vue/account/login'), false)
})
test('登录页接线:解包 + 归一文案,且不得保留「用户名或密码错误」兜底', () => {
const page = readSource('src/pages/login/LoginPage.vue')
assert.match(page, /http\.post<unknown>\('\/login'/, '断言对象必须是那条登录请求')
assert.match(page, /unwrapLoginResponse\(data\)/, '失败体必须解包,否则永远走不到 catch')
assert.match(page, /errorMessage\.value = loginErrorText\(error\)/)
assert.doesNotMatch(page, /errorMessage\.value = error instanceof Error/, '不得再用 instanceof 当失败判据')
assert.doesNotMatch(page, /:\s*'用户名或密码错误'/, '任何异常都显示"用户名或密码错误"是在伪造原因')
assert.deepEqual(missingImports('src/pages/login/LoginPage.vue'), [])
})
+3 -1
View File
@@ -58,7 +58,9 @@ test('test_task_026_unauthorized_redirect_invalid_input_rejected', () => {
assert.equal(shouldRedirectUnauthorized(undefined as unknown as string, undefined), true)
assert.equal(shouldRedirectUnauthorized(null as unknown as string, null as unknown as string), true)
assert.equal(isAuthEndpointRequest(42 as unknown as string), false)
assert.equal(isLoginLocation('/admin-vue/login'), false)
// 2026-10-06 更正:浏览器地址栏带 History base,登录页的真实 pathname 就是 /admin-vue/login,
// 原先钉成 false 让"已在登录页就不再整页跳转"这条守卫在真机上一次都没生效。
assert.equal(isLoginLocation('/admin-vue/login'), true)
})
test('test_task_026_unauthorized_redirect_dependency_failure_returns_actionable_message', () => {
@@ -3,7 +3,52 @@ package com.nanri.aiimage.common.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.time.LocalDateTime;
@Mapper
public interface AdminUserMapper extends BaseMapper<AdminUserEntity> {
/**
* 本公司「公司超级管理员」里最早的到期时间;返回 null = 本公司无此约束(没有公司超管,
* 或它们全部永不过期)。到期级联判据见 {@code AccountExpiryService}。
*
* <p>刻意用聚合标量而不是 {@code selectList(.select(expiresAt))}:MyBatis 对「所选列全为
* NULL」的行返回 null 元素,一家公司只要有任意一个公司超管没设到期,那条列表里就混着 null,
* 遍历时解引用即 NPE,而这里正是每次登录与每个鉴权请求都要走的读出口。MIN 忽略 NULL,
* 无行时结果集仍是单行单列,直接映射成 null。</p>
*/
@Select("""
SELECT MIN(expires_at)
FROM users
WHERE role = 'company_super_admin'
AND company_id = #{companyId}
""")
LocalDateTime selectCompanySuperAdminEarliestExpiry(@Param("companyId") Long companyId);
/**
* 该账号在<b>本公司那棵树</b>里被授了几条后台(menu_type='admin')菜单;>0 即允许进管理后台。
*
* <p>刻意用标量 COUNT 而不是 {@code selectList(.select(columnId))}:与上面那条同样的投影陷阱
* (见 {@code AuthChainQueryShapeTest}),而这里是每个后台入口请求都要走的鉴权读。</p>
*
* <p>必须带 {@code cm.company_id} 条件:每家公司一套树之后,{@code column_id} 指向别家树的
* 残留授权行会让账号"进得了后台、菜单树却是空的"——入口门与 {@code getUserColumnPermissions}
* 的下发集要用同一个公司口径,否则两处各判一次就留下静默死链。</p>
*/
@Select("""
<script>
SELECT COUNT(1)
FROM user_column_permission ucp
JOIN columns cm ON cm.id = ucp.column_id
WHERE ucp.user_id = #{userId}
AND cm.menu_type = 'admin'
<if test="companyId != null">
AND cm.company_id = #{companyId}
</if>
</script>
""")
Long countAdminMenuGrants(@Param("userId") Long userId, @Param("companyId") Long companyId);
}
@@ -1,6 +1,5 @@
package com.nanri.aiimage.common.security;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.mapper.ShopManageGroupMapper;
@@ -11,7 +10,6 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.List;
/**
* 账号到期(expires_at,V146)的级联判定与拦截。
@@ -113,15 +111,7 @@ public class AccountExpiryService {
if (companyId == null || companyId <= 0) {
return null;
}
List<AdminUserEntity> csas = adminUserMapper.selectList(new LambdaQueryWrapper<AdminUserEntity>()
.select(AdminUserEntity::getExpiresAt)
.eq(AdminUserEntity::getRole, "company_super_admin")
.eq(AdminUserEntity::getCompanyId, companyId));
LocalDateTime earliest = null;
for (AdminUserEntity csa : csas) {
earliest = min(earliest, csa.getExpiresAt());
}
return earliest;
return adminUserMapper.selectCompanySuperAdminEarliestExpiry(companyId);
}
/** 组级:该用户所属分组(成员表)的组长(created_by_id/user_id)若是管理员,取其最早 expires_at。 */
@@ -114,6 +114,51 @@ public class AdminAuthSupport {
return user;
}
/**
* 后台入口门:管理员角色恒可进;普通账号持有本公司任意后台菜单授权也可进。
*
* <p>2026-10-06 放开。此前"进后台"与"有管理员角色"绑死,超管在权限页给普通账号勾了
* 后台菜单也照样 403——授权动作做了,门没跟着开,界面上表现为点了没反应。放开只针对
* <b>入口</b>:每一页仍由该页自己的门把关({@code PermissionMenuService.requireConsolePageAccess}
* 按该页菜单键判定),管理类出口(用户/菜单/分组/密钥/公司/版本)一律继续走
* {@link #requireAdmin},不在这里放宽。</p>
*/
public AdminUserEntity requireConsoleOperator(HttpServletRequest request) {
AdminUserEntity user = requireUser(request);
if (!isConsoleOperator(user)) {
throw new BusinessException(403, "需要管理员权限");
}
return user;
}
/** JWT 优先走入口门;内部令牌通道仍要求管理员角色——它绕过到期与会话校验,不随入口一起放宽。 */
public AdminUserEntity requireConsoleOperatorOrInternal(HttpServletRequest request) {
try {
return requireConsoleOperator(request);
} catch (BusinessException authFailure) {
AdminUserEntity internalOperator = resolveInternalOperator(request, true);
if (internalOperator != null) {
return internalOperator;
}
throw authFailure;
}
}
/** 入口判定:角色链(super_admin / admin / company_super_admin)或本公司任意一条后台菜单授权。 */
public boolean isConsoleOperator(AdminUserEntity user) {
if (user == null) {
return false;
}
if (currentRole(user) != null) {
return true;
}
if (user.getId() == null || user.getId() <= 0) {
return false;
}
Long grants = adminUserMapper.countAdminMenuGrants(user.getId(), user.getCompanyId());
return grants != null && grants > 0;
}
/** 计算当前用户的管理角色:super_admin / admin / null。 */
public String currentRole(AdminUserEntity user) {
if (user == null) {
@@ -67,7 +67,7 @@ public class AdminConsoleController {
@GetMapping("/api/admin/current-user")
@Operation(summary = "获取当前管理员信息")
public ApiResponse<Map<String, Object>> currentUser(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
Map<String, Object> item = new LinkedHashMap<>();
item.put("id", operator.getId());
item.put("username", operator.getUsername() == null ? "" : operator.getUsername());
@@ -87,7 +87,7 @@ public class AdminConsoleController {
@GetMapping("/api/admin/current-user/menus")
@Operation(summary = "当前登录管理员的可见后台菜单树")
public ApiResponse<Map<String, Object>> currentUserMenus(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
// 补全祖先分组:部分授权用户(只授权了子页面)也要看到「一级分组 + 子页面」层级,
// 与超管的菜单组织顺序一致;分组节点无页面路由,不构成权限扩展。
List<PermissionMenuItemVo> menus = permissionMenuService.getUserColumnPermissions(
@@ -40,7 +40,7 @@ public class ImageHistoryController {
@RequestParam(name = "time_start", required = false) String timeStart,
@RequestParam(name = "time_end", required = false) String timeEnd,
@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
if (!permissionMenuService.hasAnyAdminMenu(operator, List.of("admin_history"))) {
throw new BusinessException(403, "无权访问生成记录模块");
}
@@ -54,7 +54,7 @@ public class ImageHistoryController {
@DeleteMapping("/history")
@Operation(summary = "清空全部生成记录")
public ApiResponse<Long> clearHistory(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
if (!permissionMenuService.hasAnyAdminMenu(operator, List.of("admin_history"))) {
throw new BusinessException(403, "无权访问生成记录模块");
}
@@ -66,6 +66,14 @@ public class AdminImageVideoTaskController {
private final ImageVideoAdminTaskService adminTaskService;
private final AdminAuthSupport adminAuthSupport;
private final DataReadScope dataReadScope;
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
/** 过「视频任务记录」这一页的门:管理员角色行为不变,普通账号须被授了该菜单(2026-10-06 入口放开)。 */
private AdminUserEntity requireOperator(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
permissionMenuService.requireConsolePageAccess(operator, "无权访问视频任务记录", "admin_image_video_tasks");
return operator;
}
@GetMapping
@Operation(summary = "分页查询图生视频任务", description = "管理端按用户/任务状态/提交时间等条件分页查询近 3 天的工作流任务")
@@ -80,7 +88,7 @@ public class AdminImageVideoTaskController {
@RequestParam(name = "submitted_to", required = false) String submittedTo,
@RequestParam(name = "company_id", required = false) Long companyId,
HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = requireOperator(request);
// 既有语义保留:显式传 user_id 时按那一个人筛;公司 tab 叠在它上面(交集)。
List<Long> base = userId != null && userId > 0 ? List.of(userId) : null;
List<Long> scoped = dataReadScope.readScope(operator, companyId).userIdsOr(base);
@@ -100,7 +108,7 @@ public class AdminImageVideoTaskController {
@GetMapping("/{taskId}")
@Operation(summary = "查询图生视频任务详情", description = "返回单个任务详情(含脱敏后的请求参数与结果 JSON)")
public ApiResponse<Map<String, Object>> detail(@PathVariable Long taskId, HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = requireOperator(request);
return ApiResponse.success(adminTaskService.detail(taskId, scopeOf(operator)));
}
@@ -108,7 +116,7 @@ public class AdminImageVideoTaskController {
@Operation(summary = "批量打包下载视频", description = "按任务+视频下标批量打包 zip;部分失败通过响应头 X-Archive-Error-Count 提示")
public ResponseEntity<StreamingResponseBody> downloadZip(@RequestBody(required = false) Map<String, Object> body,
HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = requireOperator(request);
List<VideoSelection> selections = parseSelections(body);
ZipBundle bundle = adminTaskService.buildZip(selections, scopeOf(operator));
String filename = "video-tasks-" + LocalDateTime.now().format(ZIP_FILENAME_FORMATTER) + ".zip";
@@ -82,7 +82,9 @@ public class AdminNotificationController {
}
private Long currentAdminId(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdmin(request);
// 通知是"自己看自己的"(userId 由会话推导),后台的铃铛在每个进得来后台的人面前都会轮询,
// 所以出口跟着入口门走;留 requireAdmin 会让刚放开的普通账号每 30s 吃一次 403。
AdminUserEntity operator = adminAuthSupport.requireConsoleOperator(request);
return operator.getId();
}
}
@@ -55,6 +55,21 @@ public class PermissionMenuService {
* 与前端 src/config/company-scope.ts 的 SUPER_ADMIN_ONLY_MENU_KEYS 必须同值,由 Task 7 的跨端用例钉住。 */
private static final Set<String> SUPER_ADMIN_ONLY_KEYS = Set.of("admin_companies");
/**
* 管理/平台配置类菜单:出口仍是 {@code requireAdmin}(用户、菜单、分组、密钥、公司、版本、教程、
* 日志),普通账号即使被勾了也用不了。
*
* <p>2026-10-06 入口放开后必须与下发集一起剪:现网实查有 13 个普通账号带着 {@code admin_users}、
* 11 个带 {@code admin_user_secrets}、9 个带 {@code admin_version} 的授权行,只在出口拦而照常下发
* 侧边栏,等于给刚放进来的人画一排必 403 的死链(显示比权限宽)。剪掉只是不再显示,
* 授权行本身不动——这些账号本来就进不去那些页。</p>
*/
private static final Set<String> ADMIN_ONLY_MENU_KEYS = Set.of(
"admin_users", "admin_columns", "admin_group_manage",
"admin_user_secrets", "admin_user_secret_usage",
"admin_version", "digital_human_version", "admin_tutorial",
"admin_device_logs");
private final PermissionMenuMapper permissionMenuMapper;
private final UserColumnPermissionMapper userColumnPermissionMapper;
private final AdminUserMapper adminUserMapper;
@@ -549,6 +564,9 @@ public class PermissionMenuService {
// 换成剪过的集合会让只勾了子页面的用户解析不出父分组,等于把「用户管理」一起弄红。
List<PermissionMenuEntity> visibleMenus = effectiveMenus.stream()
.filter(menu -> !SUPER_ADMIN_ONLY_KEYS.contains(menu.getColumnKey()))
// 出口 2 的第二道剪枝(与上一行同一批语义):管理/平台页对普通账号不下发——
// 它们的后端出口仍是 requireAdmin,下发出去就是一条点了必 403 的死链。
.filter(menu -> isAdmin(user) || !ADMIN_ONLY_MENU_KEYS.contains(menu.getColumnKey()))
.toList();
return toItemVos(visibleMenus, menus);
}
@@ -722,7 +740,8 @@ public class PermissionMenuService {
* 不应再被 403 拒绝。</p>
*/
public void requireShopDataCrawlTaskAccess(AdminUserEntity operator) {
ensureAdminOperatorIfPresent(operator);
// 不再前置判"是不是管理员角色":2026-10-06 入口放开后,那道角色门会把下面按授权判的门
// 变成普通账号永远走不到的死代码(菜单勾了、页里仍然 403)。真正的门就是下面那三行授权命中。
if (operator == null || operator.getId() == null || operator.getId() <= 0) {
throw new BusinessException(403, "需要管理员权限");
}
@@ -752,7 +771,6 @@ public class PermissionMenuService {
* 授权记录即拒绝,因此新菜单默认只有超管可见。</p>
*/
public void requireClientTaskCenterAccess(AdminUserEntity operator) {
ensureAdminOperatorIfPresent(operator);
if (operator == null || operator.getId() == null || operator.getId() <= 0) {
throw new BusinessException(403, "需要管理员权限");
}
@@ -766,6 +784,25 @@ public class PermissionMenuService {
}
}
/**
* 后台页面门(2026-10-06):管理员角色链行为不变恒可进;普通账号必须持有<b>这一页</b>的后台菜单
* 授权才放行。
*
* <p>入口放开不等于逐页放开。现网 46 个普通账号持有后台菜单授权(只读实查 2026-10-06),若逐页门只看入口,它们顺手就能读到同公司的密钥页与扣次数的 ASIN 查询页——勾菜单的人本意是给一页,不是给全部。
* 判据与 {@link #hasAnyAdminMenu} 同一套(本公司树 + 直接授权递归展开),所以勾父分组
* 覆盖后代的语义在这里照样成立。</p>
*/
public void requireConsolePageAccess(AdminUserEntity operator, String denialMessage, String... columnKeys) {
if (operator == null || isAdmin(operator)) {
return;
}
if (columnKeys != null && columnKeys.length > 0
&& hasAnyAdminMenu(operator, List.of(columnKeys))) {
return;
}
throw new BusinessException(403, denialMessage);
}
/**
* 判断操作者是否可见任一所给后台菜单(按 column_key,限定 admin 菜单类型)。
* 超管直通;其余取直接授权递归展开后的有效菜单做交集。
@@ -1,6 +1,7 @@
package com.nanri.aiimage.modules.productcategory.controller;
import com.nanri.aiimage.common.api.ApiResponse;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.util.DownloadHeaderUtil;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.productcategory.model.dto.ProductCategorySaveRequest;
@@ -38,13 +39,20 @@ public class ProductCategoryController {
private final ProductCategoryService productCategoryService;
private final AdminAuthSupport adminAuthSupport;
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
/** 过「商品类目」这一页的门:管理员角色行为不变,普通账号须被授了该菜单(2026-10-06 入口放开)。 */
private void requireOperator(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
permissionMenuService.requireConsolePageAccess(operator, "无权访问商品类目", "admin_product_categories");
}
@GetMapping("/product-categories")
@Operation(summary = "查询商品类目树")
public ApiResponse<ProductCategoryListVo> list(
HttpServletRequest request,
@RequestParam(value = "keyword", required = false) String keyword) {
adminAuthSupport.requireAdminOrInternal(request);
requireOperator(request);
return ApiResponse.success(productCategoryService.list(keyword));
}
@@ -55,7 +63,7 @@ public class ProductCategoryController {
@RequestParam(value = "parent_id", required = false) Long parentId,
@RequestParam(value = "page", defaultValue = "1") Long page,
@RequestParam(value = "page_size", defaultValue = "20") Long pageSize) {
adminAuthSupport.requireAdminOrInternal(request);
requireOperator(request);
return ApiResponse.success(productCategoryService.children(parentId, page, pageSize));
}
@@ -66,7 +74,7 @@ public class ProductCategoryController {
@RequestParam(value = "keyword", required = false) String keyword,
@RequestParam(value = "page", defaultValue = "1") Long page,
@RequestParam(value = "page_size", defaultValue = "20") Long pageSize) {
adminAuthSupport.requireAdminOrInternal(request);
requireOperator(request);
return ApiResponse.success(productCategoryService.search(keyword, page, pageSize));
}
@@ -75,7 +83,7 @@ public class ProductCategoryController {
public ResponseEntity<byte[]> export(
HttpServletRequest request,
@RequestParam(value = "keyword", required = false) String keyword) {
adminAuthSupport.requireAdminOrInternal(request);
requireOperator(request);
byte[] bytes = productCategoryService.export(keyword);
String filename = "product-categories-" + LocalDateTime.now().format(EXPORT_FILENAME_FORMATTER) + ".xlsx";
return ResponseEntity.ok()
@@ -90,7 +98,7 @@ public class ProductCategoryController {
public ApiResponse<ProductCategoryItemVo> create(
HttpServletRequest request,
@Valid @RequestBody ProductCategorySaveRequest body) {
adminAuthSupport.requireAdminOrInternal(request);
requireOperator(request);
return ApiResponse.success("创建成功", productCategoryService.create(body));
}
@@ -100,7 +108,7 @@ public class ProductCategoryController {
HttpServletRequest request,
@PathVariable Long id,
@Valid @RequestBody ProductCategorySaveRequest body) {
adminAuthSupport.requireAdminOrInternal(request);
requireOperator(request);
return ApiResponse.success("保存成功", productCategoryService.update(id, body));
}
@@ -109,7 +117,7 @@ public class ProductCategoryController {
public ApiResponse<Void> delete(
HttpServletRequest request,
@PathVariable Long id) {
adminAuthSupport.requireAdminOrInternal(request);
requireOperator(request);
productCategoryService.delete(id);
return ApiResponse.success("删除成功", null);
}
@@ -79,7 +79,9 @@ public class AdminShopDataCrawlTaskController {
private void requireShopDataCrawlTaskAccess(HttpServletRequest request) {
AdminUserEntity operator;
try {
operator = adminAuthSupport.requireAdmin(request);
// 入口门随 2026-10-06 的放开一起换:普通账号能否进这一页由下面
// permissionMenuService.requireShopDataCrawlTaskAccess 按授权判定,这里不再抢跑判角色。
operator = adminAuthSupport.requireConsoleOperator(request);
} catch (BusinessException authFailure) {
operator = resolveInternalOperator(request);
if (operator == null) {
@@ -280,7 +280,9 @@ public class AdminShopDataCrawlTasksController {
private AdminUserEntity requireShopDataCrawlTaskAccess(HttpServletRequest request) {
AdminUserEntity operator;
try {
operator = adminAuthSupport.requireAdmin(request);
// 入口门随 2026-10-06 的放开一起换:普通账号能否进这一页由下面
// permissionMenuService.requireShopDataCrawlTaskAccess 按授权判定,这里不再抢跑判角色。
operator = adminAuthSupport.requireConsoleOperator(request);
} catch (BusinessException authFailure) {
operator = resolveInternalOperator(request);
if (operator == null) {
@@ -289,7 +289,8 @@ public class AdminShopDataDuplicateCheckController {
private RequestOperator requireDuplicateCheckAccess(HttpServletRequest request) {
AdminUserEntity operator;
try {
operator = adminAuthSupport.requireAdmin(request);
// 入口门随 2026-10-06 的放开一起换:这一页能不能进由下面按授权判定,这里不再抢跑判角色。
operator = adminAuthSupport.requireConsoleOperator(request);
} catch (BusinessException authFailure) {
operator = resolveInternalOperator(request);
if (operator == null) {
@@ -45,10 +45,14 @@ public class QueryAsinController {
private final QueryAsinService queryAsinService;
private final AdminAuthSupport adminAuthSupport;
private final com.nanri.aiimage.common.service.DataReadScope dataReadScope;
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
/** 解析当前操作者(JWT 或内部令牌通道),权限与数据范围一律以该身份为准。 */
private AdminUserEntity requireOperator(HttpServletRequest request) {
return adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
// 查询 ASIN 是扣次数的出口:入口放开后仍要按这一页的菜单授权把关,不能让人顺手烧别家的额度。
permissionMenuService.requireConsolePageAccess(operator, "无权访问查询ASIN", "admin_query_asin");
return operator;
}
@GetMapping
@@ -37,6 +37,17 @@ public class ShopKeyController {
private final ShopKeyService shopKeyService;
private final AdminAuthSupport adminAuthSupport;
private final DataReadScope dataReadScope;
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
/**
* 解析当前操作者并过「店铺密钥管理」这一页的门:管理员角色行为不变,普通账号须被授了该菜单。
* 密钥是每家公司的敏感配置,入口放开不能顺手把它对全体进后台的人打开。
*/
private AdminUserEntity requireOperator(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
permissionMenuService.requireConsolePageAccess(operator, "无权访问店铺密钥管理", "admin_shop_keys");
return operator;
}
@GetMapping
@Operation(summary = "分页查询店铺密钥", description = "分页查询店铺密钥列表。company_id 只收窄可见集、不放大:"
@@ -50,7 +61,7 @@ public class ShopKeyController {
@Parameter(description = "每页数量") @RequestParam(defaultValue = "15") Long pageSize,
@Parameter(description = "按公司筛选(仅超管生效;非超管一律按会话公司裁剪)")
@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = requireOperator(request);
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(operator, companyId);
return ApiResponse.success(shopKeyService.page(page, pageSize, scopedCompanyId));
}
@@ -64,7 +75,7 @@ public class ShopKeyController {
public ApiResponse<ShopKeyItemVo> create(
HttpServletRequest request,
@Valid @RequestBody ShopKeyCreateRequest body) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = requireOperator(request);
return ApiResponse.success("创建成功", shopKeyService.create(body, operator.getId()));
}
@@ -80,7 +91,7 @@ public class ShopKeyController {
HttpServletRequest request,
@Parameter(description = "主键ID", required = true) @PathVariable Long id,
@Valid @RequestBody ShopKeyUpdateRequest body) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = requireOperator(request);
return ApiResponse.success("更新成功", shopKeyService.update(id, body, dataReadScope.writeCompanyId(operator)));
}
@@ -94,7 +105,7 @@ public class ShopKeyController {
public ApiResponse<Void> delete(
HttpServletRequest request,
@Parameter(description = "主键ID", required = true) @PathVariable Long id) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = requireOperator(request);
shopKeyService.delete(id, dataReadScope.writeCompanyId(operator));
return ApiResponse.success("删除成功", null);
}
@@ -112,7 +123,7 @@ public class ShopKeyController {
public ApiResponse<ShopKeyItemVo> checkWhitelist(
HttpServletRequest request,
@Parameter(description = "主键ID", required = true) @PathVariable Long id) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = requireOperator(request);
return ApiResponse.success("检测完成", shopKeyService.checkWhitelist(id, dataReadScope.writeCompanyId(operator)));
}
}
@@ -49,10 +49,18 @@ public class ShopManageController {
private final ShopManageGroupService shopManageGroupService;
private final AdminAuthSupport adminAuthSupport;
private final DataReadScope dataReadScope;
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
/** 解析当前操作者(JWT 或内部令牌通道),数据范围一律以该身份为准,不信任调用方传入的 operatorId/superAdmin。 */
/**
* 解析当前操作者(JWT 或内部令牌通道),数据范围一律以该身份为准,不信任调用方传入的 operatorId/superAdmin。
*
* <p>2026-10-06:入口门放开后补这一页自己的门——管理员角色行为不变,普通账号必须被授了
* 「店铺管理」菜单才读得到店铺与分组。</p>
*/
private AdminUserEntity requireOperator(HttpServletRequest request) {
return adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
permissionMenuService.requireConsolePageAccess(operator, "无权访问店铺管理", "admin_shop_manage");
return operator;
}
private boolean isSuper(AdminUserEntity operator) {
@@ -46,10 +46,13 @@ public class SkipPriceAsinController {
private final SkipPriceAsinService skipPriceAsinService;
private final AdminAuthSupport adminAuthSupport;
private final com.nanri.aiimage.common.service.DataReadScope dataReadScope;
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
/** 解析当前操作者(JWT 或内部令牌通道),权限与数据范围一律以该身份为准。 */
private AdminUserEntity requireOperator(HttpServletRequest request) {
return adminAuthSupport.requireAdminOrInternal(request);
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
permissionMenuService.requireConsolePageAccess(operator, "无权访问最低价ASIN", "admin_skip_price_asin");
return operator;
}
@GetMapping
@@ -147,7 +147,8 @@ public class AdminTaskCenterController {
/** 会话闸门(登录态 + 菜单权限),五个端点同一把;service 只认算好的 operatorId。 */
private AdminUserEntity authorizedOperator(HttpServletRequest request) {
AdminUserEntity operator = adminAuthSupport.requireAdminOrInternal(request);
// 入口门换成"管理员角色或持有后台授权",是否能看到这一页仍由下一行的菜单授权判定。
AdminUserEntity operator = adminAuthSupport.requireConsoleOperatorOrInternal(request);
permissionMenuService.requireClientTaskCenterAccess(operator);
return operator;
}
@@ -42,7 +42,7 @@ class AccountExpiryServiceTest {
groupMapper = mock(ShopManageGroupMapper.class);
service = new AccountExpiryService(adminUserMapper, groupMapper);
// 默认:无公司超管、无组长、无创建人约束
when(adminUserMapper.selectList(any())).thenReturn(List.of());
when(adminUserMapper.selectCompanySuperAdminEarliestExpiry(any())).thenReturn(null);
when(adminUserMapper.selectById(any(Long.class))).thenReturn(null);
when(groupMapper.selectLeaderIdsByMemberUserId(any())).thenReturn(List.of());
}
@@ -70,11 +70,7 @@ class AccountExpiryServiceTest {
@Test
void companySuperAdminExpiryCapsEveryoneInTheCompany() {
LocalDateTime companyExpiry = LocalDateTime.now().plusDays(2);
AdminUserEntity csa = new AdminUserEntity();
csa.setId(9L);
csa.setRole("company_super_admin");
csa.setExpiresAt(companyExpiry);
when(adminUserMapper.selectList(any())).thenReturn(List.of(csa));
when(adminUserMapper.selectCompanySuperAdminEarliestExpiry(1L)).thenReturn(companyExpiry);
// 普通账号(自身无到期)被公司超管的到期拉进去
assertThat(service.effectiveExpiresAt(entity(3L, "normal", null, 1L, null))).isEqualTo(companyExpiry);
@@ -82,26 +78,27 @@ class AccountExpiryServiceTest {
assertThat(service.effectiveExpiresAt(entity(2L, "admin", null, 1L, null))).isEqualTo(companyExpiry);
}
/**
* 生产现形(2026-10-06 先锋-团队 / company_id=3):本公司有公司超管、但它们全部没设到期。
* 这一档必须既不构成约束、也不抛——曾经这里读的是「单列实体投影」,MyBatis 对所选列全为 NULL 的
* 行返回 null 元素,遍历解引用即 NPE,而本方法是每次登录与每个鉴权请求的必经出口 ⇒ 该公司
* 全部账号表现为「登录不了」。判据已改成 mapper 里的 MIN(expires_at) 标量,见 {@code AdminUserMapper}。
*/
@Test
void companySuperAdminWithoutExpiryLeavesCompanyUnaffected() {
AdminUserEntity csa = new AdminUserEntity();
csa.setId(9L);
csa.setRole("company_super_admin");
csa.setExpiresAt(null);
when(adminUserMapper.selectList(any())).thenReturn(List.of(csa));
when(adminUserMapper.selectCompanySuperAdminEarliestExpiry(1L)).thenReturn(null);
assertThatCode(() -> service.assertLoginAllowed(entity(3L, "normal", null, 1L, null)))
.doesNotThrowAnyException();
assertThat(service.effectiveExpiresAt(entity(3L, "normal", null, 1L, null))).isNull();
assertThat(service.effectiveExpiresAt(entity(2L, "admin", null, 1L, null))).isNull();
}
@Test
void earliestConstraintWinsOverOwnExpiry() {
LocalDateTime own = LocalDateTime.now().plusDays(10);
LocalDateTime company = LocalDateTime.now().plusDays(1);
AdminUserEntity csa = new AdminUserEntity();
csa.setId(9L);
csa.setRole("company_super_admin");
csa.setExpiresAt(company);
when(adminUserMapper.selectList(any())).thenReturn(List.of(csa));
when(adminUserMapper.selectCompanySuperAdminEarliestExpiry(1L)).thenReturn(company);
assertThat(service.effectiveExpiresAt(entity(3L, "normal", null, 1L, own))).isEqualTo(company);
}
@@ -0,0 +1,184 @@
package com.nanri.aiimage.common.security;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.catchThrowableOfType;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
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 jakarta.servlet.http.HttpServletRequest;
import org.junit.jupiter.api.Test;
import org.springframework.test.util.ReflectionTestUtils;
/**
* 后台入口门(2026-10-06 放开):普通账号凭本公司的后台菜单授权进后台。
*
* <p>放开的只是<b>入口</b>(current-user / current-user/menus 这类"我能不能进后台"的出口)。
* 逐页的门在 {@code PermissionMenuService.requireConsolePageAccess},管理类出口
* (用户/菜单/分组/密钥/公司/版本)继续走 {@link AdminAuthSupport#requireAdmin}。
* 内部令牌通道更是一条都不放宽——它绕过到期与会话校验。</p>
*/
class AdminAuthSupportConsoleEntryTest {
@Test
void normalAccountHoldingAnAdminMenuGrantEntersTheConsole() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.countAdminMenuGrants(7L, 3L)).thenReturn(1L);
AdminAuthSupport support = support(user(7L, "normal", 0, 3L), userMapper);
assertThatCode(() -> support.requireConsoleOperator(requestWithBearer("t")))
.as("超管在权限页给它勾了后台菜单,就该进得来")
.doesNotThrowAnyException();
}
@Test
void normalAccountWithoutAnyGrantIsStillRejected() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.countAdminMenuGrants(7L, 3L)).thenReturn(0L);
AdminAuthSupport support = support(user(7L, "normal", 0, 3L), userMapper);
BusinessException ex = catchThrowableOfType(
() -> support.requireConsoleOperator(requestWithBearer("t")), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
assertThat(ex.getMessage()).isEqualTo("需要管理员权限");
}
/** 授权行的归属公司必须是操作者自己那棵树:别家树里的残留授权不能替本账号开门。 */
@Test
void grantProbeIsScopedToTheOperatorsOwnCompany() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.countAdminMenuGrants(anyLong(), any())).thenReturn(9L);
AdminAuthSupport support = support(user(7L, "normal", 0, 2L), userMapper);
support.requireConsoleOperator(requestWithBearer("t"));
verify(userMapper).countAdminMenuGrants(7L, 2L);
}
@Test
void adminRolesEnterWithoutAnyGrantLookup() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
AdminAuthSupport support = support(user(8L, "admin", 1, 1L), userMapper);
assertThatCode(() -> support.requireConsoleOperator(requestWithBearer("t"))).doesNotThrowAnyException();
verify(userMapper, never()).countAdminMenuGrants(anyLong(), any());
}
@Test
void companySuperAdminEntersWithoutAnyGrantLookup() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
AdminAuthSupport support = support(user(9L, "company_super_admin", 1, 1L), userMapper);
assertThatCode(() -> support.requireConsoleOperator(requestWithBearer("t"))).doesNotThrowAnyException();
verify(userMapper, never()).countAdminMenuGrants(anyLong(), any());
}
/** 内部令牌通道换不来入口:它不做到期与会话校验,只能凭管理员角色用。 */
@Test
void internalTokenChannelStillRejectsNormalOperator() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.selectById(7L)).thenReturn(user(7L, "normal", 0, 3L));
// 授权一条不少:这道门必须照样拒。若内部通道也改成"看授权",客户端凭这条通道
// 就能替任意普通账号读到后台(它同时绕过到期拦截)。
when(userMapper.countAdminMenuGrants(7L, 3L)).thenReturn(4L);
AdminAuthSupport support = tokenSupport(userMapper, "tok");
HttpServletRequest request = mock(HttpServletRequest.class);
when(request.getHeader("X-Internal-Token")).thenReturn("tok");
when(request.getParameter("operatorId")).thenReturn("7");
BusinessException ex = catchThrowableOfType(
() -> support.requireConsoleOperatorOrInternal(request), BusinessException.class);
assertThat(ex).as("内部令牌 + 普通账号 operatorId 不得返回用户").isNotNull();
// 冒出来的是 JWT 侧的"未登录",不是放行——内部分支自己把普通角色判成了"没有这个人"
assertThat(ex.getCode()).isEqualTo(401);
verify(userMapper, never()).countAdminMenuGrants(any(), any());
}
@Test
void internalTokenChannelStillAdmitsAdminOperator() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.selectById(8L)).thenReturn(user(8L, "admin", 1, 1L));
AdminAuthSupport support = tokenSupport(userMapper, "tok");
HttpServletRequest request = mock(HttpServletRequest.class);
when(request.getHeader("X-Internal-Token")).thenReturn("tok");
when(request.getParameter("operatorId")).thenReturn("8");
assertThat(support.requireConsoleOperatorOrInternal(request).getId()).isEqualTo(8L);
}
/** 没登录仍然是 401,不能被入口门改写成 403(前端的整页跳转判据靠这个码)。 */
@Test
void anonymousRequestStaysUnauthorized() {
AdminAuthSupport support = new AdminAuthSupport(mock(JwtService.class), mock(AdminUserMapper.class),
mock(AuthProperties.class), mock(AccountExpiryService.class));
HttpServletRequest request = mock(HttpServletRequest.class);
BusinessException ex = catchThrowableOfType(
() -> support.requireConsoleOperator(request), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(401);
}
/** 探针返回 null(库里根本没有授权行)时按"没有授权"处理,不能当成放行。 */
@Test
void nullGrantCountIsTreatedAsNoGrant() {
AdminUserMapper userMapper = mock(AdminUserMapper.class);
when(userMapper.countAdminMenuGrants(any(), any())).thenReturn(null);
AdminAuthSupport support = support(user(7L, "normal", 0, 3L), userMapper);
assertThat(support.isConsoleOperator(user(7L, "normal", 0, 3L))).isFalse();
}
private AdminAuthSupport support(AdminUserEntity user, AdminUserMapper userMapper) {
JwtService jwtService = mock(JwtService.class);
AuthProperties props = mock(AuthProperties.class);
Claims claims = mock(Claims.class);
when(claims.getSubject()).thenReturn(String.valueOf(user.getId()));
when(claims.get("deviceId")).thenReturn("devA");
when(jwtService.parse("t")).thenReturn(claims);
when(userMapper.selectById(user.getId())).thenReturn(user);
when(props.isSingleDeviceEnabled()).thenReturn(false);
return new AdminAuthSupport(jwtService, userMapper, props, mock(AccountExpiryService.class));
}
private AdminAuthSupport tokenSupport(AdminUserMapper userMapper, String token) {
AdminAuthSupport support = new AdminAuthSupport(mock(JwtService.class), userMapper,
mock(AuthProperties.class), mock(AccountExpiryService.class));
ReflectionTestUtils.setField(support, "internalToken", token);
ReflectionTestUtils.setField(support, "internalTokenPrevious", "");
ReflectionTestUtils.setField(support, "internalTokenFile", "");
return support;
}
private HttpServletRequest requestWithBearer(String token) {
HttpServletRequest request = mock(HttpServletRequest.class);
when(request.getHeader(org.springframework.http.HttpHeaders.AUTHORIZATION)).thenReturn("Bearer " + token);
return request;
}
private AdminUserEntity user(Long id, String role, int isAdmin, Long companyId) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
user.setUsername("u" + id);
user.setRole(role);
user.setIsAdmin(isAdmin);
user.setCreatedById(1L);
user.setCompanyId(companyId);
user.setMachine("devA");
return user;
}
}
@@ -0,0 +1,140 @@
package com.nanri.aiimage.common.security;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
/**
* 鉴权链路上的 mapper 读出口不得把「可空列」投影成实体列表再遍历。
*
* <p>MyBatis 对<b>所选列全为 NULL</b> 的行返回 null 元素({@code returnInstanceForEmptyRow} 默认关)。
* 于是 {@code selectList(wrapper.select(Entity::getNullableColumn))} 拿到的 List 里混着 null,
* 一句 {@code row.getX()} 就是 NPE。这个形状出过一次事故(2026-10-06):{@code AccountExpiryService}
* 读本公司公司超管的 {@code expires_at},而"没设到期"恰是绝大多数公司的常态 ⇒ 一家公司只要有一个
* 永不过期的公司超管,该公司<b>所有账号</b>的登录与每个鉴权请求全部 500,前端表现为「登录不了」。</p>
*
* <p>单测挡不住它:mock 会如实交出「带 id 的实体」,而真库交出的是 null 元素——判据落在 mock 边界外,
* 用例恒绿。所以这条做成源码扫描,规则本身走 {@link #authChainReadsCompanyCascadeAsScalarAggregate()}
* 那类可实跑断言。</p>
*/
class AuthChainQueryShapeTest {
/** 只有一列的 {@code .select(Entity::getX)} —— 两列以上就不会出现"整行皆空"。 */
private static final Pattern SINGLE_COLUMN_PROJECTION =
Pattern.compile("\\.select\\(\\s*[A-Za-z]\\w*::get[A-Za-z]\\w*\\s*\\)");
/** 扫描面:登录与会话鉴权走过的包(这里抛异常 = 用户登录不了,不是某个页面少几行)。 */
private static final String[] SCANNED_DIRS = {
"src/main/java/com/nanri/aiimage/common/security",
"src/main/java/com/nanri/aiimage/modules/auth",
};
@Test
void authChainNeverProjectsASingleColumnIntoAnEntityList() throws IOException {
List<Path> files = scannedSources();
List<String> offenders = files.stream()
.filter(p -> SINGLE_COLUMN_PROJECTION.matcher(read(p)).find())
.map(p -> p.getFileName().toString())
.collect(Collectors.toList());
assertThat(offenders)
.as("把单个可空列投影成实体列表的文件:整行皆 NULL 时 MyBatis 给的是 null 元素,"
+ "遍历即 NPE,而它在鉴权链路上(改成标量聚合或按主键取全行)")
.isEmpty();
}
/** 取样集非空自检:扫描一旦 0 命中,上面那条就恒绿,等于没护栏。 */
@Test
void scannedSurfaceIsActuallyTheAuthChain() throws IOException {
List<String> names = scannedSources().stream()
.map(p -> p.getFileName().toString())
.collect(Collectors.toList());
assertThat(names)
.as("这两处才是登录与每个鉴权请求走过的代码,扫描面漏了它们上面那条就是空转")
.contains("AccountExpiryService.java", "AdminAuthSupport.java", "AuthService.java");
}
/**
* 公司级到期级联的读出口形状:mapper 侧一条 {@code MIN(expires_at)} 标量。
* 只钉"Service 不再这么写"不够——回流成 {@code selectList} 之前,多半是先有人把 mapper
* 的聚合改成"取全部行自己比",所以把 SQL 本身也钉住。
*/
@Test
void authChainReadsCompanyCascadeAsScalarAggregate() throws IOException {
String service = read(sourceNamed("AccountExpiryService.java"));
assertThat(service).contains("selectCompanySuperAdminEarliestExpiry(");
assertThat(service).doesNotContain("selectList(");
String mapper = read(sourceNamed("AdminUserMapper.java"));
Matcher method = Pattern.compile(
"LocalDateTime selectCompanySuperAdminEarliestExpiry\\([\\s\\S]{0,400}").matcher(mapper);
assertThat(method.find()).as("mapper 里那个标量方法还在").isTrue();
assertThat(mapper).contains("MIN(expires_at)");
// 判据必须仍锁死在"本公司 + 公司超管",扩到全站会把别家的到期算进这家
assertThat(mapper).contains("role = 'company_super_admin'");
assertThat(mapper).contains("company_id = #{companyId}");
}
private static List<Path> scannedSources() throws IOException {
Path module = moduleRoot();
List<Path> files = new java.util.ArrayList<>();
for (String dir : SCANNED_DIRS) {
Path root = module.resolve(dir);
if (!Files.isDirectory(root)) {
fail("找不到 " + root + " —— 用例依赖以 backend-java 为工作目录运行,别让守卫静默通过");
}
try (Stream<Path> walk = Files.walk(root)) {
walk.filter(Files::isRegularFile)
.filter(p -> p.getFileName().toString().endsWith(".java"))
.forEach(files::add);
}
}
return files;
}
private static Path sourceNamed(String fileName) throws IOException {
Path module = moduleRoot();
for (String dir : SCANNED_DIRS) {
Path candidate = module.resolve(dir).resolve(fileName);
if (Files.isRegularFile(candidate)) {
return candidate;
}
}
Path mapper = module.resolve("src/main/java/com/nanri/aiimage/common/mapper").resolve(fileName);
if (Files.isRegularFile(mapper)) {
return mapper;
}
throw new IllegalStateException("找不到 " + fileName);
}
/** surefire 的工作目录是模块目录;从仓库根或 IDE 跑时退到 backend-java/。 */
private static Path moduleRoot() {
Path here = Path.of("").toAbsolutePath();
if (Files.isDirectory(here.resolve("src/main/java"))) {
return here;
}
Path nested = here.resolve("backend-java");
if (Files.isDirectory(nested.resolve("src/main/java"))) {
return nested;
}
throw new IllegalStateException("无法定位 backend-java 模块目录(cwd=" + here + ")");
}
private static String read(Path file) {
try {
return Files.readString(file, StandardCharsets.UTF_8);
} catch (IOException e) {
throw new IllegalStateException("读取失败: " + file, e);
}
}
}
@@ -0,0 +1,320 @@
package com.nanri.aiimage.common.security;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
/**
* 后台入口放开(2026-10-06)的三向绊线:入口门只长在"该页自己有门"的控制器上。
*
* <p>这次改动的形状是:{@code current-user/menus} 这道<b>入口</b>从"必须是管理员角色"改成
* "管理员角色 <b>或</b> 本公司树里至少有一条后台菜单授权",而每一页另有一道<b>页面门</b>
* ({@code PermissionMenuService.requireConsolePageAccess},判据是<b>这一页</b>的授权)。
* 两层分开是刻意的:只放开入口 = 把密钥页、扣次数的 ASIN 查询页一并送给了勾了一页的账号。</p>
*
* <p>所以这个类钉三件事,缺一件就是"显示宽于权限"或"权限宽于显示":</p>
* <ol>
* <li>管理/平台类 10 个控制器(用户、菜单、公司、密钥、版本、教程、设备日志、紫鸟授权)
* <b>仍走 requireAdmin</b> 且<b>没有</b> requireConsoleOperator —— 正向挡"授权能进管理页",
* 反向挡"顺手把 requireAdmin 删了导致谁都进不去"。</li>
* <li>用了入口门的控制器<b>恰好</b>是那 14 个:多一个就是有人把新页面接进了"有授权就能进"的通道,
* 少一个就是有人回滚了某页。分母钉死,不靠抽样。</li>
* <li>带页面门的 6 个控制器,那一行里必须出现<b>本页的 column_key</b>;不带的 8 个必须逐个登记
* 它靠什么把关(服务门 / 自己的 hasAnyAdminMenu / 只按 uid 取自己的数据)——
* "没页面门"必须是已知豁免,不能是漏了。</li>
* </ol>
*
* <p>另外两支钉实现细节:{@code PermissionMenuService} 那两个服务门里不得再残留
* {@code ensureAdminOperatorIfPresent}(它会让下面的授权判定变成普通账号永远走不到的死代码),
* 以及入口探针 {@code countAdminMenuGrants} 必须是标量 {@code COUNT(1)}
* (单列投影会让"整行皆 NULL"变成 List 里的 null 元素,鉴权链路上出过一次事故,
* 见 {@link AuthChainQueryShapeTest})。</p>
*
* <p>每支都带"取样集非空 / 切片截到了方法体"自检:扫描扫不到东西就恒绿,等于没护栏。</p>
*/
class ConsoleWideningGuardrailTest {
/** 管理/平台类页面:只能由管理员角色链进,菜单授权一律无效。 */
private static final List<String> ADMIN_ONLY_CONTROLLERS = List.of(
"modules/admin/controller/AdminUserController.java",
"modules/permission/controller/PermissionMenuController.java",
"modules/company/controller/CompanyController.java",
"modules/usersecret/controller/AdminUserApiSecretController.java",
"modules/usersecret/controller/AdminUserSecretUsageController.java",
"modules/softwareversion/controller/SoftwareVersionAdminController.java",
"modules/digitalhuman/controller/DigitalHumanVersionController.java",
"modules/tutorial/controller/TutorialAdminController.java",
"modules/devicelog/controller/AdminDeviceLogController.java",
"modules/ziniao/controller/ZiniaoAuthController.java");
/** 允许使用新入口门的全部控制器(多一个少一个都算有人改了这次的边界)。 */
private static final Set<String> ENTRY_DOOR_CONTROLLERS = Set.of(
"modules/admin/controller/AdminConsoleController.java",
"modules/imagehistory/controller/ImageHistoryController.java",
"modules/imagevideo/controller/AdminImageVideoTaskController.java",
"modules/notification/controller/AdminNotificationController.java",
"modules/productcategory/controller/ProductCategoryController.java",
"modules/shopdatacrawl/controller/AdminShopDataCrawlTaskController.java",
"modules/shopdatacrawl/controller/AdminShopDataCrawlTasksController.java",
"modules/shopduplicatecheck/controller/AdminShopDataDuplicateCheckController.java",
"modules/shopkey/controller/QueryAsinController.java",
"modules/shopkey/controller/ShopKeyController.java",
"modules/shopkey/controller/ShopManageController.java",
"modules/shopkey/controller/SkipPriceAsinController.java",
"modules/taskcenter/controller/AdminTaskCenterController.java");
/** 页面门:控制器 → 它自己那一页的 column_key。 */
private static final Map<String, String> PAGE_DOOR_KEYS = pageDoorKeys();
/** 有入口门但<b>没有</b> requireConsolePageAccess 的控制器 → 它靠什么把关(豁免登记)。 */
private static final Map<String, String> NO_PAGE_DOOR_EXEMPTIONS = noPageDoorExemptions();
private static Map<String, String> pageDoorKeys() {
Map<String, String> keys = new LinkedHashMap<>();
keys.put("modules/shopkey/controller/ShopManageController.java", "admin_shop_manage");
keys.put("modules/shopkey/controller/ShopKeyController.java", "admin_shop_keys");
keys.put("modules/shopkey/controller/QueryAsinController.java", "admin_query_asin");
keys.put("modules/shopkey/controller/SkipPriceAsinController.java", "admin_skip_price_asin");
keys.put("modules/productcategory/controller/ProductCategoryController.java", "admin_product_categories");
keys.put("modules/imagevideo/controller/AdminImageVideoTaskController.java", "admin_image_video_tasks");
return keys;
}
private static Map<String, String> noPageDoorExemptions() {
Map<String, String> exemptions = new LinkedHashMap<>();
// 这两支只回"我自己"的数据:一份是当前用户与他的菜单树(下发侧自己按角色剪枝),
// 一份是按 uid 取的通知——值就是那一行可执行锚点,不是描述文字
exemptions.put("modules/admin/controller/AdminConsoleController.java", "getUserColumnPermissions(");
exemptions.put("modules/notification/controller/AdminNotificationController.java", "return operator.getId();");
// 其余三支各自有专门的服务门 / 页内判定
exemptions.put("modules/imagehistory/controller/ImageHistoryController.java", "admin_history");
exemptions.put("modules/shopdatacrawl/controller/AdminShopDataCrawlTaskController.java",
"requireShopDataCrawlTaskAccess(");
exemptions.put("modules/shopdatacrawl/controller/AdminShopDataCrawlTasksController.java",
"requireShopDataCrawlTaskAccess(");
exemptions.put("modules/shopduplicatecheck/controller/AdminShopDataDuplicateCheckController.java",
"requireShopDataCrawlTaskAccess(");
exemptions.put("modules/taskcenter/controller/AdminTaskCenterController.java",
"requireClientTaskCenterAccess(");
return exemptions;
}
/** 出口 1(正向):管理类页面不得被菜单授权打开。 */
@Test
void adminOnlyPagesKeepTheRoleGateAndGainNoGrantDoor() throws IOException {
for (String rel : ADMIN_ONLY_CONTROLLERS) {
String source = read(mainSource(rel));
List<String> gateLines = executableLinesContaining(source, "requireAdmin");
assertThat(gateLines)
.as(rel + " 必须仍由 requireAdmin 把关:删了它 = 管理员也进不去(反向杀)")
.isNotEmpty();
assertThat(executableLinesContaining(source, "requireConsoleOperator"))
.as(rel + " 不得改用入口门:那等于" +
"勾一条菜单授权就能进用户管理/密钥管理(正向杀)")
.isEmpty();
}
}
/** 出口 2:入口门的落点恰好是登记过的那 13 支,分母从全树反推,不抽样。 */
@Test
void entryDoorSitesAreExactlyTheRegisteredControllers() throws IOException {
List<Path> controllers = allControllers();
Set<String> users = new LinkedHashSet<>();
for (Path p : controllers) {
if (!executableLinesContaining(read(p), "requireConsoleOperator").isEmpty()) {
users.add(relative(p));
}
}
assertThat(users)
.as("用了入口门的控制器集合必须与登记一致;多出的一支没人给它配页面门,"
+ "少的一支是有人把某页回滚成了 requireAdmin")
.containsExactlyInAnyOrderElementsOf(ENTRY_DOOR_CONTROLLERS);
}
/** 出口 3(正向杀):带页面门的每一支,那一行必须锚住<b>本页</b>的 key。 */
@Test
void eachWidenedPageDoorCarriesItsOwnMenuKey() throws IOException {
for (Map.Entry<String, String> e : PAGE_DOOR_KEYS.entrySet()) {
List<String> lines = executableLinesContaining(read(mainSource(e.getKey())), "requireConsolePageAccess");
assertThat(lines)
.as(e.getKey() + " 必须真的调页面门")
.isNotEmpty();
assertThat(lines)
.as(e.getKey() + " 的页面门必须判本页的 key(写成别的 key = 这页对普通账号永远 403)")
.anyMatch(line -> line.contains("\"" + e.getValue() + "\""));
}
}
/** 出口 3 的另一半:有入口门却没有页面门的,只能是需要逐个登记的豁免,不得是"忘了加"。 */
@Test
void controllersWithoutAPageDoorAreRegisteredExemptions() throws IOException {
List<String> missing = new ArrayList<>();
for (String rel : ENTRY_DOOR_CONTROLLERS) {
String source = read(mainSource(rel));
if (executableLinesContaining(source, "requireConsolePageAccess").isEmpty()) {
missing.add(rel);
}
}
assertThat(missing)
.as("未登记:有入口门、没有页面门、豁免表里也没有它")
.containsExactlyInAnyOrderElementsOf(NO_PAGE_DOOR_EXEMPTIONS.keySet());
for (Map.Entry<String, String> e : NO_PAGE_DOOR_EXEMPTIONS.entrySet()) {
String source = read(mainSource(e.getKey()));
String witness = e.getValue();
List<String> lines = executableLinesContaining(source, witness);
assertThat(lines)
.as(e.getKey() + " 的豁免理由(" + witness + ")必须真的在代码里,而不是只在注释里")
.isNotEmpty();
}
}
/** 页面门与入口门都不得被"先判管理员角色"抢跑,否则下面的授权判定变死代码。 */
@Test
void serviceDoorsJudgeByGrantNotByRole() throws IOException {
String service = read(mainSource("modules/permission/service/PermissionMenuService.java"));
String shopData = methodSlice(service, "public void requireShopDataCrawlTaskAccess(");
assertThat(shopData).as("切片必须截到方法体,否则下面的" +
" doesNotContain 会因为切到空串而恒绿").contains("无权查看店铺数据任务");
assertThat(shopData).doesNotContain("ensureAdminOperatorIfPresent");
assertThat(shopData).contains("hasEffectiveColumnPermission");
String taskCenter = methodSlice(service, "public void requireClientTaskCenterAccess(");
assertThat(taskCenter).contains("无权查看客户端任务管理");
assertThat(taskCenter).doesNotContain("ensureAdminOperatorIfPresent");
assertThat(taskCenter).contains("hasEffectiveColumnPermission");
String pageDoor = methodSlice(service, "public void requireConsolePageAccess(");
assertThat(pageDoor).contains("hasAnyAdminMenu");
// 页面门对管理员角色链恒放行(不改存量行为),普通账号才落到授权判定
assertThat(pageDoor).contains("isAdmin(operator)");
// 同一文件里 ensureAdminOperatorIfPresent 仍在别处使用 ⇒ 上面的"不再出现"是真的切片判定,
// 不是有人把这个方法整个删掉后两不找
assertThat(executableLinesContaining(service, "ensureAdminOperatorIfPresent(")).isNotEmpty();
}
/** 入口探针必须是标量 COUNT:单列投影在鉴权链路上出过一次全站 500。 */
@Test
void entryGrantProbeStaysAScalarCount() throws IOException {
String mapper = read(mainSource("common/mapper/AdminUserMapper.java"));
int at = mapper.indexOf("Long countAdminMenuGrants(");
assertThat(at).as("入口探针方法还在").isGreaterThan(0);
String head = mapper.substring(Math.max(0, at - 400), at);
assertThat(head).contains("SELECT COUNT(1)");
assertThat(head).doesNotContain(".select(");
// 探针必须仍限定本公司:否则别家公司的授权能给这条账号开门
assertThat(head).contains("cm.company_id");
assertThat(head).contains("ucp.user_id = #{userId}");
assertThat(head).contains("cm.menu_type = 'admin'");
assertThat(mapper.substring(at)).contains("@Param(\"companyId\")");
}
/** 自检:扫描面与两个分母都必须是实打实的非空,且页面门/豁免恰好铺满入口门清单。 */
@Test
void scannedSurfaceIsNotEmptyAndRegistersEverySite() throws IOException {
assertThat(allControllers()).as("一个控制器都没扫到 = 路径写错了,上面全是空转").isNotEmpty();
assertThat(ENTRY_DOOR_CONTROLLERS).hasSize(13);
assertThat(NO_PAGE_DOOR_EXEMPTIONS.keySet()).containsAll(
ENTRY_DOOR_CONTROLLERS.stream()
.filter(rel -> !PAGE_DOOR_KEYS.containsKey(rel))
.collect(Collectors.toSet()));
assertThat(PAGE_DOOR_KEYS).hasSize(6);
// 管理类清单必须真能扫到 requireAdmin,否则"没有 requireConsoleOperator"是扫了个空文件
for (String rel : ADMIN_ONLY_CONTROLLERS) {
assertThat(executableLinesContaining(read(mainSource(rel)), "requireAdmin"))
.as(rel + " 取样后仍要有可执行的 requireAdmin 调用").isNotEmpty();
}
}
// ---------- 取样 ----------
private static List<Path> allControllers() throws IOException {
Path root = mainRoot().resolve("modules");
try (Stream<Path> walk = Files.walk(root)) {
return walk
.filter(Files::isRegularFile)
.filter(p -> p.getFileName().toString().endsWith("Controller.java"))
.sorted()
.collect(Collectors.toList());
}
}
/**
* 可执行行:跳过注释行与 javadoc,避免"在注释里写了一句 requireAdmin"被当成锚点。
* 同时把 {@code * } 开头的续行排除掉——本类的说明文字里有这些方法名。
*/
private static List<String> executableLinesContaining(String source, String needle) {
return source.lines()
.map(String::trim)
.filter(line -> !line.startsWith("//") && !line.startsWith("*")
&& !line.startsWith("/*") && !line.startsWith("*/"))
.filter(line -> line.contains(needle))
.collect(Collectors.toList());
}
/** 从签名开始截到下一个同缩进的成员声明,取的就是那一支方法体(含其上方的注解)。 */
private static String methodSlice(String source, String signature) {
int start = source.indexOf(signature);
if (start < 0) {
fail("找不到 " + signature + " —— 方法被改名或这次改动没落进这个文件");
}
int next = source.indexOf("\n public ", start + signature.length());
int nextPrivate = source.indexOf("\n private ", start + signature.length());
int end = source.length();
if (next >= 0) {
end = Math.min(end, next);
}
if (nextPrivate >= 0) {
end = Math.min(end, nextPrivate);
}
return source.substring(start, end);
}
private static Path mainSource(String relative) {
Path file = mainRoot().resolve(relative);
if (!Files.isRegularFile(file)) {
fail("找不到 " + file + " —— 用例依赖以 backend-java 为工作目录运行,别让扫描静默通过");
}
return file;
}
private static String relative(Path file) {
return mainRoot().relativize(file).toString().replace('\\', '/');
}
private static Path mainRoot() {
Path here = Path.of("").toAbsolutePath();
Path direct = here.resolve("src/main/java/com/nanri/aiimage");
if (Files.isDirectory(direct)) {
return direct;
}
Path nested = here.resolve("backend-java").resolve("src/main/java/com/nanri/aiimage");
if (Files.isDirectory(nested)) {
return nested;
}
throw new IllegalStateException("无法定位 backend-java 源码目录(cwd=" + here + ")");
}
private static String read(Path file) {
try {
return Files.readString(file, StandardCharsets.UTF_8);
} catch (IOException e) {
throw new IllegalStateException("读取失败: " + file, e);
}
}
}
@@ -45,7 +45,7 @@ class AdminConsoleCurrentUserCompanyTest {
operator.setUsername("op");
operator.setRole("admin");
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(operator);
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(operator);
when(adminAuthSupport.currentRole(operator)).thenReturn("admin");
}
@@ -31,7 +31,7 @@ class AdminNotificationControllerTest {
@Test
void listAndSummaryUseOperatorIdAndAdminAudience() {
when(adminAuthSupport.requireAdmin(request)).thenReturn(admin(24L));
when(adminAuthSupport.requireConsoleOperator(request)).thenReturn(admin(24L));
controller.summary(request);
controller.page(request, 1L, 20L, false, "余额", NotificationService.CATEGORY_CONFIG_ERROR,
@@ -52,7 +52,7 @@ class AdminNotificationControllerTest {
@Test
void readMarkingStaysWithinOwnAdminAudienceRows() {
when(adminAuthSupport.requireAdmin(request)).thenReturn(admin(1L));
when(adminAuthSupport.requireConsoleOperator(request)).thenReturn(admin(1L));
controller.markRead(request, 18L);
controller.markAllRead(request);
@@ -0,0 +1,308 @@
package com.nanri.aiimage.modules.permission.service;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
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.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.permission.mapper.PermissionMenuMapper;
import com.nanri.aiimage.modules.permission.mapper.UserColumnPermissionMapper;
import com.nanri.aiimage.modules.permission.model.entity.PermissionMenuEntity;
import com.nanri.aiimage.modules.permission.model.entity.UserColumnPermissionEntity;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/**
* 后台页面门(2026-10-06)与入口放开后的菜单下发。
*
* <p>入口放开不等于整站放开:现网 44 个普通账号带着「店铺管理」授权,若逐页门只看入口,
* 它们顺手就能读同公司的密钥页、烧同公司的扣次数额度。
* {@link PermissionMenuService#requireConsolePageAccess} 就是那一页自己的门。</p>
*
* <p>另一半在下发侧:管理/平台页({@code ADMIN_ONLY_MENU_KEYS})的后端出口仍是 requireAdmin,
* 对普通账号继续下发这些菜单,等于给刚放进来的人画一排点了必 403 的死链。</p>
*/
class PermissionMenuServiceConsolePageTest {
private static final Long GROUP_ID = 200L;
private static final Long SHOP_PAGE_ID = 201L;
private static final Long USER_PAGE_ID = 202L;
private static final Long SECRET_PAGE_ID = 203L;
private static final Long TASK_CENTER_ID = 302L;
private static final Long SHOP_DATA_MENU_ID = 300L;
private static final Long SHOP_DATA_CHECK_ID = 303L;
private static final Long SHOP_DATA_KEY_ID = 301L;
private PermissionMenuMapper menuMapper;
private UserColumnPermissionMapper permissionMapper;
private AdminUserMapper userMapper;
private PermissionMenuService service;
/**
* wrapper 的 lambda 条件要有 TableInfo 才解析得出列名({@code getSqlSegment()} 同理)。
* 纯单测没有 Spring/MyBatis 启动过程,不初始化就会抛 {@code can not find lambda cache}。
*/
@BeforeAll
static void initMybatisPlusTableInfo() {
MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
TableInfoHelper.initTableInfo(assistant, AdminUserEntity.class);
TableInfoHelper.initTableInfo(assistant, PermissionMenuEntity.class);
TableInfoHelper.initTableInfo(assistant, UserColumnPermissionEntity.class);
}
@BeforeEach
void setUp() {
menuMapper = mock(PermissionMenuMapper.class);
permissionMapper = mock(UserColumnPermissionMapper.class);
userMapper = mock(AdminUserMapper.class);
service = new PermissionMenuService(menuMapper, permissionMapper, userMapper);
when(menuMapper.selectList(any())).thenReturn(catalog());
when(menuMapper.selectById(any())).thenAnswer(invocation ->
catalog().stream().filter(item -> item.getId().equals(invocation.getArgument(0)))
.findFirst().orElse(null));
// 与真库同形:requireDataPermission 走 selectOne,条件里带着本公司 + 那个 column_key。
// wrapper 的参数是**惰性**绑定的:不求值 getSqlSegment() 时 paramNameValuePairs 是空 map,
// 照空 map 过滤会让"命中"与"没命中"两支断言同时通过(夹具自己变成恒真)。
when(menuMapper.selectOne(any())).thenAnswer(invocation -> {
Collection<Object> params = params(invocation.getArgument(0));
return catalog().stream()
.filter(item -> params.contains(item.getColumnKey()) && params.contains(item.getCompanyId()))
.findFirst().orElse(null);
});
when(userMapper.selectById(any())).thenAnswer(invocation -> user((Long) invocation.getArgument(0)));
}
// ---------------------------------------------------------------- 逐页门
@Test
void adminRolePassesEveryPageDoorWithoutLookingAtGrants() {
assertThatCode(() -> service.requireConsolePageAccess(user(8L, "admin"), "无权访问店铺管理", "admin_shop_manage"))
.doesNotThrowAnyException();
verify(menuMapper, never()).selectList(any());
verify(permissionMapper, never()).selectByUserId(any());
}
@Test
void companySuperAdminAndSuperAdminPassPageDoorWithoutGrants() {
assertThatCode(() -> service.requireConsolePageAccess(
user(9L, "company_super_admin"), "无权访问店铺管理", "admin_shop_manage"))
.doesNotThrowAnyException();
assertThatCode(() -> service.requireConsolePageAccess(
user(1L, "super_admin"), "无权访问店铺管理", "admin_shop_manage"))
.doesNotThrowAnyException();
}
@Test
void normalAccountHoldingThisPagesGrantPasses() {
grants(7L, SHOP_PAGE_ID);
assertThatCode(() -> service.requireConsolePageAccess(
user(7L, "normal"), "无权访问店铺管理", "admin_shop_manage")).doesNotThrowAnyException();
}
/** 相反的一半:勾了别的页换不来这一页——否则"入口放开"就变成"整站放开"。 */
@Test
void normalAccountHoldingAnotherPageGrantIsDeniedThisPage() {
grants(7L, SECRET_PAGE_ID);
BusinessException ex = catchThrowableOfType(() -> service.requireConsolePageAccess(
user(7L, "normal"), "无权访问店铺管理", "admin_shop_manage"), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
assertThat(ex.getMessage()).isEqualTo("无权访问店铺管理");
}
/** 勾父分组覆盖后代是授权页的既有语义,这一页的门必须照认。 */
@Test
void parentGroupGrantCoversTheChildPageDoor() {
grants(7L, GROUP_ID);
assertThatCode(() -> service.requireConsolePageAccess(
user(7L, "normal"), "无权访问店铺管理", "admin_shop_manage")).doesNotThrowAnyException();
}
@Test
void normalAccountWithoutAnyGrantIsDenied() {
grants(7L);
BusinessException ex = catchThrowableOfType(() -> service.requireConsolePageAccess(
user(7L, "normal"), "无权访问店铺管理", "admin_shop_manage"), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
}
/** 多个键是"任一命中",不是"全部命中"。 */
@Test
void anyOfSeveralKeysOpensTheDoor() {
grants(7L, SECRET_PAGE_ID);
assertThatCode(() -> service.requireConsolePageAccess(
user(7L, "normal"), "无权", "admin_shop_manage", "admin_user_secrets"))
.doesNotThrowAnyException();
}
// ---------------------------------------------------------------- 下发侧剪枝
@Test
void managementMenusAreNotPushedDownToNormalAccounts() {
grants(7L, USER_PAGE_ID, SECRET_PAGE_ID, SHOP_PAGE_ID);
List<PermissionMenuItemVo> items = service.getUserColumnPermissions(null, 7L, "admin", false);
assertThat(items).extracting(PermissionMenuItemVo::getColumnKey)
.as("店铺管理是数据页:普通账号被授了就照下发")
.contains("admin_shop_manage");
assertThat(items).extracting(PermissionMenuItemVo::getColumnKey)
.as("用户管理/密钥管理的后端出口仍是 requireAdmin,下发出去就是死链")
.doesNotContain("admin_users", "admin_user_secrets");
}
/** 相反的一半:管理员角色照旧拿到管理页——放开普通账号不能顺手把管理员的菜单弄红。 */
@Test
void managementMenusStayVisibleForAdminRoles() {
when(userMapper.selectById(8L)).thenReturn(user(8L, "admin"));
grants(8L, USER_PAGE_ID, SECRET_PAGE_ID, SHOP_PAGE_ID);
List<PermissionMenuItemVo> items = service.getUserColumnPermissions(
user(8L, "admin"), 8L, "admin", false);
assertThat(items).extracting(PermissionMenuItemVo::getColumnKey)
.contains("admin_users", "admin_user_secrets", "admin_shop_manage");
}
@Test
void superAdminStillGetsTheWholeTree() {
when(userMapper.selectById(1L)).thenReturn(user(1L, "super_admin"));
List<PermissionMenuItemVo> items = service.getUserColumnPermissions(null, 1L, "admin", false);
assertThat(items).extracting(PermissionMenuItemVo::getColumnKey)
.contains("admin_users", "admin_user_secrets", "admin_shop_manage");
}
// ----------------------------------------------------- 店铺数据/客户端任务的授权门
/** 这两道门此前第一句就判角色,普通账号即便被勾了菜单也永远走不到下面的授权命中(死代码)。 */
@Test
void shopDataDoorAdmitsNormalAccountHoldingTheGrants() {
grants(7L, SHOP_DATA_MENU_ID, SHOP_DATA_KEY_ID);
assertThatCode(() -> service.requireShopDataCrawlTaskAccess(user(7L, "normal")))
.doesNotThrowAnyException();
}
@Test
void shopDataDoorStillDeniesNormalAccountWithoutTheGrants() {
grants(7L, SHOP_PAGE_ID);
BusinessException ex = catchThrowableOfType(
() -> service.requireShopDataCrawlTaskAccess(user(7L, "normal")), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
assertThat(ex.getMessage()).isEqualTo("无权查看店铺数据任务");
}
@Test
void clientTaskDoorAdmitsNormalAccountHoldingThatMenu() {
grants(7L, TASK_CENTER_ID);
assertThatCode(() -> service.requireClientTaskCenterAccess(user(7L, "normal")))
.doesNotThrowAnyException();
}
@Test
void clientTaskDoorStillDeniesNormalAccountWithoutIt() {
grants(7L, SHOP_PAGE_ID);
BusinessException ex = catchThrowableOfType(
() -> service.requireClientTaskCenterAccess(user(7L, "normal")), BusinessException.class);
assertThat(ex.getCode()).isEqualTo(403);
assertThat(ex.getMessage()).isEqualTo("无权查看客户端任务管理");
}
// ---------------------------------------------------------------- 夹具
private void grants(Long userId, Long... columnIds) {
List<UserColumnPermissionEntity> rows = new ArrayList<>();
for (Long columnId : columnIds) {
UserColumnPermissionEntity row = new UserColumnPermissionEntity();
row.setUserId(userId);
row.setColumnId(columnId);
rows.add(row);
}
when(permissionMapper.selectByUserId(userId)).thenReturn(rows);
}
/** 取出 wrapper 上的绑定值;MP 是惰性绑定,不求值 SQL 段时那个 map 是空的。 */
private static Collection<Object> params(LambdaQueryWrapper<PermissionMenuEntity> query) {
String segment = query.getSqlSegment();
Collection<Object> values = query.getParamNameValuePairs().values();
if (values.isEmpty()) {
throw new IllegalStateException("夹具读不到 wrapper 条件(segment=" + segment
+ ")——空 map 会让命中/不命中两支断言同时通过");
}
return values;
}
private List<PermissionMenuEntity> catalog() {
return List.of(
menu(GROUP_ID, "admin_group_shop", null),
menu(SHOP_PAGE_ID, "admin_shop_manage", GROUP_ID),
menu(USER_PAGE_ID, "admin_users", null),
menu(SECRET_PAGE_ID, "admin_user_secrets", null),
menu(TASK_CENTER_ID, "admin_task_center", null),
// 店铺数据那道门要同时命中「可见菜单」与内部数据权限
menu(SHOP_DATA_MENU_ID, "admin_shop_data_crawl_tasks", null),
menu(SHOP_DATA_CHECK_ID, "admin_shop_data_duplicate_check", null),
menu(SHOP_DATA_KEY_ID, "admin_shop_data_crawl_task_data", null));
}
private PermissionMenuEntity menu(Long id, String columnKey, Long parentId) {
PermissionMenuEntity entity = new PermissionMenuEntity();
entity.setId(id);
entity.setColumnKey(columnKey);
entity.setName(columnKey);
entity.setParentId(parentId);
entity.setMenuType("admin");
entity.setCompanyId(1L);
entity.setSortOrder(id.intValue());
return entity;
}
/** 缺省按普通账号建:夹具里 7L/8L/1L 这些 id 的角色由显式重载覆盖。 */
private AdminUserEntity user(Long id) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
user.setUsername("u" + id);
user.setRole("normal");
user.setIsAdmin(0);
user.setCreatedById(1L);
user.setCompanyId(1L);
return user;
}
private AdminUserEntity user(Long id, String role) {
AdminUserEntity user = user(id);
user.setRole(role);
user.setIsAdmin("normal".equals(role) ? 0 : 1);
return user;
}
}
@@ -25,7 +25,7 @@ class AdminShopDataCrawlTaskControllerTest {
AdminShopDataCrawlTaskController controller = new AdminShopDataCrawlTaskController(
taskService, authSupport, permissionService);
AdminUserEntity operator = admin(8L);
when(authSupport.requireAdmin(request)).thenReturn(operator);
when(authSupport.requireConsoleOperator(request)).thenReturn(operator);
controller.deleteHistory(101L, request);
@@ -43,7 +43,7 @@ class AdminShopDataCrawlTaskControllerTest {
taskService, authSupport, permissionService);
when(authSupport.isTrustedSuppliedToken("shared-token")).thenReturn(true);
AdminUserEntity operator = admin(8L);
when(authSupport.requireAdmin(request)).thenThrow(new BusinessException(401, "not logged in"));
when(authSupport.requireConsoleOperator(request)).thenThrow(new BusinessException(401, "not logged in"));
when(request.getHeader("X-Internal-Token")).thenReturn("shared-token");
when(request.getParameter("operatorId")).thenReturn("8");
when(permissionService.requireAdminOperator(8L)).thenReturn(operator);
@@ -65,7 +65,7 @@ class AdminShopDataCrawlTaskControllerTest {
taskService, authSupport, permissionService);
AdminUserEntity operator = admin(8L);
BusinessException denied = new BusinessException(403, "no data permission");
when(authSupport.requireAdmin(request)).thenReturn(operator);
when(authSupport.requireConsoleOperator(request)).thenReturn(operator);
org.mockito.Mockito.doThrow(denied)
.when(permissionService).requireShopDataCrawlTaskAccess(operator);
@@ -45,16 +45,18 @@ class ShopKeyControllerCompanyScopeTest {
private AdminAuthSupport adminAuthSupport;
@Mock
private DataReadScope dataReadScope;
@Mock
private com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService;
private ShopKeyController controller() {
return new ShopKeyController(shopKeyService, adminAuthSupport, dataReadScope);
return new ShopKeyController(shopKeyService, adminAuthSupport, dataReadScope, permissionMenuService);
}
@Test
@DisplayName("列表:tab 的公司 id 交给 readCompanyIdOrOwn,出口给什么 service 就用什么")
void pagePassesTheTabValueThroughTheDoor() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID);
controller().page(request, 1L, 15L, COMPANY_ID);
@@ -72,7 +74,7 @@ class ShopKeyControllerCompanyScopeTest {
@DisplayName("列表:出口判超管(null)时把 null 传下去,不补任何公司 id")
void pageKeepsTheDoorsUnfilteredVerdict() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(null);
controller().page(request, 1L, 15L, COMPANY_ID);
@@ -88,7 +90,7 @@ class ShopKeyControllerCompanyScopeTest {
@DisplayName("列表:出口按会话收窄后,交给 service 的是收窄值而不是请求里的值")
void pageUsesTheNarrowedValueNotTheRequestedOne() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(99L))).thenReturn(COMPANY_ID);
controller().page(request, 1L, 15L, 99L);
@@ -100,7 +102,7 @@ class ShopKeyControllerCompanyScopeTest {
@DisplayName("更新/删除/白名单检测:把 writeCompanyId 的判定原样交给 service,controller 不自己补公司 id")
void writeEndpointsPassTheRowOwnershipGate() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(COMPANY_ID);
ShopKeyUpdateRequest body = new ShopKeyUpdateRequest();
body.setZiniaoAccountName("ziniao-a");
@@ -121,7 +123,7 @@ class ShopKeyControllerCompanyScopeTest {
@DisplayName("写侧:闸门判超管(null)时把 null 传下去,否则超管被锁死在本公司")
void writeGateKeepsTheSuperAdminVerdict() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(null);
ShopKeyUpdateRequest body = new ShopKeyUpdateRequest();
body.setZiniaoAccountName("ziniao-a");
@@ -140,7 +142,7 @@ class ShopKeyControllerCompanyScopeTest {
@DisplayName("新增:只把操作者 id 交给 service,公司由 service 从会话推导")
void createPassesOnlyTheOperator() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(adminAuthSupport.requireConsoleOperatorOrInternal(request)).thenReturn(user());
ShopKeyCreateRequest body = new ShopKeyCreateRequest();
body.setZiniaoAccountName("ziniao-a");
body.setZiniaoToken("token-a");
@@ -32,10 +32,13 @@ class ShopManageCredentialAuthTest {
private final ShopManageGroupService shopManageGroupService = mock(ShopManageGroupService.class);
private final AdminAuthSupport adminAuthSupport = mock(AdminAuthSupport.class);
private final DataReadScope dataReadScope = mock(DataReadScope.class);
private final com.nanri.aiimage.modules.permission.service.PermissionMenuService permissionMenuService =
mock(com.nanri.aiimage.modules.permission.service.PermissionMenuService.class);
private final HttpServletRequest request = mock(HttpServletRequest.class);
private ShopManageController newController() {
return new ShopManageController(shopManageService, shopManageGroupService, adminAuthSupport, dataReadScope);
return new ShopManageController(shopManageService, shopManageGroupService, adminAuthSupport,
dataReadScope, permissionMenuService);
}
@Test