fix(proxy): 青果检测改真探并按供应商分码,三面收口凭据外漏与「无法判定」

用户报「青果也要加检测」,往下挖出四层假象,一次收口:

- 后端:probeProxy 的青果短路(过去无条件回「提取成功(青果隧道端点,连接鉴权在客户端)」,
  依据的注释已过期——存下来的链接里就带 key/pwd)删掉,改成真打一次提取,按供应商返回码
  分档出独立 check_code:channel_busy / invalid_key / forbidden / rate_limited /
  insufficient_balance / tunnel_unverified。文案出口一律抹 key/pwd。
- 后端:巡检遇 channel_busy 不落库也不推通知。通道被占不是「密钥坏了」而是「此刻问不出
  结论」,而巡检自己那一发真提取就要占掉唯一一条通道——落库等于把用户早上看到的
  「代理异常」写成我们自己造成的。
- 后端:余量口径按供应商分档。青果账号此前会落进「否则查平台套餐」那条,界面显示的是
  别人家的 jikip 余量(串档);青果不提供可鉴权的余量/余额查询(余额接口是控制台
  appid/appkey 签名档),这一档宁可返回「查不了」也不借极客的数。
- 后端:SecretMasking.maskProxy 的脏值回落不再套 mask()——它保后 4 字符,而青果的 pwd=
  恰好挂在末尾,等于把口令尾 4 位交给界面与日志;改成只交「像 host 的那一段」。
- 用户端:去掉「青果账密直连,无需检测」的 disabled 例外,未保存账密现拼链接送检;
  「无法判定」回落改成后端文案原样显示+可重试语义;代理卡不再套 LLM 渠道字典
  (「龙抬头」错标的真根因就在这行)。
- 后管:货源标签拆成两张互不相通的字典,代理列只读 masked 且不回落到原文,删掉
  user-select:all 的全选复制旁路,「修改代理」改成重填 Authkey/Authpwd 的弹窗。

