Web Scraping con curl, lynx, wget

Para quien no sepa que es web scraping : http://es.wikipedia.org/wiki/Web_scraping

Para esto hay varias formas y lenguajes de como hacerlo,  en este post les comentaré sobre 3 soluciones para hacerlo en cualquier Linux desde terminal:

LYNX
Es un navegador web para la terminal sin soporte para javascript (AJAX)

lynx -dump "http://www.ejemplo.com/"

Si lo que quieres es obtener el codigo fuente completo de la pagina web, puedes usar la opción -source :

lynx -source "http://www.ejemplo.com/"

También puedes usar pipe "|" para usar programas como grep,sed,awk para obtener solo cierto contenido de la consulta web :

lynx -source "http://www.ejemplo.com/" | grep -o 'tu expresión regular' | sed 's/etiquetas html aqui//g'

También puedes redirigir la salida a un archivo (Recomendado para webservers con ASP) :

lynx "http://www.ejemplo.com/info?cld=312&aac=ugc" -dump > miarchivo.txt

CURL
Es una herramienta para transferir información de un servidor a otro (Está diseñado para trabajar sin intervención del usuario)

Obtienes el código completo de la pagina con:

curl "http://www.ejemplo.com/" 

Puedes agregar la opción -s para hacerlo en modo silencioso:

curl -s "http://www.ejemplo.com/"

También puedes redirigir la saida a un archivo:

curl -s "http://www.ejemplo.com/" > miarchivo.txt

Limitas la salida con expresiones regulares y sed,awk y grep :

curl -s "http://www.ejemplo.com/" | grep -o 'tu expresión regular'

WGET
Es una herramienta para descargar archivos en red/Internet el cual soporta http, https, ftp:

wget http://www.ejemplo.com

Puedes agregar la opción -q  para ejectuar wget en modo silencioso

wget -q http://www.ejemplo.com

También puees dirigir la salida a un archivo:

wget -q http://www.ejemplo.com > miarchivo.txt

Con estas tres herramientas se pueden hacer muchas cosas, ya depende de ti en que y como lo quieras usar.

Configurar virtual host en apache para correr scripts cgi con perl

Primero tenermos que tener instalado el modulo de perl para apache:

#apt-get install libapache2-mod-perl2 

y tener nuestro virtual host como esto:

  ServerAdmin webmaster@localhost
  ServerAlias miserver.local
  ServerName miserver
  ServerAdmin villatux@midominio.com.mx
  DocumentRoot /var/www/mivirtualhost/docs
  ErrorLog /var/www/mivirtualhost/logs/error.log
  CustomLog /var/www/mivirtualhost/logs/access.log combined

  
     Options FollowSymLinks
     AllowOverride None
   

   
     Options Indexes FollowSymLinks MultiViews
     AllowOverride None
     Order allow,deny
     allow from all
   

  Alias /app/ /var/www/mivirtualhost/docs/mi_app_perl/
  
  
    AllowOverride None
    Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
    AddHandler cgi-script .pl
    Order allow,deny
    allow from all
  

Es importante remarcar que el uso de la directiva Alias te permitirá acceder de manera sencilla a tu aplicación en PERL como en este ejemplo:

http://mipagina.com.mx/app/index.pl

O también podemos acceder sin usar el alias de esta manera:

http://mipagina.com.mx/miapp_perl/index.pl

Generador de diccionarios (Fuerza bruta)

Les comparto este generador de passwords de fuerza bruta que hice por si se ofrece :D . Opera de la siguiente forma:

1) asignas los caracteres con los cuales quieres generar las combinaciones
2) ejecutas el script de la siguiente forma:

./generador.sh passwords.txt

Y con esto se generará el archivo passwords.txt con todas las combinaciones que establecimos dentro del script.

NOTA:
* Entre más caracteres para combinar puede tardar semanas en generar tu diccionario ya que hace todas las combinaciones entre ellos
* Con el crackeo sucede de la misma forma, Puede tardar años ...
* Disculpen por la identación, no se refleja de forma correcta

#!/bin/bash

caracteres="a b c d e f g h i j k l m n ñ o p q r s t u v x y z 1 2 3 4 5 6 7 8 9 0" 

ndigitos=$(echo $caracteres | wc -w)
echo $ndigitos
if [ -z ${1} ]
then
 echo "     Uso: Falta el archivo de salida"
 echo " Ejemplo: $0 passwords.txt"
