El rincón de Zerial » bash

Búsqueda de servicios DNS con Transferencia de Zona abierta (AXFR)

Zerial — Thu, 11 Aug 2011 18:00:39 +0000

Ya vimos que los servidores mal configurados que permiten realizar transferencias de zona sin restricciones desde cualquier IP son muchos.

Para saber si un servidor DNS es “vulnerable” a este tipo de ataque usamos la herramienta dig, primero obtenemos los dns que estan asociados al dominio, para este ejemplo usaremos el dominio zerial.org.

$ dig NS zerial.org ; < <>> DiG 9.7.3 < <>> NS zerial.org ;; global options: +cmd ;; Got answer: ;; ->>HEADER< <- opcode: QUERY, status: NOERROR, id: 64152 ;; flags: qr rd ra; QUERY: 1, ANSWER: 5, AUTHORITY: 0, ADDITIONAL: 6


;; QUESTION SECTION:

;zerial.org.			IN	NS

;; ANSWER SECTION: zerial.org. 86400 IN NS ns1.linode.com. zerial.org. 86400 IN NS ns3.linode.com. zerial.org. 86400 IN NS ns2.linode.com. zerial.org. 86400 IN NS ns5.linode.com. zerial.org. 86400 IN NS ns4.linode.com.

Ya tenemos la lista de los servidores dns de zerial.org, para probar la transferencia de zona cambiamos NS por AXFR y forzamos que use el DNS que nosotros elijamos, en este caso probaremos ns3.linode.com:

$ dig AXFR zerial.org @ns3.linode.com

; < <>> DiG 9.7.3 < <>> AXFR zerial.org @ns3.linode.com ;; global options: +cmd ; Transfer failed.

Failed. No hemos logrado transferir la zona desde ns3.linode.com, lo que nos indica que aparentemente se encuentra bien configurado.
Otro ejemplo usando un dominio que sepamos que tiene esta falla: finanzas.gov.ar.
Obtenemos los dos:

$ dig NS finanzas.gov.ar


; < <>> DiG 9.8.0-P4 < <>> NS finanzas.gov.ar

;; global options: +cmd

;; Got answer:

;; ->>HEADER< <- opcode: QUERY, status: NOERROR, id: 38476

;; flags: qr rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 2
;; QUESTION SECTION:

;finanzas.gov.ar.		IN	NS

;; ANSWER SECTION: finanzas.gov.ar. 7006 IN NS ns3.zoneedit.com. finanzas.gov.ar. 7006 IN NS ns9.zoneedit.com.

Probamos el segundo dns, ns9.zoneedit.com.

$ dig AXFR finanzas.gov.ar @ns9.zoneedit.com

; < <>> DiG 9.8.0-P4 < <>> AXFR finanzas.gov.ar @ns9.zoneedit.com ;; global options: +cmd finanzas.gov.ar. 7200 IN SOA ns3.zoneedit.com. soacontact.zoneedit.com. 2011266765 2400 360 1209600 300 finanzas.gov.ar. 7200 IN NS ns3.zoneedit.com. finanzas.gov.ar. 7200 IN NS ns9.zoneedit.com. finanzas.gov.ar. 7200 IN A 201.253.123.35 finanzas.gov.ar. 7200 IN MX 10 ALT1.ASPMX.L.GOOGLE.COM. finanzas.gov.ar. 7200 IN MX 10 ALT2.ASPMX.L.GOOGLE.COM. finanzas.gov.ar. 7200 IN MX 0 ASPMX.L.GOOGLE.COM. finanzas.gov.ar. 7200 IN MX 20 ASPMX2.GOOGLEMAIL.COM. finanzas.gov.ar. 7200 IN MX 20 ASPMX3.GOOGLEMAIL.COM. finanzas.gov.ar. 7200 IN MX 20 ASPMX4.GOOGLEMAIL.COM. finanzas.gov.ar. 7200 IN MX 20 ASPMX5.GOOGLEMAIL.COM. mail.finanzas.gov.ar. 7200 IN CNAME ghs.google.com. googleffffffff85ca3fa2.finanzas.gov.ar. 7200 IN CNAME google.com. asignaciones.finanzas.gov.ar. 7200 IN A 186.136.205.252 docs.finanzas.gov.ar. 7200 IN CNAME ghs.google.com. www.finanzas.gov.ar. 7200 IN A 201.253.123.35 mapas.finanzas.gov.ar. 7200 IN A 201.253.123.35 finanzas.gov.ar. 7200 IN SOA ns3.zoneedit.com. soacontact.zoneedit.com. 2011266765 2400 360 1209600 300 ;; Query time: 355 msec ;; SERVER: 66.240.231.42#53(66.240.231.42) ;; WHEN: Thu Aug 11 13:49:31 2011 ;; XFR size: 18 records (messages 18, bytes 1138)

La transferencia de zona se hizo de forma exitosa.

Para poder analizar de forma automatica un listado de dominios, hice un script en bash que usa DIG para obtener los dns de cada dominio y prueba realizar AXFR por cada dominio en todos sus dns.

#!/bin/bash

digcmd=$(which dig)
domain=$1
echo -n "[+] Getting NS domains from $1 ..."
ns_domains=$(dig NS $domain @4.2.2.2|grep ^$domain|awk {'print $5'}|sed 's/.$//g')
echo -e "\t[OK]"
for ns in $ns_domains; do echo "[-] Found: "$ns; done
for ns in $ns_domains
do
	echo -n "Trying Zone Transfer from $ns: "
	$digcmd AXFR $domain @$ns|egrep 'Transfer failed|timed out|end of file'>/dev/null
	if [ $? -eq 1 ]
	then
		echo -e "\tSuccess."
	else
		echo -e "\tFail."
	fi
done

La forma de ejecucion es:

]$ sh zonetransfer.sh finanzas.gov.ar [+] Getting NS domains from finanzas.gov.ar ... [OK] [-] Found: ns9.zoneedit.com [-] Found: ns3.zoneedit.com Trying Zone Transfer from ns9.zoneedit.com: Success. Trying Zone Transfer from ns3.zoneedit.com: Success.

Nos indica que es posible realizar una transferencia de zona desde ns3.zoneedit.com y ns9.zoneedit.com para el dominio finanzas.gov.ar.
Tambien podemos pasarle un archivo que contenga una lista de dominios que queramos analizar de forma masiva. Por ejemplo, tenemos un archivo llamado dominios.txt con los dominios:
finanzas.gov.ar transparencia.cl gobierno.cl argentina.gov.ar gobierno.es microsoft.com

Ejecutamos:

$ for dom in $(cat dominios.txt); do sh zonetransfer.sh $dom; done [+] Getting NS domains from finanzas.gov.ar ... [OK] [-] Found: ns9.zoneedit.com [-] Found: ns3.zoneedit.com Trying Zone Transfer from ns9.zoneedit.com: Success. Trying Zone Transfer from ns3.zoneedit.com: Success. [+] Getting NS domains from transparencia.cl ... [OK] [-] Found: ns02.000webhost.com [-] Found: ns01.000webhost.com Trying Zone Transfer from ns02.000webhost.com: Fail. Trying Zone Transfer from ns01.000webhost.com: Fail. [+] Getting NS domains from gobierno.cl ... [OK] [-] Found: ga.interior.gov.cl [-] Found: gb.interior.gov.cl [-] Found: ns1.presidencia.cl Trying Zone Transfer from ga.interior.gov.cl: Fail. Trying Zone Transfer from gb.interior.gov.cl: Fail. Trying Zone Transfer from ns1.presidencia.cl: Success. [+] Getting NS domains from argentina.gov.ar ... [OK] [-] Found: nsii.arcert.gov.ar [-] Found: nsii.sgp.gov.ar Trying Zone Transfer from nsii.arcert.gov.ar: Fail. Trying Zone Transfer from nsii.sgp.gov.ar: Fail. [+] Getting NS domains from gobierno.es ... [OK] [-] Found: sun.rediris.es [-] Found: chico.rediris.es [-] Found: dns1.mpr.es [-] Found: dns2.mpr.es Trying Zone Transfer from sun.rediris.es: Fail. Trying Zone Transfer from chico.rediris.es: Fail. Trying Zone Transfer from dns1.mpr.es: Fail. Trying Zone Transfer from dns2.mpr.es: Fail. [+] Getting NS domains from microsoft.com ... [OK] [-] Found: ns3.msft.net [-] Found: ns4.msft.net [-] Found: ns1.msft.net [-] Found: ns2.msft.net [-] Found: ns5.msft.net Trying Zone Transfer from ns3.msft.net: Fail. Trying Zone Transfer from ns4.msft.net: Fail. Trying Zone Transfer from ns1.msft.net: Fail. Trying Zone Transfer from ns2.msft.net: Fail. Trying Zone Transfer from ns5.msft.net: Fail.

Ya tenemos el output del script, donde nos dice que los dns de finanzas.gov.ar y uno de gobierno.cl permite AXFR.

[PoC] Cifrado del historial de bash (.bash_history)

Zerial — Thu, 03 Feb 2011 14:18:16 +0000

El otro día, en mis momentos de ocio, se me ocurrio buscar una forma de cifrar el historial de comandos que guarda bash. Hay servidores que sólo tenemos -o hemos ganado- acceso como usuarios, y no nos gusta que el administrador (root) vea lo que hacemos o los comandos que hemos ejecutado. Existen varias formas de ir contra eso, por ejemplo eliminar el bash_history o bien editarlo cada vez que hacemos algo que no queremos que sepan. Esta forma es un poco mas rebuscada y busca cifrar mediante GPG el historial, de manera tal que el root no podrá leer lo que dice el archivo.

La logica es bastante simple:

Cuando ingresamos (login) a nuestra cuenta desciframos el bash history usando nuestra clave privada
Cuando salimos (logout) ciframos el archivo con nuestra clave publica.

Para lograrlo vamos a necesitar tener una clave gpg y configurar el comportamiento del login y logout con unos scripts que les mostraré a continuación.

Vamos a usar el usuario “usuario” de prueba. Primero, creamos la clave GPG:

[usuario@belcebu ~]$ gpg --gen-key

En mi caso, generé una clave de 2048 bits con el UID Usuario de Prueba (Historial Cifrado)

Editamos el archivo .bashrc y agregamos las siguientes lineas

gpg -d -r "Usuario de Prueba (Historial Cifrado) " $HISTFILE >$HOME/._bash_history
mv $HOME/._bash_history $HISTFILE

Luego creamos el siguiente script, lo llamaremos .crypt_history.sh:

#!/bin/bash

sleep 2;
gpg -e -r "Usuario de Prueba (Historial Cifrado) " $HOME/.bash_history
mv $HOME/.bash_history.gpg $HOME/.bash_history

Y agregamos la línea

nohup sh $HOME/.crypt_history.sh &

Al archivo .bash_logout

De esta forma, al ingresar como usuario se ejecutará automaticamente el comando que descifra el .bash_history y cuando salimos, será cifrado.

[root@belcebu ~]# cat /home/usuario/.bash_history
zå¬ÈùrèÿJx¨¸QÕ{¥ ±5#ºcHb¶÷çFÀ®ú4ÞÃØÝxbZúF çïkågµNÒ¸5îÅ£ ³KÝ0U¯º±YHú#ÙÞ©Ù&¶þ¢Lyug
þ
ÓL¹ðú®&°í¾vI?V\9Õx’{4hÐaÜdÛPÅ©²¦öcñm¾O’µÔ2Éªðá¸ó²ëÕÁ²NªOÈ`A²U´¬Uîkï
u:÷ÛASþdè¶]1ê¬GBXLT¥3þ0Ñ_8uóâEQ¯`.¾Kn3AÒy»çÌ¡øyà$ßÙkíKzÜ§¸×’Øx¿S¥
ÂâÆâveó´Î/¸)aýü4µÅ:mCú}1Á$äãÑõæ>¥ÈM9IÈÛ³=PË^q{Ñ
3º ë]Å¿74ë*Ø
Öuå¦
[root@belcebu ~]#

Y si ingresamos como usuario …

gpg: encrypted with 2048-bit RSA key, ID C8F972E8, created 2011-02-03
“Usuario de Prueba (Historial Cifrado) ”
[usuario@belcebu ~]$ history
1 cat nohup.out
2 vim .bashrc
3 vim .crypt_history.sh
4 ls
5 history
6 ls -lia
7 history
[usuario@belcebu ~]$

Existe un pequeño detalle, es que el root puede ingresar como usuario y de esta forma poder el historial. Pero para esto, nosotros debemos proteger nuestro cifrado con un passphrase, asi cuando el root quiera ingresar como usuario, éste le pedira una clave para poder descifrar el archivo bash_history, si el root no maneja esa clave no podrá ver lo que hay.

Esto es solo una prueba de concepto (PoC), se puede hacer cualquier modificación a los scripts usados para adaptarlos a otras necesidades y obviamente mejorar el cifrado mismo del bash_history.
Nota: Existen varios peros en esta forma de cifrar, que obviamente pueden ser mejoradas, por ejemplo, podria existir algun conflicto cuando se inicia mas de una vez la sesion del usuario.

[Tip] AND (&&) y OR (||) en bash

Zerial — Fri, 17 Dec 2010 01:24:05 +0000

Parece algo muy simple, pero estoy seguro que muchos no lo saben: Usar los operadores lógicos && y || al momento de crear scripts o ejecutar comandos en bash.
Podemos condicionar la ejecución de un comando en función de otro; por ejemplo, si falla el primer comando, entonces no ejecuto el segundo, o bien, si no se ejecuta el primero entonces ejecuto el segundo, dependiendo de lo que necesitemos.
Ejemplos:

