feat(user-secret): 代理白名单一键添加(极客/青果)并前置默认渠道

- 客户端设置面板新增「白名单」区块:自动获取出口 IP、可手改;加入前先同步未上报的代理配置,避免拿服务端旧 Key 代加
- 后端新增 POST /api/user-secrets/proxy-whitelist:先查后加;极客用套餐 ID+套餐 key,青果用已保存提取链接里的 key,重复添加不报错
- 极客套餐 key 加密存 biz_user_proxy_plan.jikip_plan_key(V181),回读只给掩码;换套餐 ID 时必须重填
- 白名单接口地址走配置(AIIMAGE_USER_SECRET_JIKIP/QINGGUO_WHITE_LIST_*),日志不落 key 与完整 URL
- 贞贞/极客等默认选项前置;catch 棘轮 7 处逐条记名并入基线(含 79b04afd 的 AdminApiGuardFilter 一枚)
This commit is contained in:
2026-10-30 11:05:55 +08:00
parent 79b04afdd9
commit 43ae12f722
30 changed files with 1206 additions and 40 deletions
@@ -59,7 +59,9 @@ class CatchSilenceRatchetTest {
// 10-28 Phase 3 抬 582 -> 585(心跳降级一枚 + 优雅停机两枚中断恢复,逐处记名见 STRICT_TOTAL 上方注释)。
// 10-29 Phase 4D 抬 585 -> 591(AC-17 分片通道六枚 LOG_ONLY:清理/收尾失败不得盖掉主错误,
// 逐处记名见 STRICT_TOTAL 上方注释;EMPTY 一格没涨)。
static final int GIVEN_NOT_RETHROW = 591;
// 10-30 用户端代理白名单(极客/青果)抬 591 -> 598(7 处逐一记名见 STRICT_TOTAL 上方注释;
// 实测量到 599,多出的 1 格来自已提交的 79b04afd(AdminApiGuardFilter 编码绕过 catch),见同处说明)。
static final int GIVEN_NOT_RETHROW = 599;
static final int GIVEN_LOG_ONLY = 249;
static final int GIVEN_EMPTY = 56;
@@ -234,8 +236,32 @@ class CatchSilenceRatchetTest {
* 空体已按 10-26 那批的先例改成 WARN 带 path——空体是三类高危出口里最贵的一种,
* 这里宁可让 {@code STRICT_LOG_ONLY} 涨六格,也不给"删除失败连日志都不留"开门。</li>
* </ul>
*
* <p>10-30 用户端代理白名单(极客/青果白名单 API)抬 total 1045 -&gt; 1052,7 枚逐处记名。
* 全部是 NOT_RETHROW(log+return 或纯 return),RETHROW/LOG_ONLY/EMPTY 三格一枚未涨:
* <ul>
* <li>{@code JikipProxyClient.checkAndAddWhitelist} 添加一枚:网络/解析/上游非 0 code 统一折成
* {@code ProxyWhitelistOutcome(false, ...)} 交控制器转可读文案;异常只记类型——RestClient
* 异常消息可能带完整 URL(含套餐 key),禁止回传或落日志。</li>
* <li>{@code JikipProxyClient.checkWhitelist} 查询一枚:查不到(含网络失败)返回 null,
* 由调用方继续尝试添加——查询只是省一次写调用,不能变成添加的前置故障点。</li>
* <li>{@code QingguoProxyClient.checkAndAddWhitelist} 添加一枚与
* {@code QingguoProxyClient.queryContains} 查询一枚:与极客两枚同形状(同一套"先查后加"),
* 异常只记类型——查询串里带用户的青果 Key。</li>
* <li>{@code UserProxyPlanService.decryptQuietly} 一枚:已存套餐 key 解密失败按「未配置」处理
* (返回空串),只记异常类型,绝不把密文/明文写进日志;抛出去只会让整个代理配置页 500。</li>
* <li>{@code PublicIpValidator.normalize} 一枚(仅 return null):正则已拦字面量与段数,
* {@code InetAddress.getByName} 的 {@code UnknownHostException} 表示输入非法,
* 返回 null 让控制器给 400,不是吞供应商/DB 异常。</li>
* <li>{@code ProxyLinkKey.fromUrl} 一枚(仅 return null):提取链接里 {@code key} 的百分号编码
* 坏了就当作没带 key(后续按「未配置」提示重填),不把坏输入升级成整页失败。</li>
* </ul>
* 同批实测 total 1052、rethrow 398、notRethrow 598、logOnly 188(未动)、empty 56(未动)。
* ⚠ 本批提交时整树已是 1053/notRethrow 599:多出的 1 格不属本批——已提交的 79b04afd 在
* {@code AdminApiGuardFilter.decodePath} 增加了「畸形百分号编码保持原样、交给容器 400」的 catch
* (NOT_RETHROW 形状),该笔未抬本基线。这里按整树实测一并包住并在这一行记名。
*/
static final int STRICT_TOTAL = 1045;
static final int STRICT_TOTAL = 1053;
/**
* 重抛型 catch 的**下限**(不是上限):本轮把两处吞异常改成重抛之后实测 388。
* 这一格只能涨不能跌——它是"异常会往外走"的总量,把它钉成"只许减"就等于拦着别人修吞异常。
@@ -350,8 +376,15 @@ class CatchSilenceRatchetTest {
* {@code WorkbenchClientPackageService.abortChunkedPackage} 的「会话已不存在」INFO 与
* 「未登记对象清理失败」WARN 两枚。六枚的误差方向都是「清理/收尾失败不得盖掉主错误」,
* 主错误由外层重抛;本批 EMPTY 一格没涨(原先三枚空体已按 10-26 先例改成带 path 的 WARN)。
* 10-30 再抬 591 -&gt; 598(用户端代理白名单 7 枚,逐处记名见 STRICT_TOTAL 上方注释):
* 极客/青果各两枚(添加失败折成 {@code ProxyWhitelistOutcome}、查询失败返回 null 继续添加),
* 套餐 key 解密失败按「未配置」处理一枚,IP 校验与提取链接 key 解码各一枚纯 return null。
* 七枚全在用户端配置页的「手动加白名单」链路上,方向都是「选项未配置/输入非法就给可读提示」,
* 没有把服务端主链路异常静默吞掉的出口。
* 复测整树 599:多出的 1 格来自已提交的 79b04afd {@code AdminApiGuardFilter.decodePath}
* (畸形编码保持原样交给容器 400),非本批新增,说明见 STRICT_TOTAL 上方。
*/
static final int STRICT_NOT_RETHROW = 591;
static final int STRICT_NOT_RETHROW = 599;
/**
* 10-17 抬 172 -> 173,出处就是上面点名过的 {@code TaskHeartbeatLivenessService.stamp()}:
* 块体只有「取到 key 名 + log.warn」一句,写心跳证据失败时既不重试也不抛出——
@@ -1,5 +1,6 @@
package com.nanri.aiimage.modules.usersecret.service;
import com.nanri.aiimage.common.security.ShopCredentialCryptoService;
import com.nanri.aiimage.modules.usersecret.mapper.UserProxyPlanMapper;
import com.nanri.aiimage.modules.usersecret.model.entity.UserProxyPlanEntity;
import com.nanri.aiimage.modules.usersecret.model.vo.UserProxyPlanVo;
@@ -7,15 +8,22 @@ import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/** 用户级 jikip 套餐配置:一个用户一行,保存即 upsert,清除即删行。 */
/** 用户级 jikip 套餐配置:一个用户一行,保存即 upsert,套餐 key 加密且只回显掩码。 */
class UserProxyPlanServiceTest {
private final UserProxyPlanMapper mapper = mock(UserProxyPlanMapper.class);
private final UserProxyPlanService service = new UserProxyPlanService(mapper);
private final ShopCredentialCryptoService cryptoService = mock(ShopCredentialCryptoService.class);
private final UserProxyPlanService service = new UserProxyPlanService(mapper, cryptoService);
UserProxyPlanServiceTest() {
when(cryptoService.encrypt(anyString())).thenAnswer(invocation -> "enc:" + invocation.getArgument(0));
when(cryptoService.decrypt("enc:plan-key-123456")).thenReturn("plan-key-123456");
}
@Test
void getReturnsUnconfiguredWhenNoRow() {
@@ -26,13 +34,15 @@ class UserProxyPlanServiceTest {
assertThat(vo.getConfigured()).isFalse();
assertThat(vo.getPlanId()).isNull();
assertThat(vo.getJikipUserId()).isNull();
assertThat(vo.getJikipPlanKeyConfigured()).isFalse();
assertThat(vo.getJikipPlanKeyMasked()).isNull();
}
@Test
void saveInsertsTrimmedValuesForFirstTime() {
void saveInsertsTrimmedValuesAndEncryptsPlanKey() {
when(mapper.selectById(7L)).thenReturn(null);
service.save(7L, " 20261010593613392231 ", " 626710989815 ");
service.save(7L, " 20261010593613392231 ", " 626710989815 ", " plan-key-123456 ");
ArgumentCaptor<UserProxyPlanEntity> captor = ArgumentCaptor.forClass(UserProxyPlanEntity.class);
verify(mapper).insert(captor.capture());
@@ -40,25 +50,60 @@ class UserProxyPlanServiceTest {
assertThat(inserted.getUserId()).isEqualTo(7L);
assertThat(inserted.getPlanId()).isEqualTo("20261010593613392231");
assertThat(inserted.getJikipUserId()).isEqualTo("626710989815");
assertThat(inserted.getUserId()).isNotNull();
assertThat(inserted.getJikipPlanKey()).isEqualTo("enc:plan-key-123456");
}
@Test
void saveUpdatesExistingRowInPlace() {
UserProxyPlanEntity existing = new UserProxyPlanEntity();
existing.setUserId(7L);
existing.setPlanId("old-plan");
existing.setJikipUserId("old-user");
void saveKeepsExistingKeyWhenBlankAndPlanUnchanged() {
UserProxyPlanEntity existing = existingRow("plan-1", "enc:plan-key-123456");
when(mapper.selectById(7L)).thenReturn(existing);
service.save(7L, "new-plan", "new-user");
service.save(7L, "plan-1", "user-1", " ");
ArgumentCaptor<UserProxyPlanEntity> captor = ArgumentCaptor.forClass(UserProxyPlanEntity.class);
verify(mapper).updateById(captor.capture());
UserProxyPlanEntity updated = captor.getValue();
assertThat(updated.getUserId()).isEqualTo(7L);
assertThat(updated.getPlanId()).isEqualTo("new-plan");
assertThat(updated.getJikipUserId()).isEqualTo("new-user");
assertThat(captor.getValue().getJikipPlanKey()).isEqualTo("enc:plan-key-123456");
}
@Test
void saveClearsKeyWhenPlanChangedAndNoNewKeyProvided() {
UserProxyPlanEntity existing = existingRow("old-plan", "enc:plan-key-123456");
when(mapper.selectById(7L)).thenReturn(existing);
service.save(7L, "new-plan", "user-1", "");
ArgumentCaptor<UserProxyPlanEntity> captor = ArgumentCaptor.forClass(UserProxyPlanEntity.class);
verify(mapper).updateById(captor.capture());
assertThat(captor.getValue().getPlanId()).isEqualTo("new-plan");
assertThat(captor.getValue().getJikipPlanKey()).isNull();
}
@Test
void getMasksStoredPlanKey() {
when(mapper.selectById(7L)).thenReturn(existingRow("plan-1", "enc:plan-key-123456"));
UserProxyPlanVo vo = service.get(7L);
assertThat(vo.getJikipPlanKeyConfigured()).isTrue();
assertThat(vo.getJikipPlanKeyMasked()).isEqualTo("plan****3456");
}
@Test
void getWhitelistCredentialReturnsDecryptedKey() {
when(mapper.selectById(7L)).thenReturn(existingRow("plan-1", "enc:plan-key-123456"));
UserProxyPlanService.WhitelistCredential credential = service.getWhitelistCredential(7L);
assertThat(credential).isNotNull();
assertThat(credential.planId()).isEqualTo("plan-1");
assertThat(credential.planKey()).isEqualTo("plan-key-123456");
}
@Test
void getWhitelistCredentialNullWhenKeyMissing() {
when(mapper.selectById(7L)).thenReturn(existingRow("plan-1", null));
assertThat(service.getWhitelistCredential(7L)).isNull();
}
@Test
@@ -67,4 +112,13 @@ class UserProxyPlanServiceTest {
verify(mapper).deleteById(7L);
}
private static UserProxyPlanEntity existingRow(String planId, String key) {
UserProxyPlanEntity existing = new UserProxyPlanEntity();
existing.setUserId(7L);
existing.setPlanId(planId);
existing.setJikipUserId("user-1");
existing.setJikipPlanKey(key);
return existing;
}
}
@@ -0,0 +1,111 @@
package com.nanri.aiimage.modules.usersecret.service;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.modules.usersecret.client.JikipProxyClient;
import com.nanri.aiimage.modules.usersecret.client.QingguoProxyClient;
import com.nanri.aiimage.modules.usersecret.model.vo.UserProxyWhitelistVo;
import com.nanri.aiimage.modules.usersecret.support.ProxyWhitelistOutcome;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
class UserProxyWhitelistServiceTest {
private final UserApiSecretService userApiSecretService = mock(UserApiSecretService.class);
private final UserProxyPlanService userProxyPlanService = mock(UserProxyPlanService.class);
private final JikipProxyClient jikipProxyClient = mock(JikipProxyClient.class);
private final QingguoProxyClient qingguoProxyClient = mock(QingguoProxyClient.class);
private final UserProxyWhitelistService service = new UserProxyWhitelistService(
userApiSecretService, userProxyPlanService, jikipProxyClient, qingguoProxyClient);
@Test
void rejectsNonPublicIpBeforeTouchingConfig() {
assertThatThrownBy(() -> service.add(7L, "192.168.1.10"))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("公网 IP");
verifyNoInteractions(userApiSecretService, userProxyPlanService, jikipProxyClient, qingguoProxyClient);
}
@Test
void rejectsWhenProxyLinkNotSaved() {
when(userApiSecretService.findPlainValue(7L, "proxy")).thenReturn("");
assertThatThrownBy(() -> service.add(7L, "36.251.68.43"))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("保存代理提取链接");
}
@Test
void qingguoUsesKeyFromSavedProxyLink() {
when(userApiSecretService.findPlainValue(7L, "proxy"))
.thenReturn("https://overseas.proxy.qg.net/get?key=abc123&format=json");
when(userApiSecretService.findChannel(7L, "proxy")).thenReturn("qingguo");
when(qingguoProxyClient.checkAndAddWhitelist("abc123", "36.251.68.43"))
.thenReturn(new ProxyWhitelistOutcome(true, true, "已加入白名单,立即生效"));
UserProxyWhitelistVo vo = service.add(7L, " 36.251.68.43 ");
assertThat(vo.getIp()).isEqualTo("36.251.68.43");
assertThat(vo.getProvider()).isEqualTo("qingguo");
assertThat(vo.getAdded()).isTrue();
verify(qingguoProxyClient).checkAndAddWhitelist("abc123", "36.251.68.43");
}
@Test
void qingguoRejectsLinkWithoutKey() {
when(userApiSecretService.findPlainValue(7L, "proxy"))
.thenReturn("http://user:pass@host:8080");
when(userApiSecretService.findChannel(7L, "proxy")).thenReturn("qingguo");
assertThatThrownBy(() -> service.add(7L, "36.251.68.43"))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("缺少 key");
}
@Test
void jikipUsesStoredPlanCredential() {
when(userApiSecretService.findPlainValue(7L, "proxy"))
.thenReturn("https://api.jikip.com/ip-get?key=extract-key&num=1");
when(userApiSecretService.findChannel(7L, "proxy")).thenReturn("jikip");
when(userProxyPlanService.getWhitelistCredential(7L))
.thenReturn(new UserProxyPlanService.WhitelistCredential("plan-1", "plan-key"));
when(jikipProxyClient.checkAndAddWhitelist("plan-1", "plan-key", "36.251.68.43"))
.thenReturn(new ProxyWhitelistOutcome(true, false, "该 IP 已在白名单中"));
UserProxyWhitelistVo vo = service.add(7L, "36.251.68.43");
assertThat(vo.getProvider()).isEqualTo("jikip");
assertThat(vo.getAdded()).isFalse();
verify(jikipProxyClient).checkAndAddWhitelist("plan-1", "plan-key", "36.251.68.43");
}
@Test
void jikipRequiresPlanKeyConfigured() {
when(userApiSecretService.findPlainValue(7L, "proxy"))
.thenReturn("https://api.jikip.com/ip-get?key=extract-key&num=1");
when(userApiSecretService.findChannel(7L, "proxy")).thenReturn("jikip");
when(userProxyPlanService.getWhitelistCredential(7L)).thenReturn(null);
assertThatThrownBy(() -> service.add(7L, "36.251.68.43"))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("套餐 key");
}
@Test
void supplierFailureBecomesBusinessException() {
when(userApiSecretService.findPlainValue(7L, "proxy"))
.thenReturn("https://overseas.proxy.qg.net/get?key=abc123");
when(userApiSecretService.findChannel(7L, "proxy")).thenReturn("qingguo");
when(qingguoProxyClient.checkAndAddWhitelist("abc123", "36.251.68.43"))
.thenReturn(new ProxyWhitelistOutcome(false, false, "青果套餐不存在或已过期"));
assertThatThrownBy(() -> service.add(7L, "36.251.68.43"))
.isInstanceOf(BusinessException.class)
.hasMessage("青果套餐不存在或已过期");
}
}
@@ -0,0 +1,29 @@
package com.nanri.aiimage.modules.usersecret.support;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class ProxyLinkKeyTest {
@Test
void extractsKeyFromQuery() {
assertThat(ProxyLinkKey.fromUrl(
"https://overseas.proxy.qg.net/get?key=abc123&format=json&num=1")).isEqualTo("abc123");
}
@Test
void acceptsCapitalizedKeyAndDecodesValue() {
assertThat(ProxyLinkKey.fromUrl("https://share.proxy.qg.net/get?Key=a%2Bb%20c"))
.isEqualTo("a+b c");
}
@Test
void returnsNullWhenKeyMissingOrUrlInvalid() {
assertThat(ProxyLinkKey.fromUrl("https://overseas.proxy.qg.net/get?num=1")).isNull();
assertThat(ProxyLinkKey.fromUrl("https://overseas.proxy.qg.net/get?key=")).isNull();
assertThat(ProxyLinkKey.fromUrl("http://user:pass@host:8080")).isNull();
assertThat(ProxyLinkKey.fromUrl("")).isNull();
assertThat(ProxyLinkKey.fromUrl(null)).isNull();
}
}
@@ -0,0 +1,38 @@
package com.nanri.aiimage.modules.usersecret.support;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class PublicIpValidatorTest {
@Test
void acceptsPublicIpv4AndTrims() {
assertThat(PublicIpValidator.normalize(" 36.251.68.43 ")).isEqualTo("36.251.68.43");
}
@Test
void acceptsPublicIpv6() {
assertThat(PublicIpValidator.normalize("2001:4860:4860::8888")).isNotNull();
}
@Test
void rejectsPrivateLoopbackAndLinkLocal() {
assertThat(PublicIpValidator.normalize("127.0.0.1")).isNull();
assertThat(PublicIpValidator.normalize("10.1.2.3")).isNull();
assertThat(PublicIpValidator.normalize("172.16.0.1")).isNull();
assertThat(PublicIpValidator.normalize("192.168.1.10")).isNull();
assertThat(PublicIpValidator.normalize("169.254.1.1")).isNull();
assertThat(PublicIpValidator.normalize("0.0.0.0")).isNull();
assertThat(PublicIpValidator.normalize("::1")).isNull();
}
@Test
void rejectsHostnamesAndMalformedText() {
assertThat(PublicIpValidator.normalize("example.com")).isNull();
assertThat(PublicIpValidator.normalize("1.1.1.1/24")).isNull();
assertThat(PublicIpValidator.normalize("1.1.1")).isNull();
assertThat(PublicIpValidator.normalize("")).isNull();
assertThat(PublicIpValidator.normalize(null)).isNull();
}
}