JAVA代码审计之Shiro反序列化漏洞分析

Posted 2021-08-27 Tr0e

文章目录

• 前言
• Java反序列化
• 源码审计分析
• • IDEA 部署环境
  • 序列化过程分析
  • 反序列化的分析
• 漏洞利用
• 总结

前言

在前面的一篇文章：Apache Shiro Java反序列化漏洞复现 曾介绍了 CVE-2016-4437 漏洞的复现过程和利用方式，为了不再当个“脚本小子”工具人…本文将记录学习下从源码审计的角度分析 CVE-2016-4437 漏洞的原理。

Java反序列化

同样的在前面一篇博文：Java-序列化与反序列化 已经讲述了 Java 序列化和反序列化的概念，此处简单再描述下。

把对象转换为字节序列的过程称为对象的序列化；把字节序列恢复为对象的过程称为对象的反序列化。

对象的序列化主要有两种用途：

1. 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中（持久化对象）；
2. 在网络上传送对象的字节序列（网络传输对象）。

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java 对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为 Java 对象。

Java序列化实例

来看一个实际的例子：

import java.io.Serializable;

public class People implements Serializable {
    public String name;
    public int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

上述代码定义了 People 类，并且实现了 Serializable 接口，我们便可以对其进行序列化和反序列化操作：

import java.io.*;

public class Test {
    public static void main(String[] args) throws Exception {
        // 初始化对象
        People people = new People();
        people.setName("xiaoming");
        people.setAge(18);
        // 序列化步骤
        // 1. 创建一个ObjectOutputStream输出流
        // 2. 调用ObjectOutputStream对象的writeObject输出可序列化对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("d:/People.txt")));
        oos.writeObject(people);
        System.out.println("people对象序列化成功！");
        // 反序列化步骤
        // 1. 创建一个ObjectInputStream输入流
        // 2. 调用ObjectInputStream对象的readObject()得到序列化的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("d:/People.txt")));
        People people1 = (People) ois.readObject();
        System.out.println("people对象反序列化成功！");
        System.out.println(people1.getName());
        System.out.println(people1.getAge());
    }
}

代码运行结果：

people对象序列化成功！
people对象反序列化成功！
xiaoming
18

序列化过程将字节流保存在 d:/People.txt 中，我们可以在 d:/People.txt 看到序列化后的二进制对象（其中开头的 aced 0005 是 Java 序列化文件的文件头）：

反序列化漏洞

回想一下 CTF 比赛经常遇到的 php 的反序列化漏洞，反序列化对象时会调用类的魔法函数__construct()(创建对象时触发)，我们可以构造 pop 链来控制(改造)__construct()函数，从而反序列化时执行我们需要的操作，Java 也是类似。

在上面的代码中，我们通过调用 readObject() 方法来从一个源输入流中读取字节序列，再把它们反序列化为一个对象，那么我们如果控制了此类的 readObject() 方法会怎么样？为了验证想法，我们修改一下 People 类，重写其 readObject() 方法：

public class People implements Serializable {
    //添加以下方法，重写People类的readObject()方法
    private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException{
        //执行默认的readObject()方法
        in.defaultReadObject();
        //执行打开计算器程序命令
        Runtime.getRuntime().exec("calc.exe");
    }
}

运行程序，当执行People people1 = (People) ois.readObject();语句时会调用 People 类的 readObject 方法，弹出计算器：
由此可知控制了类的 readObject 方法便可以在反序列化该类时执行任意操作。事实上大多数 Java 反序列化漏洞都可追溯到 readObject 方法，通过构造 pop 链最终改造 readObject() 方法。

源码审计分析

Apache Shiro 是一个Java安全框架，执行身份验证、授权、密码和会话管理。2016年网络中曝光 Apache Shiro 1.2.4 以前的版本存在反序列化漏洞，尽管该漏洞已经曝光几年，但是在实战中仍然比较实用。

影响版本

Apache Shiro <= 1.2.4

漏洞原理

Apache Shiro 框架提供了记住我的功能（RememberMe），用户登陆成功后会生成经过加密并编码的Cookie。Cookie 的 key 为 RememberMe，Cookie 的值是经过对相关信息进行序列化，然后使用AES加密，最后在使用 Base64 编码处理形成的。

在服务端接收 Cookie值时，按照如下步骤来解析处理：

1. 检索 RememberMe cookie 的值；
2. Base 64解码；
3. 使用AES解密(加密密钥硬编码)；
4. 进行反序列化操作（未作过滤处理）。

在调用反序列化时未进行任何过滤，导致可以触发远程代码执行漏洞。

IDEA 部署环境

下面在本地 IDEA 部署 Apache Shrio 1.2.4 漏洞环境，以便于进行漏洞动态调试分析。

1、首先在 Github 下载项目源码：

https://github.com/apache/shiro

注意选择存在漏洞的 1.2.4 版本：
2、编辑 shiro\\samples\\web 路径下的 pom.xml 文件，给 jstl 指定版本：
3、使用 IDEA 导入此 MVN 项目：
4、等待 IDEA 自动下载并导入完项目依赖的包，build 完成后项目结构如下：
注意，pom.xml 里面的配置会让程序自动下载shiro-core依赖包（后面程序加断点调试会用到该部分文件）：

5、接着设置 run/debug configurations， 添加本地 Tomcat 环境（需要提前在本地安装 Tomcat 环境）：
6、添加项目 War 包 samples-web.war进 Tomcat 中：
附：此处该 War 包之所以存在，是因为它也是前面 pom.xml 配置文件设置的自动下载到本地的：
7、配置完以上的准备工作，就可以直接 run 运行程序了：
运行成功后浏览器将自动打开目标程序站点，本地环境部署至此结束：
8、访问登录页面进行已提示账户的登录，抓包可见 remenberme 字段：
9、为了开始调试该程序，先停止程序运行，然后在 External Libraries 中找到 shiro-core-1.2.4 的 jar 包，打开 RememberMeManager.class 文件并在 onSuccessfulLogin 函数前加断点，然后点击 Debug 按钮开始在调试模式下运行程序：
10、接着在 Web 端登录账户 root/secret，勾选上 Remember Me 的按钮，程序会停在断点处，然后便可以开始正式的 Debug 漏洞调试了：
11、以上项目工程相当于是只导入 samples-web 文件夹，实际上也可以直接在 IDEA 导入在 Github 下载的完整的 shiro-shiro-root-1.2.4 源码工程文件夹，待 Build 自动下载完所需的依赖包后，同样的步骤配置 Tomcat，然后直接找到 core 文件夹下的RememberMeManager.java 文件并在 onSuccessfulLogin 函数前加断点：
12、接着在 Debug 模式下运行程序，也可在断点处拦截程序、进行调试：
后面的审计分析将基于上述导入所有项目源码的工程项目，因为相比于第一种仅导入 samples-web 文件夹并通过引入shiro-core-1.2.4 的 jar 包来调试 class 文件的方式，直接审计全部 java 源码将更为直观！

序列化过程分析

下面开始正式调试分析 Apache Shiro 框架在登录过程生成序列化 Cookie对象的过程。

1、首先看下登录请求发送后断点停留的 onSuccessfulLogin 函数：
程序首先调用 forgetIdentity 构造方法处理 request 和 response 请求，包括在 response 中加入 cookie 信息，然后调用 rememberIdentity 函数，来处理 cookie 中的 rememberme 字段。

2、我们按 F8 来 Step Over 跨过 forgetIdentity 构造方法，然后 F7 来 Step Into 跟进下 rememberIdentity 函数：
可以看到，rememberIdentity 函数首先调用 getIdentityToRemember 函数来获取用户身份，这里也就是"root"。

3、接着我们跟进 rememberIdentity 构造方法：
4、上面调用了 convertPrincipalsToBytes 方法将 accountPrincipals 也就是 “root” 转换为字节形式，跟进该方法查看内部如何转换：
5、转换过程是先序列化用户身份 “id” ，再对其进行 encrypt 加密，进一步跟进 encrypt 函数查看加密方式：
6、encrypt 函数就是调用 AES 加密对序列化后的 “root” 进行加密，加密的密钥由 getEncryptionCipherKey() 得到，跟进 getEncryptionCipherKey() 函数会发现其值为常量（即密钥硬编码）：
7、Shift+F8 进行 Step Out 步出，返回到 rememberIdentity 函数：

8、跟进 rememberSerializedIdentity 函数查看后续转换流程，发现该函数对上述 root 的 AES 加密后的序列化值进行 base64 编码后，设置到cookie中：
到这里我们可以梳理下上述整个 Cookie 的生成过程，当我们勾选上 Remember Me 选项框后，以 root 身份登录，后端会进行如下操作：

1. 序列化用户身份"root"，得到值 A；
2. 对 root 的序列化值 A 进行 AES 加密（密钥为硬编码的常量），得到值 B；
3. base64 编码上述计算的结果 B，得到值 C；
4. 将值 C 设置到 response 响应包中 cookie 的 rememberme 字段。

可以看看整个数据包：

反序列化的分析

以上已经调试分析完 Shiro 生成 Cookie 字段的序列化、加密过程，下面来进一步调试分析下 Cookie 字段的反序列化、解密过程。

1、将断点打在org.apache.shiro.mgt.DefaultSecurityManager#getRememberedIdentity函数处，然后发送一个带有 rememberMe Cookie 的请求：

2、跟进查看 getRememberedPrincipals 函数：

3、跟进 getRememberedSerializedIdentity 函数，发现函数提取出 cookie 并将其进行 base64 解码：
4、Step Out 返回到 getRememberedPrincipals 函数，继续跟进到 convertBytesToPrincipals 函数，发现其对 cookie 进行 AES 解密和反序列化：
5、同理再依次跟进查看 AES 解密函数 decrypt、反序列化函数 deserialize，如下：
至此 Cookie 的反序列化、解密流程分析完毕，整个流程大致为：

1. 读取 cookie 中 rememberMe 值；
2. base64 解码；
3. AES解密；
4. 反序列化

其中 AES 加解密的密钥为常量 且 反序列化过程没有进行过滤，于是我们可以手动构造 rememberMe 值，改造其 readObject() 方法，让其在反序列化时执行任意操作。

漏洞利用

在前面的一篇文章：Apache Shiro Java反序列化漏洞复现 已经介绍了如何手工构造 Payload 对此处的反序列化漏洞进行利用，下面简单演示下利用 shiro_attack-2.0 工具进行自动化攻击。

1、如下图，依次爆破密钥和检测构造链：
2、利用反序列化漏洞成功执行任意命令：

【注意】 如果是直接导入 samples-web 文件夹建立工程项目的话，会导致攻击失败：

因为 shiro550 自带的包是 commons-collections3.2.1，原生情况下直接用 ysoserial 打，是不会成功的（这是因为 CommonsCollections3.2.1 用的是非数组形式的利用链，在该利用链上没有出现数组类型的对象，这使得在 shiro 的环境下，可以正确执行命令）：

需要修改 pom.xml，添加 commons-collections4 依赖包：
重新 Build 一下项目，确认已下载上述依赖包：

随后即可成功攻击利用：

总结

本文是调试分析 CVE 漏洞的第一篇，遇到了很多坑点，但也学到了不少东西，继续努力吧！

最后说一下，CVE-2016-4437 漏洞主要的修复方案：

1. 升级 shiro 到最新版本；
2. 如果在配置里配置了密钥，那么请一定不要使用网上的密钥， 一定不要！请自己base64一个AES的密钥，或者利用官方提供的方法生成密钥：org.apache.shiro.crypto.AbstractSymmetricCipherService#generateNewKey()。

本文参考文章：

1. 分析调试apache shiro反序列化漏洞(CVE-2016-4437)；
2. Shiro 反序列化记录 。