判据:SecretMaskingTest(5)、UserProxyBalanceServiceTest(6)、UserApiSecretServiceTest
(+1 巡检不落库)、UserApiSecretCheckServiceTest(+138 行分码)、ProxyLinkKeyTest、
用户端 node 5 支+mount 10 支、后管 node 9 支+mount 8 支。后端整量 5187/0 失败,
full 闸门四面绿。
This commit is contained in:
2026-11-02 15:18:41 +08:00
parent 7f5437d012
commit 7e64c12dd6
24 changed files with 2062 additions and 204 deletions
@@ -33,7 +33,7 @@ public final class SecretMasking {
try {
URI uri = URI.create(value.trim());
if (uri.getHost() == null || uri.getHost().isBlank()) {
return mask(value);
return hostOnlyOrHidden(value);
}
StringBuilder masked = new StringBuilder();
masked.append(uri.getScheme() == null ? "http" : uri.getScheme()).append("://");
@@ -46,7 +46,37 @@ public final class SecretMasking {
}
return masked.toString();
} catch (Exception ex) {
return mask(value);
return hostOnlyOrHidden(value);
}
}
/**
* 解析不出 host 的代理串(无 scheme 的 {@code host/get?key=..&pwd=..}、脏值、纯凭据串)走这里。
*
* <p>不能套 {@link #mask}:它保前 4 <b>和后 4</b>,而青果链接的 {@code pwd=} 就挂在末尾——
* 那等于把口令尾 4 位交给界面与日志(2026-11-02 后管「密钥管理」列的残余外漏形状)。
* 这里只肯交出「像 host 的那一段」,其余一个字符都不给。</p>
*/
private static String hostOnlyOrHidden(String value) {
String text = value.trim();
int scheme = text.indexOf("://");
String rest = scheme >= 0 ? text.substring(scheme + 3) : text;
int at = rest.lastIndexOf('@');
if (at >= 0) {
rest = rest.substring(at + 1);
}
int cut = rest.length();
for (char boundary : new char[]{'/', '?', '#'}) {
int index = rest.indexOf(boundary);
if (index >= 0) {
cut = Math.min(cut, index);
}
}
String host = rest.substring(0, cut);
// 没有点号的不认 host(多半是裸凭据),带 = 的更可能是整串 query
if (host.isBlank() || !host.contains(".") || host.contains("=")) {
return "****";
}
return "****" + host;
}
}
@@ -18,10 +18,10 @@ public class AdminUserSecretModuleVo {
@Schema(description = "货源:LLM 行为渠道(longtaitou/t8star),代理行为供应商(qingguo/jikip)")
private String channel;
@Schema(description = "脱敏值")
@Schema(description = "脱敏值(代理列为 scheme://host[:port],不含链接里的 key/pwd)")
private String masked;
@Schema(description = "完整明文值:仅代理列返回(含账号密码),密钥列为空")
@Schema(description = "完整明文值:后台侧一律不再下发(2026-11-02 收口,代理链接里带账密);字段保留只为界面兼容,恒为空")
private String full;
@Schema(description = "是否已配置")
@@ -8,6 +8,7 @@ import com.nanri.aiimage.config.HttpClientPool;
import com.nanri.aiimage.config.SimilarAsinProperties;
import com.nanri.aiimage.config.UserSecretProperties;
import com.nanri.aiimage.modules.usersecret.client.JikipProxyClient;
import com.nanri.aiimage.modules.usersecret.support.ProxyLinkKey;
import com.nanri.aiimage.modules.usersecret.support.UserSecretModule;
import com.nanri.aiimage.modules.usersecret.support.ProxyProvider;
import com.nanri.aiimage.modules.usersecret.support.LlmChannel;
@@ -56,10 +57,25 @@ public class UserApiSecretCheckService {
public static final String CODE_TIMEOUT = "timeout";
public static final String CODE_PROVIDER_ERROR = "provider_error";
public static final String CODE_INSUFFICIENT_BALANCE = "insufficient_balance";
/**
* 青果通道被占满({@code NO_AVAILABLE_CHANNEL}):隧道转发按存活周期只给一条通道,
* 检测里这一次提取就是在抢通道;抢不到是「稍后再点」,不是「密钥坏了」,必须与
* {@link #CODE_PROVIDER_ERROR} 分开——混成一个码,界面只能显示「无法判定」(现网 uid=1301)。
*/
public static final String CODE_CHANNEL_BUSY = "channel_busy";
/** 隧道端点拿到了,但服务端组不出可验连的地址(链接未带 key/pwd,或账密含会切歪 host 的分隔符)。 */
public static final String CODE_TUNNEL_UNVERIFIED = "tunnel_unverified";
/** 供应商欠费提示文案(前后端都按 code 识别展示)。 */
public static final String INSUFFICIENT_BALANCE_MESSAGE = "代理服务商余额不足,请充值后重试";
/** 通道被自己占用的提示文案:说人话,并给出可执行的下一步(等存活周期释放)。 */
public static final String CHANNEL_BUSY_MESSAGE = "青果通道正被你自己的采集占着,等约 3 分钟释放后再点检测";
/** 提取成功但服务端无法验连的提示文案:如实说"没验成",不拿它冒充 passed。 */
public static final String TUNNEL_UNVERIFIED_MESSAGE = "青果提取成功,但这条链接里没有可用于隧道验连的 key/pwd,"
+ "服务端无法确认代理是否可用(青果只支持账密档,请在密钥设置里补全提取链接)";
/** 超时与网络不可达提示文案:面向用户展示,技术细节只进服务端日志。 */
public static final String TIMEOUT_MESSAGE = "检测超时:上游服务响应超时,请稍后重试";
public static final String NETWORK_ERROR_MESSAGE = "网络不可达:无法连接上游服务,请检查网络后重试";
@@ -78,6 +94,12 @@ public class UserApiSecretCheckService {
private static final Pattern IP_PORT_PATTERN =
Pattern.compile("(\\d{1,3}(?:\\.\\d{1,3}){3}):(\\d{2,5})");
/** 供应商文案里可能回显的凭据型查询参数(值一律盖掉)。 */
private static final Pattern CREDENTIAL_PARAM_PATTERN =
Pattern.compile("(?i)\\b(key|pwd|password|passwd|token|secret)=([^&\\s\"]+)");
/** 短于这个长度的值不按原文替换:像 "0"/"ab" 这种会误伤正常文案。 */
private static final int MIN_REDACT_LENGTH = 4;
private final AppearancePatentProperties appearancePatentProperties;
private final SimilarAsinProperties similarAsinProperties;
private final UserSecretProperties userSecretProperties;
@@ -168,13 +190,19 @@ public class UserApiSecretCheckService {
/**
* 代理配置探测(按「提取链接」语义,与品牌检测的实际用法一致):
* 先 GET 用户链接真实提取一次——余额不足报余额不足、解析不出 IP 报配置错误;
* 提取到 IP(可含账密)后经该代理请求一次自家域名,拿到任意 HTTP 响应即转发可用。
* 先 GET 用户链接真实提取一次——余额不足报余额不足、通道占用报通道占用、解析不出 IP 报配置错误;
* 提取到端点后经它请求一次自家域名,拿到任意 HTTP 响应才算转发可用。
* 兼容纯静态代理地址(无 path/query 的 host:port)直接探测。
*
* <p>2026-09-13 修复:旧实现把提取链接直接交给 HttpClientPool 当静态代理使用,链接无
* 显式端口时解析失败会静默回退直连,探测到的是自家站点的直连响应——40 个用户全部
* 「假通过」(3-39ms + HTTP 301),余额不足 / 链接失效都测不出来。
* 「假通过」(3-39ms + HTTP 301),余额不足 / 链接失效都测不出来。</p>
*
* <p>2026-11-02 修复(青果):那次修复只覆盖了极客,青果分支仍在看不到账密的借口下
* 「提取成功=passed」短路。现在青果也走真实的经隧道转发探测,供应商返回码逐档落独立
* code(见 {@link #classifyProviderRejection})。副作用要如实登记:这一次提取会占掉
* 青果那唯一一条通道(存活周期约 3 分钟),所以「点检测」本身是有一次通道成本的,
* 服务层的新鲜期复用({@code reuseFreshOutcome})是它唯一的挡箭牌。</p>
*/
private CheckOutcome probeProxy(String proxyUrl) {
return probeProxy(proxyUrl, null);
@@ -200,8 +228,8 @@ public class UserApiSecretCheckService {
}
// 提取链接:先真实提取一次。刻意读响应体而不依赖 2xx——
// 青果的失败码(API_AUTH_DENY / BALANCE_INSUFFICIENT)走 HTTP 4xx,
// 交给 RestClient 抛异常会把「密钥没授权」误报成「接口无法访问」。
// 青果的失败码(API_AUTH_DENY / BALANCE_INSUFFICIENT / NO_AVAILABLE_CHANNEL)走 HTTP 4xx,
// 交给 RestClient 抛异常会把「密钥没授权」「通道被占」统统误报成「接口无法访问」。
StatusAndBody extract;
try {
extract = clientFor(null).get().uri(normalized)
@@ -216,7 +244,7 @@ public class UserApiSecretCheckService {
"代理提取接口无法访问,请检查提取链接或稍后重试", (int) latency, false);
}
long extractLatency = System.currentTimeMillis() - startMillis;
CheckOutcome rejection = classifyProviderRejection(provider, extract.body(), (int) extractLatency);
CheckOutcome rejection = classifyProviderRejection(provider, extract.body(), (int) extractLatency, normalized);
if (rejection != null) {
log.warn("[user-secret][check] 代理提取被供应商拒绝 provider={} httpStatus={} code={}",
provider.key(), extract.statusCode(), rejection.code());
@@ -225,33 +253,95 @@ public class UserApiSecretCheckService {
String extractedProxyUrl = extractProxyUrlFromBody(extract.body());
if (extractedProxyUrl == null) {
log.warn("[user-secret][check] 代理提取响应未解析出 IP provider={} httpStatus={} 响应前 150 字={}",
provider.key(), extract.statusCode(), abbreviate(extract.body(), 150));
provider.key(), extract.statusCode(),
redactCredentials(abbreviate(extract.body(), 150), normalized));
return new CheckOutcome(STATUS_FAILED, CODE_INVALID_KEY,
"链接未返回可用 IP,请检查代理提取配置", (int) extractLatency, false);
}
if (provider == ProxyProvider.QINGGUO) {
// 青果通道提取返回的是**隧道端点**(如 tunpool-xxx.qg.net:16359),连它要用
// Authkey/Authpwd 做 Basic 认证,而这对账密只存在用户本机、不上报服务端;
// 所以这里只验"提取接口可用且拿到端点",连接态由客户端的实际任务证明。
log.info("[user-secret][check] 青果提取成功,跳过经隧道探测(端点鉴权在客户端)endpoint={}",
SecretMasking.maskProxy(extractedProxyUrl));
return new CheckOutcome(STATUS_PASSED, CODE_OK,
"提取成功(青果隧道端点,连接鉴权在客户端)", (int) extractLatency, false);
return probeQingguoTunnel(normalized, extractedProxyUrl, startMillis);
}
return probeThroughProxy(extractedProxyUrl, startMillis);
}
/**
* 青果隧道真探(2026-11-02 改):旧实现在这里短路返回 {@code passed/ok}「提取成功(青果隧道端点,
* 连接鉴权在客户端)」,依据是「这对账密只存在用户本机、不上报服务端」——那句注释已经过期:
* 青果只做账密档(AGENTS.md 铁律 25),用户填进来并存下来的提取链接里就带着 {@code key=} 与 {@code pwd=}。
* 服务端既然拿得到凭据,就必须拿它经隧道打一次自家域名,否则「提取成功」永远冒充「代理可用」。
* 现网 uid=1301(2026-11-02 13:08)是同一条路上另一半的坑:提取回 {@code NO_AVAILABLE_CHANNEL}
* 被落成一坨 {@code provider_error},界面只剩「无法判定」——所以本方法连同
* {@link #classifyProviderRejection} 一起改:探测要真打,失败要一档一码。
*
* <p>组出来的带鉴权地址只在内存里存在,日志与文案一律只出现 {@link SecretMasking#maskProxy} 之后的端点。</p>
*/
CheckOutcome probeQingguoTunnel(String extractLink, String endpointUrl, long startMillis) {
String tunnelProxyUrl = qingguoTunnelProxyUrl(extractLink, endpointUrl);
if (tunnelProxyUrl == null) {
int latency = (int) (System.currentTimeMillis() - startMillis);
log.warn("[user-secret][check] 青果隧道无法组链验连(链接未带可用 key/pwd)endpoint={}",
SecretMasking.maskProxy(endpointUrl));
return new CheckOutcome(STATUS_ERROR, CODE_TUNNEL_UNVERIFIED, TUNNEL_UNVERIFIED_MESSAGE, latency, false);
}
log.info("[user-secret][check] 青果隧道探测开始 endpoint={}(账密来自本条链接,不入日志)",
SecretMasking.maskProxy(tunnelProxyUrl));
return probeThroughProxy(tunnelProxyUrl, startMillis);
}
/**
* 给青果隧道端点补上链接里的 key/pwd:补不出安全可解析的地址就返回 null(宁可不验,也不猜一条
* 会把 host 切歪的地址——{@code pwd} 里含 {@code @}/{@code :} 时 userinfo 会吞掉主机名)。
*/
static String qingguoTunnelProxyUrl(String extractLink, String endpointUrl) {
if (endpointUrl == null || !looksLikeStaticProxy(endpointUrl)) {
return null;
}
String key = ProxyLinkKey.fromUrl(extractLink);
String pwd = ProxyLinkKey.passwordFromUrl(extractLink);
if (!urlSafeCredential(key) || !urlSafeCredential(pwd)) {
return null;
}
int schemeEnd = endpointUrl.indexOf("://");
if (schemeEnd < 0) {
return null;
}
return endpointUrl.substring(0, schemeEnd + 3) + key + ":" + pwd + "@" + endpointUrl.substring(schemeEnd + 3);
}
/** 能原样嵌进 userinfo 的凭据判定:URL 分隔符与控制字符/空白一律不算(青果的 Authkey/Authpwd 本就不含它们)。 */
private static boolean urlSafeCredential(String value) {
if (value == null || value.isBlank()) {
return false;
}
for (int i = 0; i < value.length(); i++) {
char c = value.charAt(i);
if (c <= ' ' || c == ':' || c == '@' || c == '/' || c == '?' || c == '#' || c == '%' || c == '&') {
return false;
}
}
return true;
}
/**
* 供应商拒付/鉴权失败的独立分类(两家错误码词表不同):
* <ul>
* <li>青果:code 为字符串。BALANCE_INSUFFICIENT=余额不足;INVALID_KEY/UNAVAILABLE_KEY/KEY_BLOCK/
* ACCESS_DENY/API_AUTH_DENY=密钥不可用或未授权;REQUEST_LIMIT_EXCEEDED=限流;
* INVALID_PARAMETER=参数错;其余业务失败按上游异常。</li>
* <li>青果:code 为字符串,逐码分档,**一档一个 code**——
* BALANCE_INSUFFICIENT=余额不足;INVALID_KEY/UNAVAILABLE_KEY/KEY_BLOCK=密钥本身不可用;
* API_AUTH_DENY/ACCESS_DENY=这一条链接的鉴权没过(多数是 pwd 没填);
* NO_AVAILABLE_CHANNEL=通道被自己的采集占着({@link #CODE_CHANNEL_BUSY},稍后再点);
* REQUEST_LIMIT_EXCEEDED=限流;INVALID_PARAMETER=参数错;其余业务失败按上游异常。</li>
* <li>极客:沿用历史口径(code=-1 或 message 含「余额不足」=余额不足)。</li>
* </ul>
* 返回 null 表示不是拒付/鉴权类失败,继续走 IP 解析。
*
* <p>供应商文案可能整条回显请求链接(含 key/pwd),出口前一律过 {@link #redactCredentials}。</p>
*/
CheckOutcome classifyProviderRejection(ProxyProvider provider, String body, int latencyMs) {
return classifyProviderRejection(provider, body, latencyMs, null);
}
/** {@code extractLink} 只用于抹掉供应商文案里回显的本条链接凭据,不参与判定。 */
CheckOutcome classifyProviderRejection(ProxyProvider provider, String body, int latencyMs, String extractLink) {
if (provider == ProxyProvider.QINGGUO) {
JsonNode root = parseJson(body);
if (root == null || !root.isObject()) {
@@ -262,21 +352,25 @@ public class UserApiSecretCheckService {
if (code.isEmpty() || "SUCCESS".equalsIgnoreCase(code) || "0".equals(code)) {
return null;
}
String message = text(root.get("message"));
String message = redactCredentials(text(root.get("message")), extractLink);
String detail = message == null || message.isBlank() ? "" : ":" + abbreviate(message, 120);
String upper = code.toUpperCase(java.util.Locale.ROOT);
return switch (upper) {
case "BALANCE_INSUFFICIENT" ->
new CheckOutcome(STATUS_FAILED, CODE_INSUFFICIENT_BALANCE, INSUFFICIENT_BALANCE_MESSAGE, latencyMs, false);
case "INVALID_KEY", "UNAVAILABLE_KEY", "KEY_BLOCK", "ACCESS_DENY", "API_AUTH_DENY" ->
new CheckOutcome(STATUS_FAILED, CODE_FORBIDDEN,
"青果密钥不可用或未授权(" + upper + ")" + detail, latencyMs, false);
case "REQUEST_LIMIT_EXCEEDED" ->
new CheckOutcome(STATUS_ERROR, CODE_RATE_LIMITED, "青果提取触发限流,本次无法判定" + detail, latencyMs, false);
case "NO_AVAILABLE_CHANNEL" ->
// 通道被占满(存活期内一个通道只给一个端点):不是密钥问题,稍后重试即可
new CheckOutcome(STATUS_ERROR, CODE_PROVIDER_ERROR,
"青果通道已全部占用,请等当前通道释放(约 3 分钟)后重试" + detail, latencyMs, false);
// 通道被占满(存活期内一个通道只给一个端点):不是密钥问题,等释放后重点一次即可
new CheckOutcome(STATUS_ERROR, CODE_CHANNEL_BUSY, CHANNEL_BUSY_MESSAGE, latencyMs, false);
case "INVALID_KEY", "UNAVAILABLE_KEY", "KEY_BLOCK" ->
new CheckOutcome(STATUS_FAILED, CODE_INVALID_KEY,
"青果密钥不可用或已失效(" + upper + "),请核对提取链接里的 key" + detail, latencyMs, false);
case "API_AUTH_DENY", "ACCESS_DENY" ->
new CheckOutcome(STATUS_FAILED, CODE_FORBIDDEN,
"青果拒绝了这条链接的鉴权(" + upper + "),请检查提取链接里的 pwd(青果只支持账密档,pwd 必填)"
+ detail, latencyMs, false);
case "REQUEST_LIMIT_EXCEEDED" ->
new CheckOutcome(STATUS_ERROR, CODE_RATE_LIMITED,
"青果提取接口请求过于频繁(限流),请等约 1 分钟后再点检测" + detail, latencyMs, false);
case "INVALID_PARAMETER" ->
new CheckOutcome(STATUS_FAILED, CODE_BAD_REQUEST, "青果提取参数不正确" + detail, latencyMs, false);
default ->
@@ -289,6 +383,24 @@ public class UserApiSecretCheckService {
return null;
}
/**
* 抹掉文案里回显的链接凭据:先按参数名把 {@code key=…}/{@code pwd=…} 的值盖掉,
* 再按这把 key/pwd 的原文逐处替换(供应商可能只回显裸值、不带参数名)。
* 返回值用于日志与界面,绝不带凭据原文。
*/
static String redactCredentials(String text, String extractLink) {
if (text == null || text.isEmpty()) {
return text;
}
String redacted = CREDENTIAL_PARAM_PATTERN.matcher(text).replaceAll("$1=****");
for (String secret : new String[]{ProxyLinkKey.fromUrl(extractLink), ProxyLinkKey.passwordFromUrl(extractLink)}) {
if (secret != null && secret.length() >= MIN_REDACT_LENGTH && redacted.contains(secret)) {
redacted = redacted.replace(secret, "****");
}
}
return redacted;
}
/** 经指定代理请求自家域名:任意 HTTP 响应即转发可用;407 为代理自身认证失败;网络异常不可达。 */
private CheckOutcome probeThroughProxy(String proxyUrl, long startMillis) {
try {
@@ -3,6 +3,7 @@ package com.nanri.aiimage.modules.usersecret.service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.text.SecretMasking;
import com.nanri.aiimage.modules.admin.spi.UserSecretCleanupPort;
import com.nanri.aiimage.common.security.ShopCredentialCryptoService;
import com.nanri.aiimage.config.UserSecretProperties;
@@ -78,7 +79,6 @@ public class UserApiSecretService implements UserSecretCleanupPort {
public static final String ROW_STATUS_UNKNOWN = "unknown";
private static final String STATUS_UNKNOWN = "unknown";
private static final int MASK_MIN_LENGTH = 8;
private static final int MESSAGE_MAX_LENGTH = 500;
/** 「输入值检测」结果暂存键前缀:保存同一个值时沿用该结果,避免用户检完还要再检一次。 */
private static final String VERIFIED_KEY_PREFIX = "aiimage:user-secret-verified";
@@ -711,6 +711,14 @@ public class UserApiSecretService implements UserSecretCleanupPort {
probed++;
sleepQuietly(200L);
}
if (UserApiSecretCheckService.CODE_CHANNEL_BUSY.equals(outcome.code())) {
// 通道被占不是「密钥坏了」:这一轮问不出结论,就既不改状态也不推通知。
// 青果通道数只有 1 条(2026-11-02 控制台核实),而巡检本身就要占一条——
// 若把 channel_busy 落库,用户早上看到的「代理异常」其实是我们自己 04:30
// 那一枪把他的通道占了(现网 uid=1301 的「无法判定」就是这个形状)。
skipped++;
continue;
}
applyCheckOutcome(row.getUserId(), module.get().key(), outcome);
checked++;
if (adminAudience != null) {
@@ -1157,6 +1165,10 @@ public class UserApiSecretService implements UserSecretCleanupPort {
.last("limit 1"));
}
/**
* 后台侧的模块单元(列表行 + 代填回包):值一律脱敏,**不再下发代理明文**(见下方 2026-11-02 收口注释)。
* 客户端侧另走 {@link #toItem}——那里锁定的代理要把完整地址发给配置的主人本人。
*/
private AdminUserSecretModuleVo toModuleVo(UserSecretModule module, UserApiSecretEntity row) {
AdminUserSecretModuleVo vo = new AdminUserSecretModuleVo();
vo.setModuleKey(module.key());
@@ -1174,10 +1186,11 @@ public class UserApiSecretService implements UserSecretCleanupPort {
String plain = decryptQuietly(row.getSecretValue());
vo.setChannel(module.channelOrDefault(row.getChannel(), plain));
vo.setMasked(maskValue(module, plain));
// 后台代理列要求完整可见(含账号密码),密钥列不下发明文
if (module == UserSecretModule.PROXY) {
vo.setFull(plain);
}
// 2026-11-02 收口:后台列表/代填回包一律**不再下发代理明文**(full 留空)。
// 之前这一列把用户填的提取链接原文交给界面,而青果/极客的链接里就带着 key= 与 pwd=
// ——等于把凭据摊在管理员屏幕、浏览器 DOM 与接口响应里(同页 LLM 列一直是脱敏的)。
// 管理员要改代理只能重新粘贴完整链接(后管「改代理」的预填因此变空,属预期的行为收紧);
// 客户端侧的锁定代理仍按 toItem 下发完整地址(那是用户自己的配置、发给本人)。
vo.setExists(hasText(plain));
vo.setLocked(isAdminLocked(row));
vo.setCheckStatus(hasText(row.getCheckStatus()) ? row.getCheckStatus() : STATUS_UNKNOWN);
@@ -1304,47 +1317,11 @@ public class UserApiSecretService implements UserSecretCleanupPort {
}
}
/** 脱敏单出口:一律走 {@link SecretMasking},不在这里长第二份实现(代理列与日志必须同口径)。 */
private String maskValue(UserSecretModule module, String plainValue) {
if (module == UserSecretModule.PROXY) {
return maskProxy(plainValue);
}
return mask(plainValue);
}
private String mask(String value) {
if (!hasText(value)) {
return "";
}
String text = value.trim();
if (text.length() <= MASK_MIN_LENGTH) {
return "****";
}
return text.substring(0, 4) + "****" + text.substring(text.length() - 4);
}
/** 代理掩码:隐去账号密码,保留 scheme://host:port 便于运维核对。 */
private String maskProxy(String value) {
if (!hasText(value)) {
return "";
}
try {
URI uri = URI.create(value.trim());
if (uri.getHost() == null || uri.getHost().isBlank()) {
return mask(value);
}
StringBuilder masked = new StringBuilder();
masked.append(uri.getScheme() == null ? "http" : uri.getScheme()).append("://");
if (uri.getUserInfo() != null && !uri.getUserInfo().isBlank()) {
masked.append("***@");
}
masked.append(uri.getHost());
if (uri.getPort() > 0) {
masked.append(':').append(uri.getPort());
}
return masked.toString();
} catch (Exception ex) {
return mask(value);
}
return module == UserSecretModule.PROXY
? SecretMasking.maskProxy(plainValue)
: SecretMasking.mask(plainValue);
}
private String truncate(String value, int maxLength) {
@@ -7,6 +7,8 @@ import com.nanri.aiimage.modules.notification.service.NotificationService;
import com.nanri.aiimage.modules.usersecret.client.JikipProxyClient;
import com.nanri.aiimage.modules.usersecret.model.entity.UserProxyPlanEntity;
import com.nanri.aiimage.modules.usersecret.model.vo.UserApiSecretBalanceVo;
import com.nanri.aiimage.modules.usersecret.support.ProxyProvider;
import com.nanri.aiimage.modules.usersecret.support.UserSecretModule;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@@ -33,6 +35,7 @@ public class UserProxyBalanceService {
private final Map<Long, CachedProxyBalance> cache = new ConcurrentHashMap<>();
private final UserProxyPlanService userProxyPlanService;
private final UserApiSecretService userApiSecretService;
private final JikipProxyClient jikipProxyClient;
private final NotificationDispatchService notificationDispatchService;
private final UserSecretProperties userSecretProperties;
@@ -45,6 +48,27 @@ public class UserProxyBalanceService {
if (cached != null && now - cached.cachedAt() < CACHE_MILLIS) {
return cached.balance();
}
UserApiSecretBalanceVo vo = loadByProvider(userId);
cache.put(userId, new CachedProxyBalance(vo, now));
return vo;
}
/**
* 按供应商分档取余量:这套余量口径**只属于 jikip**(套餐 IP 余量+账户余额,走 find-balance)。
*
* <p>青果必须原样拒:它的余额接口是控制台档 {@code https://www.qg.net/api/merchant/getBalance},
* 公共参数要 {@code domain}+{@code appid}+{@code time}+{@code sign=md5(appid+domain+time+appkey)},
* 而用户在这里只填 Authkey/Authpwd(铁律 25 口径)——2026-11-02 实测提取域上的
* {@code /balance} 对 key/pwd 直接 {@code API_AUTH_DENY},{@code /traffic}、{@code /package} 是
* {@code NO_ROUTE}。此前青果账号走到这里会落进"否则查平台套餐"那一条,界面显示的是
* **别人家的 jikip 余量**(串档),所以这一档宁可返回"查不了",也不许借用极客的数。</p>
*/
private UserApiSecretBalanceVo loadByProvider(Long userId) {
ProxyProvider provider = ProxyProvider.detectFromUrl(
userApiSecretService.findPlainValue(userId, UserSecretModule.PROXY.key()));
if (provider == ProxyProvider.QINGGUO) {
return qingguoUnsupported();
}
UserProxyPlanEntity plan = userProxyPlanService.getEntity(userId);
UserApiSecretBalanceVo vo;
if (plan != null) {
@@ -59,7 +83,18 @@ public class UserProxyBalanceService {
vo.setScope("platform");
vo.setLow(false);
}
cache.put(userId, new CachedProxyBalance(vo, now));
return vo;
}
/** 青果档的余量答复:不打供应商、不冒充平台套餐,只把"去哪看"说清楚。 */
private UserApiSecretBalanceVo qingguoUnsupported() {
UserApiSecretBalanceVo vo = new UserApiSecretBalanceVo();
vo.setAvailable(false);
vo.setScope("none");
vo.setLow(false);
vo.setMessage("青果不提供余量/余额查询(它的余额接口要控制台 Appid 与 Appkey 签名,"
+ "这里填的 Authkey/Authpwd 只能提取)。用量请看青果控制台,"
+ "通道与密钥是否正常请点「代理设置」里的「检测」。");
return vo;
}
@@ -4,8 +4,9 @@ import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
/**
* 从代理提取链接里取供应商 Key(青果白名单 API 复用它,无需用户再填一次)。
* 链接本身是凭据载体,调用方不得把返回值写进日志。
* 从代理提取链接里取供应商凭据(Key 与密码)——这是全仓唯一读这对值的入口。
* 青果白名单 API 复用 {@link #fromUrl(String)},隧道验连复用 {@link #passwordFromUrl(String)}。
* 链接本身是凭据载体,调用方不得把返回值写进日志/界面文案。
*/
public final class ProxyLinkKey {
@@ -14,7 +15,25 @@ public final class ProxyLinkKey {
/** 取 {@code key} 查询参数(大小写不敏感,兼容 Key);没有返回 null。 */
public static String fromUrl(String url) {
if (url == null || url.isBlank()) {
return param(url, "key");
}
/**
* 取账密档的密码参数:青果的提取链接用 {@code pwd},极客旧链接用 {@code password}。
* 返回值已 URL 解码,调用方不得写进日志。
*/
public static String passwordFromUrl(String url) {
return param(url, "pwd", "password");
}
/**
* 按参数名(大小写不敏感)取链接查询串里的值,取第一个命中的非空项;没有返回 null。
*
* <p>查询串里存的是 URL 编码后的值,这里按 URL 组件解码返回;需要重新拼进 URL 的调用方
* 要自己按组件编码(AGENTS.md 铁律 25:{@code pwd} 里的 {@code @}/{@code :} 会把 host 切歪)。</p>
*/
public static String param(String url, String... names) {
if (url == null || url.isBlank() || names == null || names.length == 0) {
return null;
}
int queryStart = url.indexOf('?');
@@ -32,12 +51,12 @@ public final class ProxyLinkKey {
continue;
}
String name = pair.substring(0, separator);
if (!"key".equalsIgnoreCase(name)) {
if (!matchesAny(name, names)) {
continue;
}
String value = pair.substring(separator + 1);
if (value.isEmpty()) {
return null;
continue;
}
try {
return URLDecoder.decode(value, StandardCharsets.UTF_8);
@@ -47,4 +66,13 @@ public final class ProxyLinkKey {
}
return null;
}
private static boolean matchesAny(String name, String[] names) {
for (String candidate : names) {
if (candidate != null && candidate.equalsIgnoreCase(name.trim())) {
return true;
}
}
return false;
}
}
@@ -0,0 +1,48 @@
package com.nanri.aiimage.common.text;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
/**
* 代理串脱敏的残余外漏面:{@link SecretMasking#maskProxy} 的回落分支**一个凭据字符都不许给**。
*
* <p>钉住的形状:脏值(无 scheme 的 {@code host/get?key=..&pwd=..}、裸凭据串)过去回落到
* {@link SecretMasking#mask},而它保前 4 <b>和后 4</b>——青果的 {@code pwd=} 恰好挂在末尾,
* 于是后管「密钥管理」列与日志里都会留下口令尾 4 位。改成只交「像 host 的那一段」。</p>
*/
class SecretMaskingTest {
@Test
void 正常链接保留scheme与hostPort() {
assertThat(SecretMasking.maskProxy("http://u:pass@proxy.example.com:9000/get?k=1"))
.isEqualTo("http://***@proxy.example.com:9000");
}
@Test
void 无scheme的提取链接不吐出pwd尾字符() {
String masked = SecretMasking.maskProxy(
"overseas.proxy.qg.net/get?key=fakekey&pwd=SuperSecret99");
assertThat(masked).isEqualTo("****overseas.proxy.qg.net");
assertThat(masked).doesNotContain("SuperSecret99").doesNotContain("fakekey")
.doesNotContain("ret99");
}
@Test
void 裸凭据串只给掩码不给字符() {
assertThat(SecretMasking.maskProxy("abcdef1234567890")).isEqualTo("****");
assertThat(SecretMasking.maskProxy("key=fakekey&pwd=fakepwd")).isEqualTo("****");
}
@Test
void 带账号密码的host形状只留host() {
assertThat(SecretMasking.maskProxy("user:pass@10.0.0.1:8080")).isEqualTo("****10.0.0.1:8080");
}
@Test
void 空值仍是空串不打异常() {
assertThat(SecretMasking.maskProxy(null)).isEmpty();
assertThat(SecretMasking.maskProxy(" ")).isEmpty();
}
}
@@ -302,6 +302,144 @@ class UserApiSecretCheckServiceTest {
"{\"code\":\"SUCCESS\",\"data\":[]}", 60)).isNull();
}
// ---------- 2026-11-02:青果检测不再「提取成功=passed」,且一档一码(现网 uid=1301 的「无法判定」就是这么来的)
/**
* 通道占用必须是独立码:混进 {@code provider_error} 后界面只剩「无法判定」,
* 用户既不知道是自己在占用、也不知道等 3 分钟就好。
*/
@Test
void qingguoChannelBusyIsItsOwnCodeWithHumanMessage() {
UserApiSecretCheckService.CheckOutcome outcome = service.classifyProviderRejection(
com.nanri.aiimage.modules.usersecret.support.ProxyProvider.QINGGUO,
"{\"code\":\"NO_AVAILABLE_CHANNEL\",\"message\":\"没有可用的空闲通道\",\"request_id\":\"x\"}", 88);
assertThat(outcome).isNotNull();
assertThat(outcome.code()).isEqualTo(UserApiSecretCheckService.CODE_CHANNEL_BUSY);
assertThat(outcome.code()).isNotEqualTo(UserApiSecretCheckService.CODE_PROVIDER_ERROR);
assertThat(outcome.status()).isEqualTo(UserApiSecretCheckService.STATUS_ERROR);
assertThat(outcome.message())
.isEqualTo(UserApiSecretCheckService.CHANNEL_BUSY_MESSAGE)
.contains("青果通道正被你自己的采集占着")
.contains("3 分钟");
}
/**
* 五档失败各自可辨(欠费/通道占用/限流/密钥失效/鉴权未过)——
* 把任意一档改回 provider_error 或彼此合并,本例即红。
*/
@Test
void qingguoFailureCodesArePairwiseDistinguishable() {
java.util.Map<String, String> byProviderCode = new java.util.LinkedHashMap<>();
byProviderCode.put("BALANCE_INSUFFICIENT", UserApiSecretCheckService.CODE_INSUFFICIENT_BALANCE);
byProviderCode.put("NO_AVAILABLE_CHANNEL", UserApiSecretCheckService.CODE_CHANNEL_BUSY);
byProviderCode.put("REQUEST_LIMIT_EXCEEDED", UserApiSecretCheckService.CODE_RATE_LIMITED);
byProviderCode.put("INVALID_KEY", UserApiSecretCheckService.CODE_INVALID_KEY);
byProviderCode.put("API_AUTH_DENY", UserApiSecretCheckService.CODE_FORBIDDEN);
java.util.Set<String> resolved = new java.util.LinkedHashSet<>();
for (java.util.Map.Entry<String, String> entry : byProviderCode.entrySet()) {
UserApiSecretCheckService.CheckOutcome outcome = service.classifyProviderRejection(
com.nanri.aiimage.modules.usersecret.support.ProxyProvider.QINGGUO,
"{\"code\":\"" + entry.getKey() + "\",\"message\":\"m\",\"request_id\":\"x\"}", 50);
assertThat(outcome).as(entry.getKey()).isNotNull();
assertThat(outcome.code()).isEqualTo(entry.getValue());
// 说人话:文案不得只剩「无法判定」这种界面兜底词,也不得是英文异常串
assertThat(outcome.message()).doesNotContain("无法判定");
resolved.add(outcome.code());
}
assertThat(resolved).hasSize(5).doesNotContain(UserApiSecretCheckService.CODE_PROVIDER_ERROR);
}
/** 限流与欠费不是「密钥坏了」:前者 error(放行但警示),后者 failed(拦下)。 */
@Test
void qingguoRateLimitedStaysJudgementAndBalanceStaysBlocking() {
UserApiSecretCheckService.CheckOutcome limited = service.classifyProviderRejection(
com.nanri.aiimage.modules.usersecret.support.ProxyProvider.QINGGUO,
"{\"code\":\"REQUEST_LIMIT_EXCEEDED\",\"message\":\"请求过于频繁\"}", 40);
assertThat(limited.status()).isEqualTo(UserApiSecretCheckService.STATUS_ERROR);
assertThat(limited.message()).contains("限流").contains("1 分钟");
UserApiSecretCheckService.CheckOutcome broke = service.classifyProviderRejection(
com.nanri.aiimage.modules.usersecret.support.ProxyProvider.QINGGUO,
"{\"code\":\"BALANCE_INSUFFICIENT\",\"message\":\"余额不足\"}", 40);
assertThat(broke.status()).isEqualTo(UserApiSecretCheckService.STATUS_FAILED);
}
/** 供应商文案整条回显请求链接时,出口前必须抹掉 key/pwd 原文(假凭据,不涉真值)。 */
@Test
void providerRejectionMessageNeverEchoesLinkCredentials() {
String extractLink = "https://overseas.proxy.qg.net/get?key=fakekey&pwd=fakepwd";
UserApiSecretCheckService.CheckOutcome outcome = service.classifyProviderRejection(
com.nanri.aiimage.modules.usersecret.support.ProxyProvider.QINGGUO,
"{\"code\":\"INVALID_KEY\",\"message\":\"Key 无效: https://overseas.proxy.qg.net/get?key=fakekey&pwd=fakepwd\"}",
70, extractLink);
assertThat(outcome).isNotNull();
assertThat(outcome.code()).isEqualTo(UserApiSecretCheckService.CODE_INVALID_KEY);
assertThat(outcome.message()).doesNotContain("fakekey").doesNotContain("fakepwd").contains("****");
// 参数名形状之外的裸值也要盖掉(供应商只回显值、不带 key= 前缀的形态)
assertThat(UserApiSecretCheckService.redactCredentials("裸值 fakekey 与 fakepwd 都要抹", extractLink))
.doesNotContain("fakekey").doesNotContain("fakepwd");
}
/** 极客链接不带凭据型参数名时,通用抹除不能把正常参数吃成 ****。 */
@Test
void redactKeepsNonCredentialQueryParamsIntact() {
assertThat(UserApiSecretCheckService.redactCredentials(
"https://overseas.proxy.qg.net/get?num=1&format=json", null))
.contains("num=1").contains("format=json");
}
// ---------- 青果隧道组链:账密就在链接里,所以必须真经隧道打一次(旧短路已废)
/** 隧道端点 + 链接里的 key/pwd = 可直接验连的代理地址;日志侧只允许出现掩码形态。 */
@Test
void qingguoTunnelProxyUrlSplicesLinkCredentialsIntoEndpoint() {
String tunnelUrl = UserApiSecretCheckService.qingguoTunnelProxyUrl(
"https://overseas.proxy.qg.net/get?key=fakekey&pwd=fakepwd&format=json",
"http://tun1.qg.net:16359");
assertThat(tunnelUrl).isEqualTo("http://fakekey:fakepwd@tun1.qg.net:16359");
// 组出来的地址含凭据:任何日志/文案只能用它掩码后的形态
assertThat(com.nanri.aiimage.common.text.SecretMasking.maskProxy(tunnelUrl))
.isEqualTo("http://***@tun1.qg.net:16359")
.doesNotContain("fakekey").doesNotContain("fakepwd");
}
/** 补不出安全地址就返回 null:缺 pwd、账密含会切歪 host 的分隔符、端点没端口,一律不猜。 */
@Test
void qingguoTunnelProxyUrlRefusesMissingOrUnsafeCredentials() {
// 白名单档(只有 key、没有 pwd):青果只做账密档,组不出鉴权地址
assertThat(UserApiSecretCheckService.qingguoTunnelProxyUrl(
"https://overseas.proxy.qg.net/get?key=fakekey", "http://tun1.qg.net:16359")).isNull();
// pwd 里的 @ 会把 userinfo 吞进 host(AGENTS.md 铁律 25 实录)
assertThat(UserApiSecretCheckService.qingguoTunnelProxyUrl(
"https://overseas.proxy.qg.net/get?key=fakekey&pwd=a%40b", "http://tun1.qg.net:16359")).isNull();
assertThat(UserApiSecretCheckService.qingguoTunnelProxyUrl(
"https://overseas.proxy.qg.net/get?key=fake%3Akey&pwd=fakepwd", "http://tun1.qg.net:16359")).isNull();
// 端点缺端口:不是可连的代理地址
assertThat(UserApiSecretCheckService.qingguoTunnelProxyUrl(
"https://overseas.proxy.qg.net/get?key=fakekey&pwd=fakepwd", "http://tun1.qg.net")).isNull();
}
/**
* 组不出链时的结论必须如实是「没验成」(error/tunnel_unverified),
* **不得**退回旧的 passed/ok 短路——那正是本次要消灭的假通过。
*/
@Test
void qingguoTunnelWithoutUsableCredentialsReportsUnverifiedNotPassed() {
UserApiSecretCheckService.CheckOutcome outcome = service.probeQingguoTunnel(
"https://overseas.proxy.qg.net/get?key=fakekey", "http://tun1.qg.net:16359",
System.currentTimeMillis());
assertThat(outcome.status()).isEqualTo(UserApiSecretCheckService.STATUS_ERROR);
assertThat(outcome.code()).isEqualTo(UserApiSecretCheckService.CODE_TUNNEL_UNVERIFIED);
assertThat(outcome.status()).isNotEqualTo(UserApiSecretCheckService.STATUS_PASSED);
assertThat(outcome.message()).contains("无法确认").doesNotContain("fakekey");
assertThat(outcome.viaProxy()).isFalse();
}
@Test
void jikipBalanceShortageStillClassified() {
UserApiSecretCheckService.CheckOutcome outcome = service.classifyProviderRejection(
@@ -550,7 +550,70 @@ class UserApiSecretServiceTest {
assertThat(rowVo.getSimilarAsin().getFull()).isNull();
assertThat(rowVo.getProxy().getExists()).isTrue();
assertThat(rowVo.getProxy().getMasked()).isEqualTo("http://***@1.2.3.4:8080");
assertThat(rowVo.getProxy().getFull()).isEqualTo("http://user:pass@1.2.3.4:8080");
// 2026-11-02 收口:后台读路不再下发代理明文(链接里就带着账密)
assertThat(rowVo.getProxy().getFull()).isNull();
}
/**
* 后管列表的代理列:响应体里不得出现提取链接的 key/pwd 原文(同页 LLM 列一直是脱敏的,
* 代理列此前把 {@code https://overseas.proxy.qg.net/get?key=…&pwd=…} 整串交给界面)。
* 断言打在真正发出去的 JSON 上,不是只打 VO 字段——界面拿到的是序列化后的字节。
*/
@Test
void adminPageProxyColumnNeverShipsExtractLinkCredentials() throws Exception {
UserApiSecretService service = newService();
when(mapper.selectList(any())).thenReturn(List.of(
row(1L, "proxy", "enc:https://overseas.proxy.qg.net/get?key=fakekey&pwd=fakepwd", "error")));
AdminUserEntity user = new AdminUserEntity();
user.setId(1L);
user.setUsername("张三");
when(adminUserMapper.selectById(1L)).thenReturn(user);
AdminUserEntity operator = new AdminUserEntity();
operator.setId(88L);
when(adminAuthSupport.currentRole(operator)).thenReturn("super_admin");
AdminUserSecretModuleVo proxy = service
.adminPage(operator, new AdminUserSecretQuery(), ReadScope.unfiltered())
.getItems().get(0).getProxy();
assertThat(proxy.getExists()).isTrue();
assertThat(proxy.getMasked()).isEqualTo("https://overseas.proxy.qg.net");
assertThat(proxy.getFull()).isNull();
// 断言打在序列化后的响应体上;用 Boot 同款 mapper(new ObjectMapper() 不挂 jsr310,日期会直接炸)
String body = com.fasterxml.jackson.databind.json.JsonMapper.builder()
.addModule(new com.fasterxml.jackson.datatype.jsr310.JavaTimeModule())
.build()
.writeValueAsString(proxy);
assertThat(body).doesNotContain("fakekey").doesNotContain("fakepwd");
}
/**
* 代理行的「货源」只可能是供应商:后端把 LLM 渠道词表贴到 proxy 行上(现网看到「龙抬头」)
* 从来不是这里的产出——存量脏值(channel 列写着 longtaitou)也会被 {@code channelOrDefault}
* 按链接域名归一到 qingguo/jikip。界面那一列拿到什么,由本例钉住。
*/
@Test
void adminPageProxyChannelIsProviderNeverLlmChannel() {
UserApiSecretService service = newService();
UserApiSecretEntity dirty = row(1L, "proxy",
"enc:https://overseas.proxy.qg.net/get?key=fakekey&pwd=fakepwd", "error");
dirty.setChannel("longtaitou");
when(mapper.selectList(any())).thenReturn(List.of(dirty));
AdminUserEntity user = new AdminUserEntity();
user.setId(1L);
user.setUsername("张三");
when(adminUserMapper.selectById(1L)).thenReturn(user);
AdminUserEntity operator = new AdminUserEntity();
operator.setId(88L);
when(adminAuthSupport.currentRole(operator)).thenReturn("super_admin");
AdminUserSecretModuleVo proxy = service
.adminPage(operator, new AdminUserSecretQuery(), ReadScope.unfiltered())
.getItems().get(0).getProxy();
assertThat(proxy.getChannel()).isEqualTo("qingguo");
assertThat(proxy.getChannel()).isNotIn("longtaitou", "t8star");
}
@Test
@@ -914,7 +977,7 @@ class UserApiSecretServiceTest {
assertThat(existing.getSecretValue()).isEqualTo("enc:http://1.2.3.4:8080");
}
/** 后台代填:写入 source=admin(锁定)并把完整地址回给后台列表。 */
/** 后台代填:写入 source=admin(锁定),回包只给脱敏值——代填的链接里带着账密,不再原文回显。 */
@Test
void adminSaveModuleLocksProxyAndReturnsLockedVo() {
UserApiSecretService service = newService();
@@ -940,7 +1003,7 @@ class UserApiSecretServiceTest {
assertThat(stored.getSource()).isEqualTo(UserApiSecretService.SOURCE_ADMIN);
assertThat(vo.getExists()).isTrue();
assertThat(vo.getLocked()).isTrue();
assertThat(vo.getFull()).isEqualTo("https://api.jikip.com/ip-get?num=1&key=abc");
assertThat(vo.getFull()).isNull();
assertThat(vo.getMasked()).isEqualTo("https://api.jikip.com");
}
@@ -1119,6 +1182,35 @@ class UserApiSecretServiceTest {
anyString(), anyString(), anyString(), any());
}
/**
* 巡检遇到「青果通道被占」必须**什么都不改**:既不落 error 也不推通知。
*
* <p>通道被占不是密钥坏了,而是"此刻问不出结论"——巡检自己那一发真提取就要占掉唯一一条通道
* (2026-11-02 青果控制台核实:通道数 1 个、存活周期 3 分钟)。把 channel_busy 落库等于
* 用户早上看到的「代理异常」是我们自己造成的(现网 uid=1301 那条「无法判定」就是这形状)。</p>
*/
@Test
void schedulerWritesNothingWhenQingguoChannelIsBusy() {
UserApiSecretService service = newService();
String cipher = "enc:https://overseas.proxy.qg.net/get?key=fakekey&pwd=fakepwd";
stubInspectionStore(Map.of(11L, storedRow(11L, "proxy", cipher)));
when(checkService.probe(any(), anyString(), any())).thenReturn(
outcome("error", UserApiSecretCheckService.CODE_CHANNEL_BUSY,
"青果通道正被你自己的采集占着,等约 3 分钟释放后再点检测", 70));
when(mapper.selectList(any())).thenReturn(List.of(
inspectionRow(1L, 11L, "proxy", cipher)), List.of());
stubAdminNotificationPath();
var summary = service.checkAllForScheduler(500, 20);
assertThat(summary.checked()).isEqualTo(0);
assertThat(summary.skipped()).isEqualTo(1);
assertThat(summary.probed()).isEqualTo(1);
assertThat(inspectionWrites).isEmpty();
verify(notificationDispatchService, never()).pushToUser(any(), anyString(), anyString(),
anyString(), anyString(), anyString());
}
/** 只有一个账号在用的密钥保持原口径:仍然点名「用户密钥异常:{用户名}」,去重键与改动前一致。 */
@Test
void schedulerKeepsNamedAdminAlertWhenSecretIsUsedByOneAccount() {
@@ -1252,8 +1344,8 @@ class UserApiSecretServiceTest {
}
private UserProxyBalanceService newBalanceService() {
return new UserProxyBalanceService(userProxyPlanService, jikipProxyClient,
notificationDispatchService, userSecretProperties);
return new UserProxyBalanceService(userProxyPlanService, mock(UserApiSecretService.class),
jikipProxyClient, notificationDispatchService, userSecretProperties);
}
private UserProxyPlanEntity proxyPlan(long userId, String planId, String jikipUserId) {
@@ -0,0 +1,143 @@
package com.nanri.aiimage.modules.usersecret.service;
import com.nanri.aiimage.config.UserSecretProperties;
import com.nanri.aiimage.modules.notification.service.NotificationDispatchService;
import com.nanri.aiimage.modules.usersecret.client.JikipProxyClient;
import com.nanri.aiimage.modules.usersecret.model.entity.UserProxyPlanEntity;
import com.nanri.aiimage.modules.usersecret.model.vo.UserApiSecretBalanceVo;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatchers;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* 用户级代理余量按供应商分档:jikip 的数只能给 jikip 账号看。
*
* <p>钉住的现网缺陷:青果账号走到这套余量口径里会落进「否则查平台套餐」那一条,
* 设置弹窗显示的是别人家的极客余量(串档),用户据此判断"我还有量",实际青果那边
* 通道早被占满。青果不提供可鉴权的余量/余额查询(余额接口是控制台 appid/appkey 签名档),
* 所以这一档必须返回"查不了"、并且一次都不许打极客接口。</p>
*/
class UserProxyBalanceServiceTest {
private static final Long USER_ID = 7L;
private static final String QINGGUO_LINK = "https://overseas.proxy.qg.net/get?key=fakekey&pwd=fakepwd";
private static final String QINGGUO_SHARE_LINK = "https://share.proxy.qg.net/get?key=fakekey";
private static final String JIKIP_LINK = "https://api.jikip.com/ip-get?key=fakekey";
private final UserProxyPlanService userProxyPlanService = mock(UserProxyPlanService.class);
private final UserApiSecretService userApiSecretService = mock(UserApiSecretService.class);
private final JikipProxyClient jikipProxyClient = mock(JikipProxyClient.class);
private final NotificationDispatchService notificationDispatchService =
mock(NotificationDispatchService.class);
private final UserSecretProperties userSecretProperties = mock(UserSecretProperties.class);
private final UserProxyBalanceService service = new UserProxyBalanceService(
userProxyPlanService, userApiSecretService, jikipProxyClient,
notificationDispatchService, userSecretProperties);
private void storedProxyLink(String link) {
when(userApiSecretService.findPlainValue(anyLong(), anyString())).thenReturn(link);
}
private static UserApiSecretBalanceVo jikipReply(String surplus, String balance) {
UserApiSecretBalanceVo vo = new UserApiSecretBalanceVo();
vo.setAvailable(true);
vo.setSurplus(surplus);
vo.setBalance(balance);
return vo;
}
@Test
void 青果账号不打极客接口也不借用平台套餐() {
storedProxyLink(QINGGUO_LINK);
UserApiSecretBalanceVo vo = service.balance(USER_ID);
assertThat(vo.getAvailable()).isFalse();
assertThat(vo.getScope()).isEqualTo("none");
assertThat(vo.getLow()).isFalse();
assertThat(vo.getMessage()).contains("青果不提供").contains("检测");
verifyNoInteractions(jikipProxyClient);
verifyNoInteractions(userProxyPlanService);
}
@Test
void 青果分享域名的存量链接同样认得不会被当成极客() {
storedProxyLink(QINGGUO_SHARE_LINK);
assertThat(service.balance(USER_ID).getScope()).isEqualTo("none");
verifyNoInteractions(jikipProxyClient);
}
@Test
void 极客账号填了套餐就查自己那份() {
storedProxyLink(JIKIP_LINK);
UserProxyPlanEntity plan = new UserProxyPlanEntity();
plan.setUserId(USER_ID);
plan.setPlanId("plan-1");
plan.setJikipUserId("jiku-1");
when(userProxyPlanService.getEntity(USER_ID)).thenReturn(plan);
when(jikipProxyClient.fetchBalance(any(JikipProxyClient.PlanRef.class)))
.thenReturn(jikipReply("120", "30"));
UserApiSecretBalanceVo vo = service.balance(USER_ID);
assertThat(vo.getScope()).isEqualTo("user");
assertThat(vo.getSurplus()).isEqualTo("120");
verify(jikipProxyClient).fetchBalance(new JikipProxyClient.PlanRef("plan-1", "jiku-1"));
verify(jikipProxyClient, never()).fetchBalance();
}
@Test
void 极客账号没填套餐才落平台套餐() {
storedProxyLink(JIKIP_LINK);
when(userProxyPlanService.getEntity(USER_ID)).thenReturn(null);
when(jikipProxyClient.fetchBalance()).thenReturn(jikipReply("900", "900"));
UserApiSecretBalanceVo vo = service.balance(USER_ID);
assertThat(vo.getScope()).isEqualTo("platform");
assertThat(vo.getLow()).isFalse();
}
@Test
void 同一用户五分钟内复用缓存不再打供应商() {
storedProxyLink(JIKIP_LINK);
when(userProxyPlanService.getEntity(USER_ID)).thenReturn(null);
when(jikipProxyClient.fetchBalance()).thenReturn(jikipReply("900", "900"));
service.balance(USER_ID);
service.balance(USER_ID);
verify(jikipProxyClient, times(1)).fetchBalance();
}
@Test
void 改过代理配置后缓存作废下一次按新供应商走() {
storedProxyLink(JIKIP_LINK);
when(userProxyPlanService.getEntity(USER_ID)).thenReturn(null);
when(jikipProxyClient.fetchBalance()).thenReturn(jikipReply("900", "900"));
service.balance(USER_ID);
service.invalidate(USER_ID);
storedProxyLinkAfter(QINGGUO_LINK);
UserApiSecretBalanceVo vo = service.balance(USER_ID);
assertThat(vo.getScope()).isEqualTo("none");
}
private void storedProxyLinkAfter(String link) {
when(userApiSecretService.findPlainValue(ArgumentMatchers.eq(USER_ID), anyString()))
.thenReturn(link);
}
}
@@ -26,4 +26,21 @@ class ProxyLinkKeyTest {
assertThat(ProxyLinkKey.fromUrl("")).isNull();
assertThat(ProxyLinkKey.fromUrl(null)).isNull();
}
/**
* 隧道验连要用链接里的密码:青果的参数名是 {@code pwd},极客旧链接是 {@code password},
* 两者都要认(AGENTS.md 铁律 25:青果只做账密档,pwd 必填)。
*/
@Test
void passwordReadsPwdThenLegacyPasswordParam() {
assertThat(ProxyLinkKey.passwordFromUrl(
"https://overseas.proxy.qg.net/get?key=fakekey&pwd=fakepwd")).isEqualTo("fakepwd");
assertThat(ProxyLinkKey.passwordFromUrl(
"https://api.jikip.com/ip-get?password=fakepwd")).isEqualTo("fakepwd");
assertThat(ProxyLinkKey.passwordFromUrl(
"https://overseas.proxy.qg.net/get?key=fakekey")).isNull();
// 大小写不敏感 + 值按 URL 组件解码(含 %40 的 pwd 解码后才能判定它不能直接拼进 userinfo)
assertThat(ProxyLinkKey.passwordFromUrl("https://overseas.proxy.qg.net/get?PWD=fake%40pwd"))
.isEqualTo("fake@pwd");
}
}