else
 cont0=0
 cont1=0
 cont2=0
 cont3=0
 cont4=0
 cont5=0
 cont6=0
 cont7=0
 cont8=0
  time for a in $caracteres
           do
               let cont0=cont0+1
        for b in $caracteres
        do
            let cont1=cont1+1
          for c in $caracteres
          do
              let cont2=cont2+1
            for d in $caracteres
            do
                let cont3=cont3+1
             for e in $caracteres
             do
                 let cont4=cont4+1
               for f in $caracteres
               do
                   let cont5=cont5+1
                 for g in $caracteres
                 do
                     let cont6=cont6+1
                   for h in $caracteres
                   do
                       if [ $cont2 -lt $ndigitos ]; then a="";  fi
                       if [ $cont3 -lt $ndigitos ]; then b="";  fi
                       if [ $cont4 -lt $ndigitos ]; then c="";  fi
                       if [ $cont5 -lt $ndigitos ]; then d="";  fi
                       if [ $cont6 -lt $ndigitos ]; then e="";  fi
                       if [ $cont7 -lt $ndigitos ]; then f="";  fi
                       if [ $cont8 -lt $ndigitos ]; then g="";  fi
                       let cont7=cont7+1
                       `echo "$a$b$c$d$e$f$g$h" >> ${1}`
                        echo "$a$b$c$d$e$f$g$h"
                  done
                 done
               done
             done
            done
          done
        done
      done
fi

Combinaciones sin repetición (script en bash)

Son los grupos que podemos hacer de entre m elementos tomados de n en n diferenciándose, un grupo de otro, en tener algún elemento distinto.

Si disponemos de los elementos: {a,b,c,d} y los tomamos de 2 en dos, los grupos que podemos formar de modo que cada grupo se diferencie de los demás en tener un elemento distinto son:

ab,ac,ad,bc,bd,cd  =  6 combinaciones

Lo mismo hace este script que hice para calcular las combinaciones que se realizarán para generar un diccionario de fuerza bruta para crackeo de accesos:

mi prueba inicial fue de letras minúsculas y números que dan un total de 36 dígitos , haciendo la combinación de 1 en 1  y la ejecución del script fué de la siguiente forma:

./script.sh 36 1

se envía el parámetro 36  y el parametro 1  indicando el total de numeros y de cuantos en cuantos va a ser las combinaciones .  de esta ejecución el resultado fue de 9003737871877668864 Combinaciones posibles para intentos de loggeo (Es por eso que entre más segura sea tu contraseña más difícil será el hackeo de la misma  :D )

Este script realiza algunas operaciones con factoriales en bash para calcular las combinaciones:

#!/bin/bash
# By, Oswaldo villa @villatux

# USO  ./script.sh 4 2
# Descripcion:  En este ejemplo queremos sacar cuantas combinaciones tenemos
# con 4 caracteres combinados de dos en dos

factorial=$1
res=1
while [ $factorial -gt 1 ]
 do
 let res=$res*$factorial
 let factorial-=1
done

factorial2=$2
res2=1
while [ $factorial2 -gt 1 ]
 do
 let res2=$res2*$factorial2
 let factorial2-=1
done
echo $1" digitos de "$2 "en "$2

let combinaciones=($res/$res2)/$res2
echo "Resultado : " $combinaciones "Combinaciones"

(Solucion) Al problema : "/bin/rm: Argument list too long"

EL PROBLEMA
Me ha pasado en ocaciones cuando quiero borrar miles de archivos dentro de un directorio (rm /mi/directorio/*"  obtengo el error:

/bin/rm: Argument list too long

Esto nos indica que la cantidad de archivos es muy grande y no puede gestionarla (wtf?)

LA CAUSA
La causa es una limitación del buffer de la función exec() la cual es de 128K, y esta funcion está utilizada en muchos otros programas como , ls, rm, du ...

El limite afecta la funcion execve() del kernel, la cual es usada por  las funciones exec() (execl, execlp, execle,etc). La funcion trabaja creando un buffer de 128k al final del espacio de memoria y copiando el comando y el entorno para el nuevo proceso en este espacio. En ese momento el kernel carga el nuevo programa en memoria, configura sus punteros argv y endv, y salta al punto de entrada del programa. El mensaje de error "argument list too long" es causado por el codigo de error !E2BIG, siendo devuelto por la funcion execve(), cuando es incapaz de introducir el argumento y entorno suministrados dentro del buffer de 128k.

LA SOLUCIÓN 
La técnica que soluciona esto es seleccionar archivo por archivo . pensarías que esto no es viable ya que tendrías que borrar miles de archivos a mano y tardarías años en realizar este proceso

Para borrar de uno en uno sin hacerlo manualmente podemos hacer un bucle for (ciclo) que seleccione a cada archivo y le aplique el comando rm

for i in ls /mi/directorio/*; do rm -v $i -f; done

También se puede haciendo una búsqueda de todos los archivos  y aplicar a cada uno que vaya encontrando el comando rm

find . -name '*' | xargs rm

y listo, con esto podemos  borrar de manera masiva miles de archivos sin problemas :D