Ejecutar el comando2 solo si se ejecuta el comando1:
$ comando1 && comando2

Ejecutar el comando2 solo si no se ejecuta el primero
$ comando1 || comando2

Sería así:
[zerial@balcebu ~]$ comando1 || echo "Como comando1 no existe, entonces ejecuto el echo" bash: comando1: command not found Como comando1 no existe, entonces ejecuto el echo [zerial@balcebu ~]$ echo "El primer echo se ejecuta, pero el segnudo no" || echo "Como comando1 no existe, entonces ejecuto el echo" El primer echo se ejecuta, pero el segnudo no [zerial@balcebu ~]$

Es muy útil cuando queremos programar scripts para ejecutar tareas condicionadas a otros comandos.

Esteganografía: Ofuscación de archivos (parte 3)

Zerial — Thu, 02 Dec 2010 15:59:06 +0000

Luego de haber presentado la primera y segunda parte de este post, les presentaré un script que automatiza el proceso de “esconder” y “encontrar” el archivo y además mostrar como podemos solucionar el problema de los “bytes” para poder separar el archivo original. Es un simple script en bash, que usa los mismos comandos y técnicas mostradas en los post anteriores, con comandos basicos como cat, split, etc. Para “marcar” la división entre el archivo oculto dentro del archivo original lo haremos de una forma bien simple.

Marcar la división entre los archivos

Para saber exactamente el byte donde debemos cortar con split el archivo para poder separarlo, vamos a agregar, al final de nuestro archivo ofuscado, una linea en texto plano con un numero X = bytes. Puede sonar absurdo por lo simple que es, pero es posible.

¿Cómo hacerlo? Es muy simple, tambien usamos echo:
$ echo XXXX >>archivo_ofuscado.jpg"
Donde XXXXX corresponde a la cantidad de bytes que la puedes saber por ejemplo con “ls -l” sobre el archivo.

Entonces el procedimiento para “separar” los archivos sería leer la última línea del archivo y hacer un split -b XXXX.

Ya habiendo aprendido a ocultar y a encontrar archivos, podemos automatizarlo y usar el siguiente script:

esconder.sh

#!/bin/bash

