SniperlCat 0.3.1, pasado a perl estricto y correjidos bugs varios

Esta versión no trae nada nuevo, así que va a ser corto. Se pasó todo el código a perl estricto (use strict), y se corriguieron fallos tontos al interpretar las opciones de la línea de comandos, por ejemplo, si se daemonizaba después de lanzar un hilo, el hilo se cerraba por que lo hacía el proceso original =P

El trigger no cambia (bueno, en realidad cambia el notify-send, que en vez de poner 0.3, es 0.3.1, pero es estético). El código completo está en github , aunque lo importante es el Sniperlcat.pl [o en plano]

ps: Ya me dirán por que ******* no dejarán usar break; en estricto !?

SniperlCat 0.3, suma y sigue

Pues nada, nueva versión de sniperlcat, los cambios son:
  - Los avisos los hace un script a parte, eliminando GTK de las dependencias y haciendo que no haya que trastear en el código para que haga algo distinto con los avisos.
  - Corregido al bug que lo volvia paranoico al cerrar el dispositivo...al final solo había que reabrirlo =)
  - Añadida la opción de poner a la escucha un puerto cualquiera para detectar los scanners que se conectan a el, si se utiliza varias veces se escuchan varios puertos (cada uno en un hilo distinto).

SniperlCat 0.2, detección de SYN scan's

Actualización: por algun extraño motivo se vuelve paranoico con los paquetes cuando se suspende el ordenador y se vuelve a iniciar (¿?), estoy trabajando para resolver eso.

Hoy traigo la segunda versión del SniperlCat [SniperlCat 0.2], los cambios no son muchos, pero creo que pueden resultar interesantes:

- Detecta los paquetes SYN de sockets raw (típicos de un SYN scan), aunque para esto necesita permisos de root para levantar un sniffer, básicamente se aprovecha esta [http://danielmiessler.com/study/synpackets/] idea, aunque con scanners modernos se puede hacer que no exista diferencia, unicamente avisa de paquetes con un tamaño menor de 60 bytes (suelen ser de 58) y sin el flag DF de IP activado.

- Permite llevar un log aparte de las notificaciones... no es gran cosa pero puede ser útil.

- Las alertas se reunieron en una función llamada "show_alert" para poder modificar el sistema más facilmente.

Las dependencias quedarían en "libgtk2-notify-perl" para las notificaciones, y "libnet-pcap-perl" y "libnetpacket-perl" para buscar paquetes sospechosos.

Y la sintaxis del comando sería:

---

Sniperlcat 0.2

sniperlcat [-h]|[-d | -v ] [-nf] [-c] [-n <red>] [-f <descriptor de red>] [-p|-np] [-dv <interfaz>][-l <log>][-s <tiempo>]
-h  (--help): Muestra este mensaje
-d  (--daemonize): Se ejecuta de fondo
-nf (--no-fill): No llena la tabla de hosts (con nmap) antes de leerla
-c  (--cansino): Repite los avisos, aún los ya emitidos, en cada iteración
-v  (--verbose): Muestra más información por pantalla
-n  (--network): Especifica la red donde se ejecuta, por defecto 192.168.1.0/24
-dv (--device): Especifica la interfaz de red que se monitoreará
-p  (--privileged): Se asumirán que es un usuario con privilegios
-np (--no-privileged): Se asumirán que es un usuario sin privilegios
-l  (--log): Se guardarán los avisos en un archivo
-s  (--sleep): Especifica el tiempo en segundos de "descanso" entre iteraciones (por defecto 60)

---

Eso es todo, otro día... más.

[Referencias]
http://seclists.org/pen-test/2007/Oct/44
http://www.perlmonks.org/index.pl?node_id=170648
http://search.cpan.org/~saper/Net-Pcap-0.16/Pcap.pm

Script para hacer animaciones con CFDG

Hoy traigo un script que genera automaticamente un conjunto de imágenes con CFDG [cfanim.pl].
 Lo que hace es partir de un archivo de este programa, partiendo de un nivel de recursividad pequeño y avanzando, por ejemplo, partiendo del archivo:

---

startshape init

rule init{
     spiral{sat 1 b 0.8}
}

rule spiral{
     SQUARE{}
     spiral{x 1 r 1 hue 1 s 0.999}
}

---

Se pueden obtener las imágenes desde el primer nivel de recursividad, hasta, digamos... el 300

---

./cfanim.pl base.cfdg -i 1 -f 300

---

Nota: Es importante no partir del 0, porque se utilizaría en esa imágen el nivel de recursividad normal, no el especificado.

Con ese comando obtendríamos 300 imágenes individiales, pero si además queremos juntarlas para convertirlas en un .gif, se haría:

---

./cfanim.pl base.cfdg -i 1 -f 300 -m animacion.gif

---

La sintaxis del script es:

---

./cfanim.pl <archivo.cfdg> -i <figuras iniciales> -f <figuras finales> [-s <step>] [-m <output.gif> [-d <delay>]]

---

Por ejemplo, en el ejemplo anterior haciendo un gif de los 1000 primeros frames con 1 centésima de segundo entre cada una se haría:

---

./cfanim.pl base.cfdg -i 1 -f 1000 -m animacion.gif -d 1

---

Y eso es todo, hasta otra.

SniperlCat, un guardian de red

Hoy traigo un script en perl que vigila la red en busca de nuevos hosts o de ataques de ARP spoofing (buscando cambios en la tabla arp). El nombre, Sniperlcat es (obviamente) una mezcla entre snipercat y perl, lenguaje en el que esta programado.

El script se puede descargar aquí [sniperlcat.pl], o al final coloreado.

Simplemente hay que ejecutarlo y avisa de los cambios usando el libnotify de GTK2 (puede que sea necesario instalar las librerias Gtk para perl, libdesktop-notify-perl, o libgtk2-notify-perl ).
Por ejemplo, para un nuevo host en la red:

Si el nuevo host está spoofeado desde otro (si coinciden sus MAC):

Si cambia una MAC:

O si cambia la MAC de uno a través de un ARP spoof:

Hay que tener en cuenta algunas cosas:

• El script no hace nada para evitar los ataques ARP spoof, solo los detecta
• Si no se lanza con una configuración, utilizará como tal la tabla ARP en ese momento, si hay entonces un ARP spoof en marcha, lo tomará como el estado base.

Los parámetros aceptados son:

---

./sniperlcat [-h]|[-d | -v ] [-nf] [-c] [-n <red>] [-f <descriptor de red>] [-s <tiempo>]

-h  (--help): Muestra este mensaje

-d  (--daemonize): Se ejecuta de fondo

-nf (--no-fill): No llena la tabla de hosts (con nmap) antes de leerla

-c  (--cansino): Repite los avisos, aun los ya emitidos, en cada iteración

-v  (--verbose): Muestra más información por pantalla

-n  (--network): Especifica la red donde se ejecuta, por defecto 192.168.1.0/24

-f  (--file): Especifica el archivo de red inicial (se obtiene con arp -an)

-s  (--sleep): Especifica el tiempo en segundos de "descanso" entre iteraciones (por defeto 60)

---

Creo que solo necesitan explicación un par de cosas:

• Antes de leer la tabla ARP, para llenarla con todos los host de la red se hace un `nmap $red -sP` , si consideras que no es necesario, usa -nf
• Si la red es distinta de 192.168.1.0/24 (o 192.168.1.*), la puedes cambiar con -n red, como solo lo usa nmap, la sintaxis es la misma que este.

Hasta otra.

El script [sniperlcat.pl] :

---

#!/usr/bin/env perl
#
# SniperlCat
#
##############################################################################
#  Copyright (C) 2010 Kenkeiras <kenkeiras (arroba) gmail (punto) com>
#
#  This program is free software. It comes without any warranty, to
#  the extent permitted by applicable law. You can redistribute it
#  and/or modify it under the terms of the Do What The Fuck You Want
#  To Public License, Version 2, as published by Sam Hocevar.
#
#  See http://sam.zoy.org/wtfpl/COPYING for more details.
##############################################################################

my $appname = "Sniperlcat";

$app_icon = "";
$network = "192.168.1.*";
$verbose = 0;
$cansino = 0;

my $go_back = 0;
my $arp_fill = 1;
my $file = "";
my $sltime = 60;

use Gtk2::Notify -init, "Sniperlcat";

# Se va al fondo
sub daemonize{
    $verbose = 0;
    umask 0;
    open STDIN, "</dev/null" || die $!;
    open STDOUT,">>/dev/null" || die $!;
    open STDERR, ">>/dev/null" || die $!;
    defined ($pid=fork) || die $!;
    exit if $pid;
    setsid || die $!;
}

sub show_help{
        print "$appname\n";
        print "./sniperlcat [-h]|[-d | -v ] [-nf] [-c] [-n <red>] [-f <descriptor de red>] [-s <tiempo>]\n";
        print "-h  (--help): Muestra este mensaje\n";
        print "-d  (--daemonize): Se ejecuta de fondo\n";
        print "-nf (--no-fill): No llena la tabla de hosts (con nmap) antes de leerla\n";
        print "-c  (--cansino): Repite los avisos, aun los ya emitidos, en cada iteración\n";
        print "-v  (--verbose): Muestra más información por pantalla\n";
        print "-n  (--network): Especifica la red donde se ejecuta, por defecto 192.168.1.0/24\n";
        print "-f  (--file): Especifica el archivo de red inicial (se obtiene con arp -an)\n";  
        print "-s  (--sleep): Especifica el tiempo en segundos de \"descanso\" entre iteraciones (por defeto 60)\n";  
}

# Comprueba los parámetros

my $i = 0;
while ($i <= $#ARGV){
    if (($ARGV[$i] eq "-d") || ($ARGV[$i] eq "--daemonize")){
        $go_back = 1;
    }
    elsif (($ARGV[$i] eq "-h") || ($ARGV[$i] eq "--help")){
        show_help;
        exit 0;
    }
    elsif (($ARGV[$i] eq "-v") || ($ARGV[$i] eq "--verbose")){
        $verbose = 1;
    }
    elsif (($ARGV[$i] eq "-c") || ($ARGV[$i] eq "--cansino")){
        $cansino = 1;
    }
    elsif (($ARGV[$i] eq "-nf") || ($ARGV[$i] eq "--no-fill")){
        $arp_fill = 0;
    }
    elsif (($ARGV[$i] eq "-n") || ($ARGV[$i] eq "--network")){
        $i++;
        if ($i > $#ARGV){
            print "No se ha especificado la red\n";
            show_help;
            exit 1;
        }
        $network = $ARGV[$i];
    }
    elsif (($ARGV[$i] eq "-f") || ($ARGV[$i] eq "--file")){
        $i++;
        if ($i > $#ARGV){
            print "No se ha especificado el archivo de red\n";
            show_help;
            exit 1;
        }
        $file = $ARGV[$i];
    }
    elsif (($ARGV[$i] eq "-s") || ($ARGV[$i] eq "--sleep")){
        $i++;
        if ($i > $#ARGV){
            print "No se ha especificado el tiempo\n";
            show_help;
            exit 1;
        }
        $sltime = $ARGV[$i];
    }
    $i++;
}

daemonize if $go_back;

# LLena la tabla arp con nmap
sub fill_arp_table{
    `nmap $network -sP 2>/dev/null 1>/dev/null`;
}

# Carga la tabla arp de un archivo
sub load_arp_desc{
    my %tmplist = ();
    my $arp = $_[0];
    my @lines = split(/\n/,$arp);
    my $ip,$mac,$i = 0;
    my $max = @lines;

    while ($i < $max){
        # Extrae la IP
        @line = split(/ /,@lines[$i]);
        @ip = split(/\(/,$line[1]);
        @ip = split(/\)/,@ip[1]);
        $ip = @ip[0];


        # Y la MAC
        $mac = $line[3];

        # Y se introduce en la lista si es una MAC válida
        if (substr("$mac", 0, 1) ne "<"){
            $tmplist{"$ip"} = "$mac";
        }
        $i++;
    }
    return %tmplist;
}

# Carga la tabla arp
sub load_arp_list{
    my $arp = `arp -an`;
    return load_arp_desc($arp);
}

# Hace las comprobaciones
sub check_list{
    my $ip_list = $_[0];
    my $tmplist = $_[1];
    my $lastlist = $_[2];

    foreach my $ip (keys %$tmplist){
        my $mac = $tmplist->{$ip};
        # Si es un host nuevo
        if (!exists $ip_list->{$ip} ) {
            if ((!exists $lastlist->{$ip}) || ($cansino)){
                my $message = "Equipo desconocido en la red: $ip [$mac]";
                if ($mac ne "00:00:00:00:00"){ # Se suele utilizar para tapar
                                                                  # despues de arp spoofing.
                                                                  # No aporta nada
                    # Si la MAC está repetida, probablemente haya spoofing
                    foreach my $tmpip (keys %$ip_list){
                        if (($ip_list->{$tmpip} eq $mac) && ($tmpip ne $ip)){
                            $message .= ", posiblemente spoofeado desde $tmpip";
                        }
                    }
                }
                print "$message\n" if $verbose;
                my $notification = Gtk2::Notify->new("$appname", "$message","$app_icon");
                $notification->show();
            }
        }
        else{
            # Si cambio la MAC
            if ($ip_list->{$ip} ne $mac){
                if (($lastlist->{$ip} ne $mac)||($cansino)){
                    my $message = "La MAC de $ip ha cambiado de [".$lastlist->{$ip}."] a [".$mac."]";
                    if ($mac ne "00:00:00:00:00"){ # Se suele utilizar para tapar
                                                   # despues de arp spoofing.
                                                   # No aporta nada
                        # Si la MAC está repetida, probablemente haya spoofing
                        foreach my $tmpip (keys %$ip_list){
                            if (($ip_list->{$tmpip} eq $mac) && ($tmpip ne $ip)){
                                $message .= ", posiblemente spoofeado desde $tmpip";
                            }
                        }
                    }
                    print "$message\n" if $verbose;
                    my $notification = Gtk2::Notify->new("$appname", "$message","$app_icon");
                    $notification->show();
                }
            }
        }
    }
}

my %ip_list;
if ($file eq ""){
    if ($arp_fill){
        print STDERR "LLenando lista arp... " if $verbose;
        fill_arp_table;
        print STDERR "[OK]\n" if $verbose;
    }
    print STDERR "Leyendo tabla arp... " if $verbose;
    %ip_list = load_arp_list;
}
else{
    local $/=undef;
    open MYFILE, "$file" or die "Couldn't open file: $!";
    binmode MYFILE;
    $arp = <MYFILE>;
    close MYFILE;
    %ip_list = load_arp_desc("$arp");
}
print STDERR "[OK]\n" if $verbose;

my $lastlist = \%ip_list;
while (1){
    if ($arp_fill){
        fill_arp_table;
    }
    my %tmplist = load_arp_list;
    check_list(\%ip_list,\%tmplist,$lastlist);
    $lastlist = \%tmplist;

    sleep $sltime;
}

---

Fortunes con javascript y perl

¿Quien no conoce las miticas frases que suelen salir cuando se hace login en un sistema? (al menos en Slackware), tambien conocidas como Galletas de la suerte, fortunes, o algo asi...

¿Seria curioso poder usarlas tambien en una pagina web y que cada vez que carge la pagina salga una diferente, no?, pues no es demasiado dificil. Si las instalaste " sudo apt-get install fortune " puedes encontrar varias en /usr/share/games/fortunes/ , el formato que siguen es bastante sencillo, es texto plano, separando una "galleta" de otra con una linea con solo un %, seria algo asi:

Frase nº 1
%
Frase nº 2
%
Frase nº 3
...

Siendo tan sencillo el formato, se pueden aprovechar facilmente los archivos para cualquier cosa, por ejemplo (o para descargar [fort2js.pl] ):

---

#!/usr/bin/env perl

if ($#ARGV != 1){ # Se comprueba que se especificaron los dos archivos
    print "./fort2js.pl <fortune> <javascript>\n";
    exit(0);
}

$fname = $ARGV[0];
$foutname = $ARGV[1];

print "fort2js: ".$fname." -> ".$foutname."\r\n";

$fname = "<".$fname; # Archivo que se lee
$foutname = ">".$foutname; # Archivo que se escribe
$i = 0; # nº de fortunes
open (F, $fname);
open (O, $foutname);
print O "function get_cookie(v){var cookie = new Array(\""; # Cabecera de la funcion

while ($line = <F>){
    if (substr($line,0,1) eq "%"){ # Si es el fin de una fortune
        print O "\",\""; # Nueva posicion en el array
        $i++; # Una fortune mas
    }
    else{
        $line =~ s/\ \ /\ /g; # Se eliminan los dobles espacion
        $line =~ s/"/\\"/g; # Se escapan las comillas
        $line =~ s/\n/<br\/>/g; # Se cambian los saltos de linea por <br/>
        $line =~ s/\r//g; # Se eliminan los retornos de carro
        print O $line;
    }
}
print O "\");return cookie[v]}"; # Fin de la funcion
print O "function max_cookie(){return ".$i.";}"; # Funcion max_cookie()
close F, O;

---

Esto sirve para convertir un archivo de fortune's en uno de Javascript que permita usar las "galletas" con dos funciones, get_cookie(i) para recuperar la frase numero i y max_cookie() que servira para saber de cuantas "galletas" podemos hacer uso.
El archivo que resulta de hacer ./fort2js.pl <archivo de galletas> < archivo de salida> se puede usar muy facilmente, solo habria que subirlo a algun lugar, y añadir algo como esto al codigo HTML donde queramos que se muestre:

---

<div id="cookie">[Cargando...]</div>
<script type="text/javascript" src="http://sitio.donde.esta/archivo/donde/esta"></script>
<script type="text/javascript"><!--//

var rand=Math.floor(Math.random()*max_cookie());
document.getElementById('cookie').innerHTML=get_cookie(rand); //--></script>

---

Y ya estan listas las galletas de la fortuna :D

Hasta ahora!
[Referencias]
http://www.w3schools.com/js/default.asp
http://en.wikipedia.org/wiki/Fortune_(Unix)

Un par de scripts perl

Uno para lanzar comandos de consola/programas como daemon (se usa como el comando time ):
./daemonize.pl [comando]
Por ejemplo, si queremos hacer un ./configure;make;make install...
./daemonize.pl "./configure;make;make install"
Daemonize

Y otro para extraer los elinks de una pagina web y pasarlos al aMule ( via comando ed2k ), con cambiar la funcion link_mngr , se puede adaptar para links http, o para usar otro comando: 
getMule

Suerte