添加提示

This commit is contained in:
lu7213 committed 2026-11-15 10:32:23 -05:00
1 parent 4c4fd99fc4
commit 1daf477899
10 files changed
+562

No files matched your search

@@ -0,0 +1,8 @@
# 当前证据
扩展静态扫描完成:466 个运行依赖 JAR、125848 个条目,目标域名/IP 的明文、UTF-16、Base64 和百分号编码均未命中,扫描错误 0;阴性结果不能排除动态拼接、数据库配置或实际部署差异。
前轮已确认 AWS ELB 域名为 grpc.nile.trongrid.io 的 CNAME。
前轮扫描运行依赖未找到两个 Pinggy 域名明文。org.json:json:19970182 含授权校验逻辑,但尚未与 Pinggy 关联。
当前 RuoYiApplication 启动扫描 com.ruoyi、com.luqj 和 org.code.modules.plugins,插件目录来自 plugin.base.dir。独立执行器有另一个启动入口,也应支持同一诊断。
当前没有运行中的业务 Java 服务,仅有 IDEA Maven JVM,无法直接取得正在复现异常的 Java 调用栈。
对本地 D:/luqj-plugins 插件 JAR 和 D:/configs/license.dll 扫描明文、UTF-16 与 Base64 字符串,未命中目标域名。
主入口原本仅经本地 ruoyi-framework 间接依赖 ruoyi-system,Maven reactor 先编译 admin,新增诊断引用因此读取旧本地 system JAR。需要显式依赖 system 保证使用本轮编译的源码。
@@ -0,0 +1,7 @@
# 排查进度
最终相关回归:91 项,0 失败,0 错误,1 项跳过;其中诊断独立 JVM 测试 5 项全部通过,新增验证已有安全策略拒绝读取诊断配置时仍正常启动。
扩展扫描 466 个依赖 JAR 的 125848 条目,无目标字符串命中、无扫描错误。已完成中文启用与判读文档;仍需实际复现环境输出才能归因具体包。
已读取两个入口、POM、配置和当前工作区规则。保留已有修改,不执行 Git 历史查询。
计划使用 JDK 8 SecurityManager 的 checkConnect 观察 DNS/连接;默认关闭,已存在安全管理器时拒绝覆盖,仅记录指定域名及调用来源,不能作为沙箱。
4 个独立 JVM 测试全部通过:默认关闭、保留原安全管理器、本地真实 DNS 的动态 JAR 来源、域名边界和 200 事件输出上限。测试无可疑域名外联。
首次全模块编译因 admin 在 system 之前构建而找不到新类;以显式依赖修复构建顺序,不修改业务。
@@ -0,0 +1,11 @@
# Pinggy 异常外联定位
## Next Step
在实际复现服务启用诊断,采集首条完整调用栈以确认请求来源;本地实现与验证已完成。
### Phase 1: 当前调用链与证据检查
**Status:** complete
### Phase 2: 定位代码与隔离验证
**Status:** complete
### Phase 3: 扩展扫描、文档与结果交付
**Status:** complete
## Boundaries
不改业务逻辑,不主动请求可疑域名,不启动带真实数据库及链上调度的完整服务。
+2
View File
@@ -1,5 +1,7 @@
## 平台简介 ## 平台简介
临时排查未知域名外联可启用[网络调用来源诊断](docs/network-request-trace.md),记录 DNS 调用栈和实际加载的 JAR 来源;默认关闭,适用于 JDK 8。
TRON 密钥生成、地址校验和离线签名恢复通过现有 Trident 与 `TronKey` 适配实现,不再依赖 `tron-wallet-cli`;钱包派生路径、地址编码和投票交易行为保持兼容。后端请使用 JDK 8 编译。 TRON 密钥生成、地址校验和离线签名恢复通过现有 Trident 与 `TronKey` 适配实现,不再依赖 `tron-wallet-cli`;钱包派生路径、地址编码和投票交易行为保持兼容。后端请使用 JDK 8 编译。
归集、代付支持可选的[双平台资源租赁](docs/resource-rental.md):人工确认租赁后等待链上资源到账,再输入密码广播;独立执行器自动异步准备资源。默认关闭,启用前执行增量SQL并配置加密的平台凭据。 归集、代付支持可选的[双平台资源租赁](docs/resource-rental.md):人工确认租赁后等待链上资源到账,再输入密码广播;独立执行器自动异步准备资源。默认关闭,启用前执行增量SQL并配置加密的平台凭据。
+124
View File
@@ -0,0 +1,124 @@
# Pinggy 外联调用来源定位
## 当前结论与证据边界
`grpc.nile.trongrid.io` 的 AWS ELB CNAME 属于已有 Nile 查询链路。
两个 `*.run.pinggy-free.link` 域名的 DNS 记录不能直接确定 Java 调用者,
也不能凭 NXDOMAIN 断言已经成功连接或外传信息。
已检查的本地动态插件 JAR 和 `D:/configs/license.dll` 中未命中目标域名的明文、
UTF-16 或 Base64 内容。此前识别到 `org.json:json:19970182` 含授权代码,
但没有把它与这两个 Pinggy 域名关联的调用栈;暂不能认定是该包引入。
实际部署目录、数据库、运行环境可能与本机不同,需要在复现进程中采样。
## 开启方式
该功能针对本项目 JDK 8,默认关闭。管理后端和独立执行器均已在 `main` 的
Spring 启动之前调用 `NetworkRequestTrace.installIfEnabled()`,不需要修改业务配置。
IDEA 的 Run/Debug Configuration → VM options 加入:
```text
-Dnetwork.trace.enabled=true
```
部署环境也可以设置 `NETWORK_TRACE_ENABLED=true`。JVM 参数优先于环境变量。
必须重启实际出现异常的 Java 进程,修改当前终端变量不会影响已经启动的进程。
无需把开关放进 `application.yml`;这里是在 Spring 读取 YAML 之前安装。
现有 `java -jar` 启动命令把开关放在 `-jar` 之前,例如:
```bash
java -Dnetwork.trace.enabled=true -jar ruoyi-admin.jar
```
默认匹配 `pinggy-free.link` 和它的子域名。如果只需这两个域名,可以设置:
```text
-Dnetwork.trace.hosts=wzndf-185-244-148-229.run.pinggy-free.link,lmdpj-185-244-148-229.run.pinggy-free.link
```
环境变量等效项为 `NETWORK_TRACE_HOSTS`。需要顺便对照 Nile 调用时,可以把
`grpc.nile.trongrid.io` 加入逗号分隔的列表。不要使用 URL、密码或查询串作为过滤值。
更新主程序时,必须同时更新本轮构建的 `ruoyi-system` JAR;外置 `lib` 部署不能只更新
`ruoyi-admin.jar`,也不能把旧 `ruoyi-system` 留在同一 classpath 中。
主模块已显式声明系统模块依赖,完整 Maven 构建会先编译当前系统模块。
## 查看结果
启动控制台首先应显示:
```text
[NETWORK-TRACE] ENABLED java=1.8... hosts=pinggy-free.link maxEvents=200 output=stderr observation-only
```
日志直接写入标准错误输出,覆盖日志框架尚未初始化的时段。
IDEA 控制台、systemd journal 或容器日志一般会收集 stderr;只看业务 `info.log`
可能看不到。自行启动时可以在原命令后追加 `2>network-trace.log` 收集诊断。
目标域名被解析时,输出形式如下(以下为格式示意,并非已经捕获的可疑调用):
```text
[NETWORK-TRACE] BEGIN event=1 timeMillis=... threadId=... operation=DNS host=lmdpj-185-244-148-229.run.pinggy-free.link port=-1
origin com.example.CallbackWorker source=file:/srv/app/lib/example.jar
at java.net.InetAddress.getAllByName(...)
at com.example.CallbackWorker.send(CallbackWorker.java:123)
[NETWORK-TRACE] END event=1
```
`origin` 显示实际执行类的 CodeSource,而非根据类名推测 JAR;`at` 显示方法和行号。
结合类名与相应栈帧,判断请求来自业务回调、依赖授权逻辑或动态插件。
若栈帧是异步 DNS 工作线程,它只能说明当前解析任务的执行者,仍需沿上游任务入口追查。
重点判读:
| 栈上的业务类 | 后续核查 |
| --- | --- |
| `PaymentCallbackWorker` | `orders.notify_url`、订单 ID、回调次数 |
| `PayoutCallbackService` | `usdt_payout_order.notify_url` |
| `RentalWorkers` | `rent_order.notify_url`、`rent_webhook` 对应明细;域名校验本身也可能触发 DNS |
| `com.license.*` | 日志中实际加载的 JAR、部署环境的授权地址配置及本地 DLL |
| 其他库或插件类 | 以 `origin source=` 指向的实际 JAR 为准,核对该部署文件的哈希及来源 |
## 同步检查数据库中的旧回调地址
当前本机无法连接配置中的数据库,所以没有假定数据库里不存在目标域名。
可以在复现服务实际连接的数据库中执行以下只读查询,只返回记录 ID 和状态,
不返回完整 URL、请求参数、API Key 或私钥。没有租赁表的库跳过相应查询。
```sql
SELECT id, status, callback_num, callback_confirm
FROM orders WHERE LOWER(notify_url) LIKE '%pinggy-free.link%' LIMIT 100;
SELECT id, status, callback_num, callback_confirm
FROM usdt_payout_order WHERE LOWER(notify_url) LIKE '%pinggy-free.link%' LIMIT 100;
SELECT id, status
FROM rent_order WHERE LOWER(notify_url) LIKE '%pinggy-free.link%' LIMIT 100;
SELECT id, status
FROM rent_app WHERE LOWER(notify_url) LIKE '%pinggy-free.link%' LIMIT 100;
```
命中仅代表存在配置,不代表该行正被定时任务执行;需要结合调用栈和任务状态确认。
不要直接删除订单、修改回调状态或清空队列作为定位手段。
## 诊断边界与关闭
- 该钩子基于 JDK 8 `SecurityManager.checkConnect`。`port=-1` 表示解析前检查,
不是 HTTP 已成功发出。诊断本身不访问目标域名,也不改变 DNS 缓存、代理或连接结果。
- 只记录域名、时间、线程 ID、栈帧和类来源,不采集完整 URL、请求头、正文或钱包数据。
- 已存在安全管理器时输出 `NOT_INSTALLED existing-security-manager`,不会覆盖已有策略。
这是观察工具,不是安全沙箱。部分较新 JDK 已禁用此机制,应使用项目 JDK 8。
- 最多输出 200 条事件;出现 `LIMIT_REACHED` 后仍正常执行网络操作,但停止打印。
- JNI、自建 DNS 解析器、原生库、子进程和其他服务的请求不一定经过本钩子。
一直没有日志时,应先核对 `ENABLED`、进程、部署 JAR、事件上限,再用操作系统工具关联 PID。
- 定位后删除 VM 参数/环境变量并重启,或显式设置 `-Dnetwork.trace.enabled=false`。
现有业务任务、回调及链上逻辑均不因该开关而被禁用。
## 验证
`NetworkRequestTraceTest` 在独立 JVM 中验证默认关闭、保留原安全管理器、
通过本地 `localhost` 真实解析记录动态 JAR 来源、域名边界、敏感 URL 拒绝输出和事件上限。
测试不解析 Pinggy 域名,也不启动真实数据库或链上调度。
+5
View File
@@ -24,6 +24,11 @@
</dependencies> </dependencies>
</dependencyManagement> </dependencyManagement>
<dependencies> <dependencies>
<!-- 启动入口直接使用系统模块的诊断类,显式声明以保证多模块构建先编译当前源码。 -->
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-system</artifactId>
</dependency>
<dependency> <dependency>
<groupId>org.json</groupId> <groupId>org.json</groupId>
<artifactId>json</artifactId> <artifactId>json</artifactId>
@@ -2,6 +2,7 @@ package com.ruoyi;
import com.baomidou.mybatisplus.annotation.DbType; import com.baomidou.mybatisplus.annotation.DbType;
import com.ruoyi.framework.config.MybatisPlusInterceptor; import com.ruoyi.framework.config.MybatisPlusInterceptor;
import com.ruoyi.system.diagnostics.NetworkRequestTrace;
import org.mybatis.spring.annotation.MapperScan; import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication; import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.autoconfigure.SpringBootApplication;
@@ -20,6 +21,7 @@ import org.springframework.context.annotation.Bean;
}) })
public class RuoYiApplication { public class RuoYiApplication {
public static void main(String[] args) {// System.setProperty("spring.devtools.restart.enabled", "false"); public static void main(String[] args) {// System.setProperty("spring.devtools.restart.enabled", "false");
NetworkRequestTrace.installIfEnabled();
SpringApplication.run(RuoYiApplication.class, args); SpringApplication.run(RuoYiApplication.class, args);
} }
@@ -0,0 +1,206 @@
package com.ruoyi.system.diagnostics;
import java.net.URL;
import java.security.CodeSource;
import java.security.Permission;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.atomic.AtomicInteger;
/**
* JDK 8 临时外联诊断:在 DNS 解析/连接之前记录调用栈与实际加载的 JAR 来源。
*
* <p>默认关闭,必须在 Spring 启动前调用。仅观察,不拒绝连接,不改变 DNS 缓存或
* 代理配置,不读取请求 URL、请求参数、正文、环境变量清单或钱包数据。
* 不是安全沙箱,也不能代替操作系统抓包;JNI、自建 DNS 客户端和其他进程可能绕过此钩子。</p>
*/
public final class NetworkRequestTrace extends SecurityManager {
private static final String ENABLED_PROPERTY = "network.trace.enabled";
private static final String HOSTS_PROPERTY = "network.trace.hosts";
private static final String DEFAULT_HOSTS = "pinggy-free.link";
/** 限制整个进程的诊断输出量,避免定时重试刷满日志;重启可重新采集。 */
private static final int MAX_EVENTS = 200;
private static final int MAX_FRAMES = 80;
private final String[] watchedHosts;
private final AtomicInteger events = new AtomicInteger();
private final ThreadLocal<Boolean> recording = new ThreadLocal<Boolean>();
private NetworkRequestTrace(String[] watchedHosts) {
this.watchedHosts = watchedHosts;
}
/**
* -Dnetwork.trace.enabled=true 或 NETWORK_TRACE_ENABLED=true 启用。
* 只接受 JVM 参数/环境变量,因为 application.yml 在这个启动阶段还未加载。
* 已有安全管理器时不替换,避免降低原有安全策略。
*/
public static synchronized void installIfEnabled() {
try {
installConfigured();
} catch (SecurityException | UnsupportedOperationException ex) {
// 读取开关也可能被现有策略拒绝,不能因诊断逻辑阻止原服务启动。
System.err.println("[NETWORK-TRACE] NOT_INSTALLED " + ex.getClass().getSimpleName());
}
}
private static void installConfigured() {
String enabled = System.getProperty(ENABLED_PROPERTY);
if (enabled == null) {
enabled = System.getenv("NETWORK_TRACE_ENABLED");
}
if (!Boolean.parseBoolean(enabled)) {
return;
}
if (System.getSecurityManager() instanceof NetworkRequestTrace) {
return;
}
if (System.getSecurityManager() != null) {
System.err.println("[NETWORK-TRACE] NOT_INSTALLED existing-security-manager");
return;
}
String configured = System.getProperty(HOSTS_PROPERTY);
if (configured == null) {
configured = System.getenv("NETWORK_TRACE_HOSTS");
}
String[] hosts = parseHosts(configured == null ? DEFAULT_HOSTS : configured);
if (hosts.length == 0) {
System.err.println("[NETWORK-TRACE] NOT_INSTALLED invalid-host-filter");
return;
}
System.setSecurityManager(new NetworkRequestTrace(hosts));
System.err.println("[NETWORK-TRACE] ENABLED java="
+ safe(System.getProperty("java.version")) + " hosts="
+ String.join(",", hosts) + " maxEvents=" + MAX_EVENTS
+ " output=stderr observation-only");
}
/** 不引入权限限制:安装前没有 SecurityManager,安装后仍允许原有操作。 */
@Override
public void checkPermission(Permission permission) {
// Observation only.
}
@Override
public void checkPermission(Permission permission, Object context) {
// Observation only.
}
@Override
public void checkConnect(String host, int port) {
record(host, port);
}
@Override
public void checkConnect(String host, int port, Object context) {
record(host, port);
}
private void record(String host, int port) {
if (Boolean.TRUE.equals(recording.get()) || !matches(host)) {
return;
}
recording.set(Boolean.TRUE);
try {
int sequence = events.incrementAndGet();
if (sequence > MAX_EVENTS) {
return;
}
StringBuilder output = new StringBuilder(4096);
output.append("[NETWORK-TRACE] BEGIN event=").append(sequence)
.append(" timeMillis=").append(System.currentTimeMillis())
.append(" threadId=").append(Thread.currentThread().getId())
.append(" operation=").append(port == -1 ? "DNS" : "CONNECT")
.append(" host=").append(normalizeHost(host)).append(" port=").append(port)
.append('\n');
// Class 对象来自真实执行栈;不根据类名反射加载其他类,避免触发静态初始化。
Class<?>[] context = getClassContext();
for (int i = 0; i < context.length && i < MAX_FRAMES; i++) {
Class<?> type = context[i];
if (type != NetworkRequestTrace.class) {
output.append(" origin ").append(safe(type.getName()))
.append(" source=").append(sourceOf(type)).append('\n');
}
}
StackTraceElement[] stack = new Throwable().getStackTrace();
for (int i = 0; i < stack.length && i < MAX_FRAMES; i++) {
// 只打印栈帧元数据,不打印业务异常消息或参数。
output.append(" at ").append(safe(stack[i].toString())).append('\n');
}
if (sequence == MAX_EVENTS) {
output.append("[NETWORK-TRACE] LIMIT_REACHED restart-to-capture-more\n");
}
output.append("[NETWORK-TRACE] END event=").append(sequence);
// 一次写入防止并发事件互相穿插。使用 stderr,覆盖日志框架初始化前的调用。
System.err.println(output.toString());
} catch (RuntimeException | LinkageError ex) {
// 来源信息不可用或类加载失败时,仅放弃本次诊断,原网络操作继续。
} finally {
recording.remove();
}
}
private boolean matches(String host) {
String normalized = normalizeHost(host);
if (normalized == null) {
return false;
}
for (String watched : watchedHosts) {
if (normalized.equals(watched) || normalized.endsWith("." + watched)) {
return true;
}
}
return false;
}
private static String[] parseHosts(String configured) {
List<String> hosts = new ArrayList<String>();
for (String value : configured.split(",")) {
String normalized = normalizeHost(value.trim());
if (normalized != null && hosts.size() < 32) {
hosts.add(normalized);
}
}
return hosts.toArray(new String[hosts.size()]);
}
/** 仅接受域名/IP 字符,避免 URL 中的密码、查询参数及日志换行进入诊断输出。 */
private static String normalizeHost(String host) {
if (host == null || host.isEmpty() || host.length() > 253) {
return null;
}
String normalized = host.toLowerCase(Locale.ROOT);
if (normalized.endsWith(".")) {
normalized = normalized.substring(0, normalized.length() - 1);
}
if (normalized.isEmpty()) {
return null;
}
for (int i = 0; i < normalized.length(); i++) {
char value = normalized.charAt(i);
if (!(value >= 'a' && value <= 'z') && !(value >= '0' && value <= '9')
&& value != '.' && value != '-' && value != ':' && value != '[' && value != ']') {
return null;
}
}
return normalized;
}
private static String sourceOf(Class<?> type) {
CodeSource source = type.getProtectionDomain().getCodeSource();
if (source == null || source.getLocation() == null) {
return "[JDK-or-unavailable]";
}
URL location = source.getLocation();
String external = location.toExternalForm();
// 不输出远程类加载器地址中的认证信息;普通 JAR、目录和 Spring Boot 嵌套 JAR 可显示。
if (!external.startsWith("file:") && !external.startsWith("jar:file:")) {
return "[non-file-code-source]";
}
return safe(external.split("[?#]", 2)[0]);
}
private static String safe(String value) {
return value == null ? "[unknown]" : value.replace('\r', '_').replace('\n', '_').replace('\t', '_');
}
}
@@ -0,0 +1,195 @@
package com.ruoyi.system.diagnostics;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.Permission;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import org.junit.Test;
import static org.junit.Assert.*;
/** 每个场景使用独立 JVM,防止临时 SecurityManager 污染其他支付测试。 */
public class NetworkRequestTraceTest {
@Test
public void disabledByDefault() throws Exception {
String output = runProbe("disabled");
assertTrue(output.contains("DISABLED_OK"));
assertFalse(output.contains("[NETWORK-TRACE]"));
}
@Test
public void existingSecurityPolicyIsNeverReplaced() throws Exception {
String output = runProbe("existing");
assertTrue(output.contains("NOT_INSTALLED existing-security-manager"));
assertTrue(output.contains("EXISTING_OK"));
}
@Test
public void deniedDiagnosticPropertyDoesNotPreventApplicationStartup() throws Exception {
String output = runProbe("denied");
assertTrue(output, output.contains("NOT_INSTALLED SecurityException"));
assertTrue(output, output.contains("DENIED_OK"));
}
@Test
public void realLocalDnsShowsStackAndDynamicallyLoadedJar() throws Exception {
String output = runProbe("enabled");
assertTrue(output, output.contains("operation=DNS host=localhost port=-1"));
assertTrue(output, output.contains("origin " + JarCaller.class.getName() + " source=file:"));
assertTrue(output, output.contains("probe-caller.jar"));
assertTrue(output, output.contains("JarCaller.lookup("));
assertTrue(output, output.contains("LOOKUP_OK"));
assertFalse(output, output.contains("not-localhost.example"));
assertFalse(output, output.contains("secret-query-marker"));
}
@Test
public void defaultFilterMatchesOnlyPinggyDomainBoundaryAndCapsLogs() throws Exception {
String output = runProbe("filter");
assertTrue(output, output.contains("host=test.pinggy-free.link"));
assertFalse(output, output.contains("evilpinggy-free.link"));
assertFalse(output, output.contains("pinggy-free.link.example"));
assertTrue(output, output.contains("LIMIT_REACHED"));
assertFalse(output, output.contains("BEGIN event=201"));
assertTrue(output, output.contains("FILTER_OK"));
}
private String runProbe(String mode) throws Exception {
String java = Paths.get(System.getProperty("java.home"), "bin", "java").toString();
String classpath = System.getProperty("surefire.test.class.path",
System.getProperty("java.class.path"));
List<String> command = new ArrayList<String>();
command.add(java);
command.add("-cp");
command.add(classpath);
command.add(Probe.class.getName());
command.add(mode);
Path output = Files.createTempFile("network-trace-test-", ".log");
try {
Process child = new ProcessBuilder(command).redirectErrorStream(true)
.redirectOutput(output.toFile()).start();
try {
assertTrue("诊断子进程超时", child.waitFor(20, TimeUnit.SECONDS));
String text = new String(Files.readAllBytes(output), StandardCharsets.UTF_8);
assertEquals(text, 0, child.exitValue());
return text;
} finally {
if (child.isAlive()) {
child.destroyForcibly().waitFor(5, TimeUnit.SECONDS);
}
}
} finally {
Files.deleteIfExists(output);
}
}
public static class Probe {
public static void main(String[] args) throws Exception {
// 无论宿主环境如何配置,先显式关闭,验证安装入口不会受测试机环境污染。
System.setProperty("network.trace.enabled", "false");
if ("disabled".equals(args[0])) {
NetworkRequestTrace.installIfEnabled();
require(System.getSecurityManager() == null);
System.out.println("DISABLED_OK");
return;
}
System.setProperty("network.trace.enabled", "true");
if ("denied".equals(args[0])) {
SecurityManager original = new SecurityManager() {
@Override public void checkPermission(Permission permission) {
if ("network.trace.enabled".equals(permission.getName())) {
throw new SecurityException("diagnostic-property-denied");
}
}
};
System.setSecurityManager(original);
NetworkRequestTrace.installIfEnabled();
require(System.getSecurityManager() == original);
System.out.println("DENIED_OK");
return;
}
if ("existing".equals(args[0])) {
SecurityManager original = new SecurityManager() {
@Override public void checkPermission(Permission permission) { }
};
System.setSecurityManager(original);
NetworkRequestTrace.installIfEnabled();
require(System.getSecurityManager() == original);
System.out.println("EXISTING_OK");
return;
}
if ("filter".equals(args[0])) {
System.setProperty("network.trace.hosts", "pinggy-free.link");
NetworkRequestTrace.installIfEnabled();
SecurityManager manager = System.getSecurityManager();
// 直接调用钩子验证过滤,不执行这些可疑域名的真实 DNS 查询。
manager.checkConnect("evilpinggy-free.link", -1);
manager.checkConnect("pinggy-free.link.example", -1);
manager.checkConnect("https://test.pinggy-free.link/?secret-query-marker", -1);
for (int i = 0; i < 205; i++) {
manager.checkConnect("TEST.PINGGY-FREE.LINK.", -1);
}
System.out.println("FILTER_OK");
return;
}
System.setProperty("network.trace.hosts", "localhost");
NetworkRequestTrace.installIfEnabled();
SecurityManager installed = System.getSecurityManager();
require(installed instanceof NetworkRequestTrace);
NetworkRequestTrace.installIfEnabled();
require(System.getSecurityManager() == installed);
installed.checkConnect("not-localhost.example", -1);
installed.checkConnect("https://localhost/?secret-query-marker", -1);
// 把调用者放到单独 JAR,并用独立类加载器加载,验证来源来自实际 Class 而非猜测。
Path directory = Files.createTempDirectory("network-trace-origin-");
Path jar = directory.resolve("probe-caller.jar");
String resource = JarCaller.class.getName().replace('.', '/') + ".class";
try {
try (JarOutputStream stream = new JarOutputStream(Files.newOutputStream(jar));
InputStream input = Probe.class.getClassLoader().getResourceAsStream(resource)) {
require(input != null);
stream.putNextEntry(new JarEntry(resource));
byte[] buffer = new byte[4096];
int count;
while ((count = input.read(buffer)) != -1) {
stream.write(buffer, 0, count);
}
stream.closeEntry();
}
try (URLClassLoader loader = new URLClassLoader(new URL[] {jar.toUri().toURL()}, null)) {
Class<?> caller = loader.loadClass(JarCaller.class.getName());
caller.getMethod("lookup").invoke(null);
}
} finally {
Files.deleteIfExists(jar);
Files.deleteIfExists(directory);
}
System.out.println("LOOKUP_OK");
}
private static void require(boolean condition) {
if (!condition) {
throw new IllegalStateException("诊断探针断言失败");
}
}
}
/** 该类只依赖 JDK,能从独立 JAR 加载;只解析本地回环域名。 */
public static class JarCaller {
public static void lookup() throws Exception {
if (InetAddress.getAllByName("localhost").length == 0) {
throw new IllegalStateException("本地域名解析失败");
}
}
}
}
@@ -2,6 +2,7 @@ package com.ruoyi.executor;
import com.ruoyi.system.chain.ChainCommandExecutor; import com.ruoyi.system.chain.ChainCommandExecutor;
import com.ruoyi.system.chain.ChainExecutionStore; import com.ruoyi.system.chain.ChainExecutionStore;
import com.ruoyi.system.diagnostics.NetworkRequestTrace;
import com.ruoyi.system.mapper.UsdtConfigMapper; import com.ruoyi.system.mapper.UsdtConfigMapper;
import com.ruoyi.system.service.TronChainDataClient; import com.ruoyi.system.service.TronChainDataClient;
import com.ruoyi.system.service.TronServiceProvider; import com.ruoyi.system.service.TronServiceProvider;
@@ -40,6 +41,7 @@ public class ChainExecutorApplication {
private static final Logger log = LoggerFactory.getLogger(ChainExecutorApplication.class); private static final Logger log = LoggerFactory.getLogger(ChainExecutorApplication.class);
public static void main(String[] args) { public static void main(String[] args) {
NetworkRequestTrace.installIfEnabled();
// 配置错误只输出固定提示;Spring 启动异常可能包含 JDBC URL 等配置,不打印异常对象。 // 配置错误只输出固定提示;Spring 启动异常可能包含 JDBC URL 等配置,不打印异常对象。
try { try {
log.info("USDT链上执行器正在启动,运行模式=独立内网执行进程"); log.info("USDT链上执行器正在启动,运行模式=独立内网执行进程");