if [ $# -eq 3 ]; then
        separador=$(ls -l $1|awk -F ' ' '{print $5}');
        cat $1 $2 > $3
        echo -e "\n$separador" >>$3
        echo "Archivo $3 creado.";
else
        echo "Sintaxis: $0 archivo1 archivo2 salida"
        exit 1;
fi

encontrar.sh

#!/bin/bash

if [ $# -eq 1 ]; then
        separador=$(tail -1 $1);
        sed -i 's/^$separador$//g' $1
        split -b $separador $1
else
        echo "Sintaxis: $0 archivo"
fi

Pueden descargar los scripts desde aca:
* esconder.sh.gz (4Kb)
* encontrar.sh.gz (4Kb)

Como pueden ver, para esconder archivos y poder “separarlos”, ya sea para enviar informacion ilegible o escondida a otras personas basta con saber usar algunos comandos basicos de unix. Si bien no es una forma an “profesional” de hacerlo, es muy simple y no se necesita un programa robusto, simplemente un par de líneas en bash.

Esteganografía: Ofuscación de archivos (parte 2)

Zerial — Fri, 19 Nov 2010 14:10:22 +0000

Luego de haber enseñado como ofuscar un archivo dentro de otro, llegó el momento de saber como “separarlos”. En la primera parte, hubo comentarios de quienes tenian problemas porque se corrompía el archivo y no todas las versiones de unrar o unzip lo podían descomprimir, ya que obviamente, el archivo tiene muchos bits y bytes extras que no corresponden al zip, al rar o al archivo que escondimos. Una vez separado el archivo que hemos escondido, evitaremos todos estos problemas y tendremos nuestro archivo íntegro.

Para separar el archivo vamos a usar el comando split, que nos permite “dividir” o “cortar” un archivo por líneas, bytes, etc. En este caso, separaremos por bytes el archivo.
La sintaxis de split para separar un archivo es tan simple como:

$ split --bytes=XXX archivo
o tambien
$ split -b XXX archivo

De esta forma, el split separará el archivo cada XXX bytes, creando archivos de la forma xab, xac, xad, … xaN.
Ejemplo:
[zerial@balcebu ejemplo_split]$ du -sh archivo.jpg 48K archivo.jpg [zerial@balcebu ejemplo_split]$ split -b 10000 archivo.jpg [zerial@balcebu ejemplo_split]$ ls archivo.jpg xaa xab xac xad xae [zerial@balcebu ejemplo_split]$ du -csh * 48K archivo.jpg 12K xaa 12K xab 12K xac 12K xad 8.0K xae 104K total [zerial@balcebu ejemplo_split]$

Para poder separar el archivo ofuscado, vamos a necesitar saber de antemano el tamaño del archivo original, para poder separarlo por esa cantidad de bytes.

Siguiendo con el mismo ejemplo del primer post, aquí vamos:

Tenemos los tres archivos; el archivo principal, el archivo que queremos ofuscar y el archivo ya ofuscado
[zerial@balcebu ofuscar]$ ls -l total 816 -rw-r--r-- 1 zerial users 408482 Oct 27 09:54 archivo.zip -rw-r--r-- 1 zerial users 414523 Oct 27 09:54 archivo_ofuscado.jpg -rw-r--r-- 1 zerial users 6041 Oct 27 09:52 dummie.jpg [zerial@balcebu ofuscar]$

Nuestro fin es separar el archivo “archivo.zip” de “archivo_ofuscado.jpg”.
[zerial@balcebu ofuscar]$ mv archivo_ofuscado.jpg separacion/ [zerial@balcebu ofuscar]$ cd separacion/ [zerial@balcebu separacion]$ ls archivo_ofuscado.jpg [zerial@balcebu separacion]$

Vemos el tamaño en bytes del archivo principal “dummie.jpg”
-rw-r--r-- 1 zerial users 6041 Oct 27 09:52 dummie.jpg

6041 bytes. Por tanto, tenemos que decirle a split, que nos divida el archivo_ofuscado.jpg en pequeños trozos de 6041 bytes cada uno.

[zerial@balcebu separacion]$ split -b 6041 archivo_ofuscado.jpg [zerial@balcebu separacion]$ ls -l total 956 -rw-r--r-- 1 zerial users 414523 Oct 27 09:54 archivo_ofuscado.jpg -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xaa -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xab -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xac -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xad -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xae -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xaf -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xag -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xah -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xai -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xaj -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xak -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xal -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xam -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xan -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xao -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xap -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xaq -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xar -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xas -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xat -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xau -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xav -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xaw -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xax -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xay -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xaz -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xba -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbb -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbc -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbd -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbe -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbf -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbg -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbh -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbi -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbj -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbk -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbl -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbm -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbn -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbo -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbp -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbq -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbr -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbs -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbt -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbu -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbv -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbw -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbx -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xby -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xbz -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xca -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xcb -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xcc -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xcd -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xce -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xcf -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xcg -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xch -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xci -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xcj -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xck -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xcl -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xcm -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xcn -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xco -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 xcp -rw-r--r-- 1 zerial users 3735 Nov 19 10:57 xcq [zerial@balcebu separacion]$

Ya tenemos dividido el archivo_ofuscado en pequeños trozos. Como nuestro archivo dummie.jpg teina un tamaño de 6041 bytes y es este archivo el que está por sobre el archivo ofuscado, el primer archivo que nos extrajo split corresponde a dummie.jpg; por tanto, renombramos xaa a dummie.jpg y concatenamos todos los demas archivos y lo llamamos archivo.zip (corresponde a nuestro archivo ofuscado)

[zerial@balcebu separacion]$ mv xaa dummie.jpg [zerial@balcebu separacion]$ cat x* >archivo.zip [zerial@balcebu separacion]$ rm x* [zerial@balcebu separacion]$ ls -l total 816 -rw-r--r-- 1 zerial users 408482 Nov 19 10:59 archivo.zip -rw-r--r-- 1 zerial users 414523 Oct 27 09:54 archivo_ofuscado.jpg -rw-r--r-- 1 zerial users 6041 Nov 19 10:57 dummie.jpg [zerial@balcebu separacion]$

Con esto ya hemos extraído nuestro archivo ofuscado. Para comparar que está íntegro y que realmente corresponde al original, comparemos los md5:

5c29dbb3975a5ffe31768b79548e1884 archivo.zip ded467af5a22134c44da18bc8d4fed1b dummie.jpg 5c29dbb3975a5ffe31768b79548e1884 ../archivo.zip ded467af5a22134c44da18bc8d4fed1b ../dummie.jpg

Los dos primeros archivos corresponden a los archivos extraídos con split y los dos últimos a los archivos originales. Los md5 coinciden, por lo que lo hemos conseguido. Si ahora unzipeamos nuestro archivo.zip, no nos mostrará ningun warning, lo mismo pasara con winrar, etc.

[zerial@balcebu separacion]$ unzip archivo.zip Archive: archivo.zip creating: tipografias/ inflating: tipografias/Aller_Bd.ttf inflating: tipografias/Aller_BdIt.ttf inflating: tipografias/Aller_It.ttf inflating: tipografias/Aller_Lt.ttf inflating: tipografias/Aller_LtIt.ttf inflating: tipografias/Aller_Rg.ttf inflating: tipografias/AllerDisplay.ttf [zerial@balcebu separacion]$

Sin warnings ni errores.

Script monitor de sistemas de archivos y particiones

Zerial — Wed, 14 Jul 2010 19:15:42 +0000

Existen herramientas que nos permiten monitorear distintas cosas en un parque de servidores, como Zabbix, Nagios, etc. Pero hay veces que no es posible, ya sea por recursos o por tiempo, implementar una solución de monitoreo de alto nivel, por lo que recurrimos a los scrtips. Estoy seguro que bash, las llaves publicas y privadas para la autentificación, y cron son unos de nuestros mejores amigos al momento de querer monitorear o administrar máquinas simultaneamente.

Con du podemos saber el uso de disco de nuestro sistema y con un pequeño script en bash podemos mejorar la salida de este comando.

ssh 10.0.0.56 -p5022 "df -hPl"|awk -F ' ' '{print $1,$4,$6,$5}' |egrep -v "Avail|Dispo|Use|Use"

Esto nos devuelve en 4 columnas el dispositivo, espacio disponible, punto de montaje y porcentaje usado.

Algo similar a:

/dev/mapper/VolGroup_25980-LogVol1 3.5G / 75%
/dev/sda1 80M /boot 16%
none 16G /dev/shm 0%
/dev/mapper/VolGroup_25980-LogVolHome 30G /home 69%
/dev/mapper/VolGroup_25980-LogVol2 4.6G /tmp 1%
/dev/mapper/VolGroup_25980-LogVol5 6.6G /usr 29%
/dev/mapper/VolGroup_25980-LogVol4 14G /var 87%
/dev/mapper/VolGroup_25980-mysql 7.0G /var/lib/mysql 63%

Mi idea es trabajar con threshold (umbral) y gatillar eventos según el umbral alcanzado. Por ejemplo, con un threshold del 80% asociado al porcentaje utilizado, que envie emails de “advertencias” y con el 90% notificaciones de “criticidad del sistema de archivos”. Lo que querìa lograr era que todos los dias se monitoreen los sistemas de archivos, generando reportes diarios de los sistemas criticos y, semanalmente, un reporte general, donde me muestre detalladamente los “normales”, “advertencias” y los “criticos”. La salida esperada es algo asi:

[+] Server: x.x.x.x (x.hostname)
[-] [Dev:/dev/hda2] [Mount:/] [Free:4.2G] [Used:5%]

[-] [Dev:/dev/hda1] [Mount:/boot] [Free:83M] [Used:11%]

[-] [Dev:/dev/hda3] [Mount:/home] [Free:3.6G] [Used:19%]

[-] [Dev:/dev/hda6] [Mount:/tmp] [Free:1.7G] [Used:1%]

[-] [Dev:/dev/hda5] [Mount:/usr] [Free:8.6G] [Used:3%]

[-] [Dev:/dev/hda7] [Mount:/var] [Free:12G] [Used:21%]

No critical filesystems

[...] cuando no hay sistemas de archivos criticos y,

[+] Server: y.y.y.y (y.hostname)
[-] [Dev:/dev/mapper/VolGroup00-LogVol00] [Mount:/] [Free:16G] [Used:14%]

[-] [Dev:/dev/sda1] [Mount:/boot] [Free:80M] [Used:15%]

[-] [Dev:/dev/shm] [Mount:/dev/shm] [Free:2.0G] [Used:0%]

[-] [Dev:/dev/mapper/VolGroup00-LogVol02] [Mount:/var] [Free:7.4G] [Used:74%]

[-] [Dev:/dev/mapper/VolGroup00-LogVol03] [Mount:/backup] [Free:13G] [Used:66%]

[-] [Dev:/dev/mapper/VolGroup00-LogVol04] [Mount:/home] [Free:6.6G] [Used:93%] [***CRITICAL***]

[-] [Dev:/dev/mapper/VolGroup00-LogVol05] [Mount:/usr/local] [Free:7.3G] [Used:89%] [***WARNING***]

cuando hay criticos y cuando hay emergencias, es decir, cuando se alcanza el umbral del 90% y 80%, respectivamente.

El script que hice es el siguiente:

#/bin/bash -e
warning_threshold="80%"
critical_threshold="90%"

warnings=0;
critical=0;
for host in $(grep -v ^# ips.txt);
do
	critical_count=0;
	hostname=$(echo -n $host|cut -f1 -d ":")
        ip=$(echo -n $host|cut -f2 -d ":")
        port=$(echo -n $host|cut -f3 -d ":")
	echo "\n[+] Server: $ip ($hostname)"
	filesystems=$(ssh $ip -p$port "df -Phl"|egrep -v 'Avail|Dispo|tmpfs|udev|Uso|Use'|awk -F ' ' '{print $6}');
	for FS in $filesystems;
	do
		alert="";
		temp=$(ssh $ip -p$port "df -hPl $FS"|awk -F ' ' '{print $1,$4,$6,$5}' |egrep -v 'Avail|Dispo|Uso|Use');
		dev=$(echo $temp |cut -f1 -d " ");
		mountpoint=$(echo $temp |cut -f3 -d " ");
		size=$(echo $temp |cut -f2 -d " ");
		used=$(echo $temp |cut -f4 -d " ");
		_wthreshold=$(echo -n $warning_threshold |sed 's/%//g');
		_cthreshold=$(echo -n $critical_threshold |sed 's/%//g');
		_used=$(echo -n $used |sed 's/%//g');
		case "$1" in
			weekly)
				if [ $_used -gt $_wthreshold ]; then
                                        alert="[***WARNING***]"; warning=$(expr $warning + 1);
                                fi
				if [ $_used -gt $_cthreshold ]; then
					alert="[***CRITICAL***]"; critical=$(expr $critical + 1);
				fi
				echo "[-] [Dev:$dev] [Mount:$mountpoint] [Free:$size] [Used:$used] $alert";
				echo "";
			;;
			daily)
                                if [ $_used -gt $_cthreshold ]; then
                                        alert="[***CRITICAL***]";
					critical_count=$(expr $critical_count + 1);
                                	echo "[-] [Dev:$dev] [Mount:$mountpoint] [Free:$size] [Used:$used] $alert";
					echo "";
				fi
			;;
		esac
	done
	if [ $critical_count -eq 0 ]; then
		echo "No critical filesystems"
		critical_count=0;
	fi
done
if [ "$1" = "weekly" ]; then
	echo "________________"
	echo "Warnings: $warning\t|";
	echo "Criticals: $critical\t|";
fi

Para que el script funcione, es necesario que en la misma ruta donde se encuentra, exista el archivo ips.txt que debe tener, bajo la sintaxis hostname:ip:port, la información para que el script se conecté por ssh a las máquinas. Para que sea más dinámico y no requiera la intervención de un humano, la máquina donde se ejecutará el script debe tener una llave privada cuya llave publica esté repartida en los servidores que se desean monitorear.
El script necesita un argumento para funcionar, puede ser “weekly” o “daily”, segun se necesite. Con daily el script genera reportes donde mostrará solamente los criticos, mientras que con weekly hará un reporte general.

En el cron tengo agregado que todos los dias a las 9AM, haga un reporte diario y todos los lunes a las 8AM uno general (weekly) y los envie por correo a los responsables.

8 * * 1 cd /root/du_alert; sh alert.sh weekly |mail -s “Weekly Disk Usage Status” encargado@dominio.cl — -F “System Administrator”
0 9 * * * cd /root/du_alert; sh alert.sh daily |mail -s “Daily Disk Usage Status” encargado@dominio.cl — -F “System Administrator”

Cosas que encontramos en los archivos .bash_history

Zerial — Thu, 29 Apr 2010 14:00:47 +0000

El otro día, haciendo revisión y limpieza en los servidores, me dediqué por un par de minutos a revisar los archivos .bash_history de algunos usuarios y me encontre con varias sorpresas, desde cosas chistosas hasta problemas críticos de seguridad. Los usuarios son muy buenos para inventar comandos, probar cosas, inventar pasarle parametros a los comandos, etc, es muy chistoso ver como se pasean por mil directorios antes de llegar a donde quieren llegar, como visualizan los archivos o como encuentran lo que buscan. Está bien que los usuarios son solo usuarios, no deberían por qué saber ni ser expertos en ejecutar comandos unix en un prompt, pero aun asi sigue pareciendo cómico para uno ver cómo lo hacen.
Para quienes no saben, el archivo .bash_history corresponde a un archivo de registro o logs que guarda los comandos ejecutados en bash por un usuario en particular, cuando un usuario ingresa vía ssh a un sistema por ejemplo, ejecuta los típicos comandos “dir, cd, ls” y estos quedan registrados.

Lo más comun, y que me da muca risa y aveces rabia, y me desespera un poco, es ver como los usuarios avanzan lentamente, directorio por directorio, hasta llegar a la destino final. Por ejemplo:

$ cd / $ cd home $ cd usuario $ cd public_html $ cd includes

En lugar de ejecutar directamente
$ cd /home/usuario/public_html/includes

Y peor aun, hay veces que el usuario es inseguro y prefiere verificar si lo hizo bien y termina su caminata por los directorios haciendo un “pwd”:

$ cd / $ cd home $ cd usuario $ cd public_html $ cd includes $ pwd /home/usuario/public_html/includes $

Hay algo que me desespera aun mas, es cuando el usuario tiene la necesidad de listar el contenido de CADA directorio:

$ cd / $ ls -l $ cd home $ ls -l $ cd usuario $ ls -l $ cd public_html $ ls -l $ cd includes $ pwd /home/usuario/public_html/includes $ ls -l

Para los que no saben, para esto existe un truco (tip!), no digo que se aprendan los directorios de memoria, pero pueden ejecutar todo en una sola linea, por ejemplo, cuando escriben / pueden presionar tabular dos veces y automaticamente aparecerá el listado de archivos y directorios dentro de /. Asi mismo, si escriben /home/ y dos veces tabular, veran todo el contenido de /home, sin tener que ejecutar cd /home, presionar enter y luego un ls.

Otra cosa que es muy comun, aunque no lo crean, es encontrar las passwords de las bases de datos, especialmente de MySQL. La gente está acostumbrada a ejecutar el comando mysql para conectarse a la base de datos pasandole como parametro el usuario y la password

$ mysql -uproduccion -p4gSg4ws -hlocalhost mydatabase mysql>

Tambien usan esta misma tecnica para generar los típicos respaldos usando mysqldump.

$ mysqldump -uproduccion -p4gSg4ws -hlocalhost mydatabase >>mydatabase.sql

Obviamente esto es un problema de seguridad, ya sea porque no se educó bien al usuario o simplemente porque no existen medidas de seguridad dentro del contexto donde se está ejecutando este tipo de comandos.

Tambien es muy usual encontrar a usuarios que intentan pasarle la password de root al comando “su”, ejecutando comandos tipo:

$ su - 354dr2

Pensando que 354dr2 es la password de root, al igual que

$ sudo su - password_del_usuario

Pensando que de esa forma no le pedirá el password. Lo que no sabe el usuario es que todo lo que ejecuta esta siendo logueado y que está comprometiendo la seguridad del servidor.

El .bash_history o historial de comandos bash, muestra mucho como trabajan los usuarios, qué hacen y de qué forma lo hacen, de esta forma es posible obtener información sobre algun sistema o servicio que esté corriendo en el servidor, por ejemplo si entramos a la mala a un servidor y queremos buscar información privada o información que nos interese, podemos ver el historial de los usuarios para saber qué hacen, por donde se mueven y seguir sus pasos.

Un dia me tocó ver que un usuario tenia un script “escondido” que se conectaba vía llave pública a 4 o 5 servidores (incluyendo uno fuera de la red), obviamente, la llave privada estaba en el servidor donde yo estabam por lo que pude acceder a todas sus cuentas en los otros servidores.

Imagenes y snapshots: Respaldo de servidores

Zerial — Mon, 22 Feb 2010 13:15:02 +0000

Mi propósito era crear imágenes de todos los servidores del datacenter para que, en caso de cualquier contingencia, levantar un nuevo servidor identico simplemente traspasando la imágen de respaldo hacia ese servidor. Los sistemas estaban instalados usando volumenes lógicos (LVM) por lo que sería mucho más fácil crear imágenes y snapshots de respaldos. En un prinicpio pensé hacer directamente dd sobre los volumenes lógicos pero la imágen se corrompía y en muchos casos no podía volver a recuperarla. Existe la posibilidad de montar el volumen lógico en un directorio y respaldar, usando tar, bzip y esas cosas, sólo los archivos, pero no era mi propósito, ya que para restaurar solamente los archivos, debía tener una partición ya preparada, con el sistma de ficheros, sistema instalado, etc etc. En cambio, con la imágen simplemente hacia un dd para restaurarla, sin tener el sistema de archivos creado, etc.

Por twitter me recomendaron varias opciones. @Apostols me recomendó las herramientas “puppet” y “rlbackup”, mientras que @ssugasti “mondorescue”, pero yo seguia con mi idea de usar directamente “dd”. Debía hacer el mismo procedimiento en mas de 40 servidores, por lo que usar una aplicación “cliente->servidor” no era mi solución. Usar aplicaciones que requieran modo grafico o que requieran mucha interacción con el usuario tampoco me servian, yo necesitaba algo automatizado que pueda dejar corriendo de noche y volver al otro día y encontrar el trabajo hecho.

Leyendo el manual de LVM, especialmente el de lvcreate, encontré la opción “snapshot” que básicamente le toma una “foto” al volumen lógico de origen y crea un nuevo volumen con ese preciso instante en que se hizo el snapshot, de ésta forma la partición original podrá ser actualizara mientras que el snapshot se respalda sin problemas. Luego de eso, el snapshot se elimina y se guarda la imágen. La rutína sería mas o menos asi:

# lvcreate --snapshot /dev/Vol00/var --name var-snap -L100k # dd if=/dev/Vol00/var-snap of=/backup/var.img # lvremove -f /dev/Vol00/var-snap

De esta forma, creamos un snapshot llamado “var-snap” en base a la partición (o volumen) /dev/Vol00/var, luego, usando dd, creamos la imágen de dicha partición y la guardamos en /backup. Finalmente eliminamos el snapshot.
Para tener aún más certesa de que todo funcionaría, tambien decidí empaquetar, comprimir y guardar los ficheros, por lo que antes de eliminarla (lvremove) la debo montar y hacer un tar. La rutina quedaría así:

# lvcreate --snapshot /dev/Vol00/var --name var-snap -L100k # dd if=/dev/Vol00/var-snap of=/backup/var.img # mount /dev/Vol00/var-snap /mnt # tar cfjv /bakcup/var.tbz2 /mnt # umount /mnt # lvremove -f /dev/Vol00/var-snap

En mi caso, /backup corresponde a un punto de montaje de red NFS.
Mi misión era realizar ésta misma rutina en más de 40 servidores, por lo que necesitaba hacer un script que se paseara por todos los servidores y ejecutara estos comandos.

#!/bin/bash

IDENTITYFILE=$HOME/.ssh/id_rsa
MACHINES=servidores.list
DATE=$(date +%d%m%Y)
NFS=/mnt/imagenes/servers/
DIR_SNAPSHOT=/mnt/snapshot

for server in $(cat servidores.list);
do
        echo "Respaldando $server ..."
        ssh -i $IDENTITYFILE $server "lvdisplay" >/tmp/lvdisplay_temp
        lvdisplay=$(awk '
                /LV Name/ { name = $3 }
                /VG Name/ { print name","$3 } ' /tmp/lvdisplay_temp)
        for _logicalv in $lvdisplay;
        do
                lvname=$(echo $_logicalv |cut -f1 -d ","|cut -f4 -d "/")
                logicalv=$(echo $_logicalv |cut -f2 -d ",")
                echo -e "\tVolumen Logico: $lvname"
                ssh $server "lvcreate --size 100m --snapshot --name $lvname-snap /dev/$logicalv/$lvname"
                ssh $server "mount /dev/$logicalv/$lvname-snap $DIR_SNAPSHOT"
                ssh $server "mkdir $NFS$server"
                ssh $server "tar cfj $NFS$server/snapshot_$lvname-$DATE.tar.bz2 $DIR_SNAPSHOT"
                ssh $server "umount $DIR_SNAPSHOT"
                ssh $server "dd if=/dev/$logicalv/$lvname-snap of=$NFS$server/image_$lvname-$DATE.img"
                ssh $server "lvremove -f /dev/$logicalv/$lvname-snap"
                echo -e "\tArchivo imagen: $NFS$server/image_$lvname-$DATE.img"
                echo -e "\tArchivo tarball: $NFS$server/snapshot_$lvname-$DATE.tar.bz2"
        done
done
scp /tmp/lvdisplay_temp $server:$NFS$server/lvdisplay

El script trabaja con la salida del comando lvdisplay que entrega una salida con los detalles de cada volumen lógico. Lee un fichero llamado servidores.list y hace un recorrido línea por línea, conectándose a cada servidor y ejecutando las instrucciones necesarias. Para hacer el proceso más eficiente y automatizado es necesario, previamente, copiar todas las claves públicas a cada servidor, para evitar la autentificación.

Asaltando un sitio de series online

Zerial — Tue, 16 Feb 2010 00:33:35 +0000

De aburridos, junto con E.A.S (o xwall), nos dedicamos a buscar un sitio que brinde el servicio de series de en linea para encontrar la forma de tomar prestadas todas las series alojadas en el servidor. Imaginense algo como YouTube, pero tan vulnerable que fuese posible extraer todos los videos que hay en la red.
Bien, nuestro objetivo fue un sitio de series de animé en línea llamado “Efecto animé” que, mediante el sitio Satanick.net logramos descargar todas las series y capítulos que se servían.

La teoría es sencilla, la idea era encontrar un link directo a los distintos archivos multimedia o bien un enlace a algun directorios que los contenga, para luego descargar todo el contenido del directorio.
El fallo por parte de ellos fue dejar que se liste el contenido de directorios, de esta forma pudimos tener acceso a informacón como la siguiente:

Luego, con un poco de magia, simplemente descargamos el contenido de todo ese directorio.

Todo fue gracias al sitio “Satanick” el cual contiene un flash que provee al usuario poder ver series en línea, afortunadamente lamentablemente si vemos el código fuente nos encontramos con la siguiente sorpresa:

Miren detenidamente el código a ver si encuentran algo que nos ayude a nuestro propósito. Encontramos:

file=http://efectoanime.com/server/dn0te/06.mp4

Con esto ya podemos deducir que todos los videos se encuentran en la URL http://efectoanime.com/server/XXX, donde XXX corresponde al nombre de la serie. Como vimos en la imágen que les mostré anteriormente (donde se listaban los archivos del directorio thundercats/), está permitido listado de archivos de un directorio. Nuestro amigo wget será la salvación, ya que con el parametro -r es posible descargar un directorio.

Bien, ahora nos falta automatizar el proceso. Las URL de Satanick, donde se encuetran los videos, son de la forma http://satanick.com/?page_id=XXX, por lo que podemos asumir que cada ID corresponde a una página y en cada página es posible que encontremos links como el que les acabo de mostrar (el html de más arriba). Entonces mi idea fue crear un script que recorriera todas las páginas desde XXX hasta XXX+n. Pensando que si lo hago desde 0 se iba a demorar una eternidad, solo lo hice desde el 3000 hasta el 10000, luego cada página examinada deberá ser parseada y se debe encontrar un patrón que nos permita obtener la URL donde se encuentran los videos.
Yo lo hice de la siguiente forma:

for x in $(seq 3000 10000); do wget -O - http://satanick.net/?page_id=$x |grep "http://efectoanime.com/server" |awk -F '&' {'print $2'}>> lista_videos_satanick; done

Si lo queremos ver más bonito y en forma de “script”:

#!/bin/bash
for x in $(seq 3000 10000);
do
   wget -O - http://satanick.net/?page_id=$x |grep "http://efectoanime.com/server" |awk -F '&' {'print $2'}>> lista_videos_satanick;
done

El archivo “lista_videos_satanick” va a guardar todas las URL que encuentre y quedarás más o menos así:

file=http://efectoanime.com/server/hades/h29.mp4
file=http://efectoanime.com/server/hades/h29.mp4
file=http://efectoanime.com/server/hades/h30.mp4
file=http://efectoanime.com/server/hades/h30.mp4
file=http://efectoanime.com/server/hades/h31.mp4
file=http://efectoanime.com/server/hades/h31.mp4
file=http://efectoanime.com/server/hades/h31.mp4
file=http://efectoanime.com/server/thundercats/Th71.mp4
file=http://efectoanime.com/server/thundercats/Th71.mp4
file=http://efectoanime.com/server/thundercats/Th71.mp4
file=http://efectoanime.com/server/thundercats/Th72.mp4
file=http://efectoanime.com/server/thundercats/Th72.mp4
file=http://efectoanime.com/server/thundercats/Th72.mp4
file=http://efectoanime.com/server/thundercats/Th73.mp4
file=http://efectoanime.com/server/thundercats/Th73.mp4
file=http://efectoanime.com/server/thundercats/Th73.mp4
file=http://efectoanime.com/server/thundercats/Th74.mp4
file=http://efectoanime.com/server/thundercats/Th74.mp4

Lo único que debemos hacer es quitarle el principio “file=” y quitar las líneas repetidas:
sed -i 's/file=//g' lista_videos_satanick
Nos quedará algo así:

http://efectoanime.com/server/shippuden/Shippuden_144.mp4

http://efectoanime.com/server/bl34ch/B255.mp4

http://efectoanime.com/server/shippuden/Shippuden_145.mp4

http://efectoanime.com/server/md/612.mp4

http://efectoanime.com/server/bl34ch/B256.mp4

http://efectoanime.com/server/shippuden/Shippuden_146.mp4

http://efectoanime.com/server/thundercats/Th90.mp4

http://efectoanime.com/server/thundercats/Th92.mp4

De todas estas URL lo que nos interesa es sólo http://efectoanime.com/server/XXX, entonces lo arreglamos:

awk -F '/' {'print $1"/"$2"/"$3"/"$4"/"$5'} lista_videos_satanick

Quedará algo así:

http://efectoanime.com/server/thundercats

http://efectoanime.com/server/thundercats

http://efectoanime.com/server/thundercats

http://efectoanime.com/server/thundercats

http://efectoanime.com/server/thundercats

http://efectoanime.com/server/thundercats

http://efectoanime.com/server/thundercats

http://efectoanime.com/server/thundercats

http://efectoanime.com/server/thundercats

http://efectoanime.com/server/thundercats

http://efectoanime.com/server/thundercats

http://efectoanime.com/server/thundercats

http://efectoanime.com/server/bl34ch

http://efectoanime.com/server/bl34ch

http://efectoanime.com/server/bl34ch

http://efectoanime.com/server/shippuden

http://efectoanime.com/server/shippuden

http://efectoanime.com/server/shippuden

http://efectoanime.com/server/MD

http://efectoanime.com/server/MD

http://efectoanime.com/server/MD

Ahora debemos eliminar las repetidas:

# awk -F '/' {'print $1"/"$2"/"$3"/"$4"/"$5'} lista_videos_satanick |sort|uniq -d


http://efectoanime.com/server/avatar
http://efectoanime.com/server/bl34ch
http://efectoanime.com/server/Chihiro
http://efectoanime.com/server/dn0te
http://efectoanime.com/server/hades
http://efectoanime.com/server/lcanvas
http://efectoanime.com/server/manga
http://efectoanime.com/server/md
http://efectoanime.com/server/MD
http://efectoanime.com/server/sayns
http://efectoanime.com/server/shippuden
http://efectoanime.com/server/thundercats
http://efectoanime.com/server/trailers

http://efectoanime.com/server/Vshow

Luego un script que descarge todos los contenidos de los directorios:

for link in $(cat lista_videos_satanick); do wget -r $link; done

Y listo.

1.6G Death Note.tar
1.6G Saga de Hades.tar

ACTUALIZADO 16/02/2009

Luego de los comentarios de los responsables de los sitios, dando las gracias y diciendo que no les importa porque de todas formas tiene una marca de agua, etc etc.. Los directorios ya no se pueden listar:

http://efectoanime.com/server/thundercats/

Al fin y al cabo, si les importó el tema. Me alegro que les sirviera el post.

Script para escanear la red en busca de servidores y servicios

Zerial — Wed, 10 Feb 2010 13:40:07 +0000

Hace un par de días tuve la necesidad de escanear 3 redes completas, mas de 50 direcciones ip, en busca de servicios que corrieran en ellas. Obviamente, no iba a ingresar a cada servidor y hacer un netstat o revisar uno por uno que servicios tenia instalado, si para eso existe nmap!
Lo que hicste fue separar los rangos de ip en archivos distintos, para tener un orden y escanear la red en orden según los segmentos y luego hice un script que leia cada archivo y escaneaba la ip en busca de servicios, la salida del nmap la parseaba y lo guarda en un archivo separado por comas. En un principio el script mostraba todo en el stdout pero para que quedara más ordenado, preferí hacerlo en un CSV para poder abrirlo con oocalc.
El script me genera un archivo con la siguiente información:

host, IP, Servicio, Puerto, Version

El script es el siguiente:

#!/bin/bash

nmap=/usr/bin/nmap
params="-sV"
tmp_file=/tmp/nmap_scanner_output
output=Servidores.csv
export SCANNER_ERROR=0

echo "host,IP,Servicio,Puerto,Version" >> $output
for ips in ips.*
do
	echo "Analizando $ips ..."
	for ip in $(cat $ips)
	do
		echo -e "\t-> $ip ..."
		ping -c 1 $ip 1>/dev/null 2>&1|| export SCANNER_ERROR=1
		if [ $SCANNER_ERROR = "1" ]; then
			echo -e "\t\t- Host no activo"
		fi
		if [ $SCANNER_ERROR = "0" ]; then
			$nmap $params $ip |grep -v "Starting Nmap" |grep -v "Nmap scan report" |grep -v "Host is up" |grep -v "Not shown" |grep -v "Service detection performed" |grep -v "Nmap done" > $tmp_file
			export _host=$(grep "Service Info" $tmp_file |sed 's/,//g'|grep "Host" |awk -F ' ' {'print $4'} |sed 's/;//g')
			grep tcp $tmp_file |scanner_ip=$ip awk -F " " '{print ENVIRON["_host"]","ENVIRON["scanner_ip"]","$3","$1","$4,$5,$6,$7,$8;}' >>$output
			echo -e "\n" >>$output
		fi
		export SCANNER_ERROR=0
	done
done

El script necesita para funcionar archivos con el listado de direcciones ip. Los (o el) archivo(s) se deben llamar “ips.“. En mi caso, tengo los siguientes archivos:
ips.192 ips.10 ips.172
Dentro de cada archivo hay direcciones del tipo 192.168.0.X, 10.0.0.X, 172.20.20.X…

$ sh scan.sh Analizando ips.10 ... -> 10.0.0.2 ... -> 10.0.0.3 ... -> 10.0.0.11 ... - Host no activo -> 10.0.0.20 ... - Host no activo -> 10.0.0.21 ... - Host no activo -> 10.0.0.70 ... -> 10.0.0.72 ... -> 10.0.0.73 ... Analizando ips.172 ... -> 172.20.20.2 ... -> 172.20.20.3 ... Analizando ips.192 ... -> 192.168.0.55 ... -> 192.168.0.101 ...

[...]

El script generará un output a un archivo llamado “Servidores.csv”, el cual lo podemos encontrar en la misma ruta donde tenemos el script.

mpd-twitter: Publicar en twitter lo que estas escuchando

Zerial — Sun, 10 Jan 2010 19:56:18 +0000

Ultimamente he estado usando el Music Player Daemon (MPD) para escuchar música. Tambien me he dado cuenta que en Twitter hace varios días está de trending topic el hashtag #nowplaying, donde la gente publica lo que está escuchando. En base a ésto y a un poco de imaginación y tiempo libre, cree un script en bash que me permite publicar lo que estoy escuchando.

El script, llamado mpd-twitter, usa el cliente mpc para conectarse a mpd y obtener el artista y nombre de la reproducción actual, hacer el parseo necesario y posteriormente publica un estado en twitter.

#!/bin/bash
#
# Author: Zerial 
# Version: 0.1
# URL: http://dev.zerial.org/mpd-twitter
# License: GPL
#

CONF_FILE=$HOME/.mpd-twitter
USER=$(grep ^USERNAME $CONF_FILE |cut -f 2 -d "=")
PASS=$(grep ^PASSWORD $CONF_FILE |cut -f 2 -d "=")

if [ -f $CONF_FILE ]; then
	BEFORE=$(grep ^BEFORE $CONF_FILE |cut -f 2 -d "=")
	AFTER=$(grep ^AFTER $CONF_FILE |cut -f 2 -d "=")
else
	Xdialog --title "Error" --beep --msgbox "Can't read your local config file. Please copy the /usr/local/share/mpd-twitter/mpd-twitter.local to $HOME/.mpd-twitter" 200 100
	exit
fi

CURRENT_SONG=$(mpc current)
MY_UPDATE="$BEFORE $CURRENT_SONG $AFTER"

curl -u "$USER:$PASS" -d "status=$MY_UPDATE" -d "source=mpd-twit" "http://twitter.com/statuses/update.json"
exit

El archivo de configuración, que debe estar ubicado en ~/.mpd-twitter, es:

#
# Local Config file for mpd-twitter
#
#
# Config the username and password
#
USERNAME=your_username
PASSWORD=your_password
#
# Text before and text after the song.
# example:
# if BEFORE=Listening and AFTER=(powered by xxx)
# mpd-twitter will send "Listening  (powered by xxx)"
#
BEFORE=#nowplaying
AFTER=(powered by mpd)

Para los usuarios de Archlinux que quieran probarlo, he creado un PKGBUILD:

# Contributor: Zerial 
pkgname=mpd-twitter
pkgver=0.1
pkgrel=4
pkgdesc="Publish on twitter what you are listening on MPD"
arch=('i686' 'x86_64')
url="http://dev.zerial.org/mpd-twitter"
license=('GPL')
depends=('xdialog' 'curl' 'mpc')
source=(http://dev.zerial.org/mpd-twitter/${pkgname}_${pkgver}.tar.gz)
md5sums=('3d73b79fa38bd60f637386146137999b')

build(){
	cd $startdir/src/$pkgname
	install -d $startdir/pkg/usr/local/share/mpd-twitter
	mkdir $startdir/pkg/usr/bin
	install -m744 $startdir/src/$pkgname/mpd-twitter.local $startdir/pkg/usr/local/share/mpd-twitter/
	install -m755 $startdir/src/$pkgname/mpd-twitter $startdir/pkg/usr/bin/
}

Tambien lo pueden encontrar en el repositorio AUR.

La idea es lanzar el script con algun hotkey de nuestro gestor de ventanas y asi, cada véz que quieras mostrar lo que estás escuchando, simplemente precionas la combinacion de teclas que configuraste. Por ejemplo, en DWM la he configurado asi:

[...]
/* commands */
static const char *mpdtwittercmd[] = { "mpd-twitter", NULL };
static Key keys[] = {
[...]
      { MODKEY|ShiftMask,                     XK_t,   spawn,  {.v = mpdtwittercmd } },
[...]

De esta forma, cada vez que presiono Alt+Shift + T, aparece en twitter lo que estoy escuchando.