Existen varias formas de hacerlo pero mi preferida es nohup. Lo uso mas que todo cuando por ejemplo me toca pasarle un mysqldump (de 30 GB) de una maquina a otra o restablecer ese mysqldump en la otra maquina.

 

El comando nohup le indica a un programa que ignore la señal de ‘Hangup‘ permitiéndole seguir corriendo después de que el usuario que lo inicio haya cerrado su sesión. Un ejemplo de nohup seria:
noup mysql -u torvalds -pPasswordAqui -bLinuxRocks < ~/linuxroks.sql &

Como ven estamos restableciendo un mysqldump de la base de datos LinuxRocks usando el usuario torvalds pero la clave aquí es que precedo el comando mysql con un nohup y terminamos el comando con un & para enviarlo al fondo ahora podemos desconectarnos y el el mysqldump seguirá corriendo.

Cualquier salida de este proceso quedara guardado en el archivo nohup.out dentro del directorio en el que estemos ejecutando el nohup.

Dejar procesos corriendo en el fondo aun cuando cerremos la sesión es un articulo de: orvtech.com

Con BASH e ImageMagick puedes cambiar el peso de una imagen ajustando su calidad

La suite ImageMagick ofrece identify entre sus aplicaciones la que nos permite ver información acerca de una imagen. En este caso lo usaremos para ver la calidad de un JPG y también usaremos convert de la misma suite (ImageMagick) para ajustar la calidad de la imagen.

En caso de que necesiten instalar ImageMagick, solo deben abrir un terminal y ejecutar como root en su Fedora Linux:
yum install ImageMagick

Recuerda que no estas obligado a usar el terminal en Fedora para instalar aplicaciones, también puedes hacerlo usando la interfaz gráfica, solo sigue mi vídeo tutorial Instalando programas en Fedora Linux

Una vez que tengas instalado ImageMagick puedes ejecutar el siguiente script:
#!/bin/bash
DIRECTORIOS="/var/www/htdocs/wordpress/wp-content/uploads/20*"
NUEVA_CALIDAD="80"
#
for IMAGENES in `find $DIRECTORIOS -type f| grep -i jpg$ `;
do CALIDAD=`identify -format %Q $IMAGENES`;
if [ "$CALIDAD" -gt "$NUEVA_CALIDAD" ];
then
echo mejorando $IMAGENES con calidad $CALIDAD
convert -quality $NUEVA_CALIDAD $IMAGENES $IMAGENES
fi
done

Como ven, en las primeras dos lineas se declara la ruta de donde están las imágenes y en el segundo se procesan. En mi caso me dispuse a ajustar la calidad de las imágenes de mi wordpress por lo que asignó a $DIRECTORIOS la ruta donde están guardadas las imágenes de los artículos. Noten que acepta wildcards.
El proceso como tal usa la salida de identify para saber la calidad actual de la imagen, luego con un condicional evaluamos si la imagen en cuestión tiene una calidad superior al valor deseado ($NUEVA_CALIDAD) y de ser así le se la cambiamos asignándole el valor de $NUEVA_CALIDAD que para este ejemplo es 80.

Eliminado meta-data y la codificación del JPEG para una imagen mas pequeña

Calidad al 100% con un tamaño o peso de 50K	Calidad al 80% con un tamaño o peso de 6.7K

El producto se puede apreciar en estas dos imágenes, la de la izquierda es la original mientras que la de la derecha es la imagen procesada. Para llegar a esta diferencia de tamaño tuve que usar medidas drásticas. aparte de ajustar la calidad a un 80%, me dispuse a eliminar la data del EXIF y cambie el subsampling pasandole a convert estos parámetros:
-quality 80 -strip -sampling-factor 4:1:1

Si quieres aplicar estos cambios a un lote de imágenes puedes usar esta versión modificada del script anterior:
#!/bin/bash
DIRECTORIOS="/var/www/htdocs/wordpress/wp-content/uploads/20*"
NUEVA_CALIDAD="80"
SAMPLING="4:1:1"
#
for IMAGENES in `find $DIRECTORIOS -type f| grep -i jpg$ `;
do CALIDAD=`identify -format %Q $IMAGENES`;
if [ "$CALIDAD" -gt "$NUEVA_CALIDAD" ];
then
echo mejorando $IMAGENES con calidad $CALIDAD
convert -quality $NUEVA_CALIDAD -strip -sampling-factor $SAMPLING $IMAGENES $IMAGENES
fi
done

Tengan en cuenta que jugar con el sampling-factor puede alterar la fidelidad de los colores de una imagen.
Si te gusto este articulo, tal vez te interese: Marcado de agua por lote usando BASH.

Cambiar la calidad de imágenes por lote usando BASH es un articulo de: orvtech.com

Retomando el tema de eliminar archivos, hay muchos que piensan que simplemente formateando un archivo o eliminándolos con rm es suficiente para evitar que alguien los recupere, déjenme decirles que están muy equivocados. Para asegurarse que los datos de la tarjeta de crédito que anotaron en el archivo XYZ, cartas de su amante con la que engañan a su pareja o el historial de su navegador web con todas esas visitas a redtube y demás sitios pornográficos no puedan ser recuperados deben usar algo mas complejo.

El borrar un archivo con el comando rm lo único que hace es decirle al sistema operativo, que el espacio que ocupaba ese archivo ahora esta libre. Cualquier archivo puede ser recuperado de forma sencilla siempre y cuando los bloques que componen este archivo no sean re-usados.

Para evitar que sean recuperados debemos rescribir el espacio que estos archivos ocupan el el disco duro con data aleatoria, de manera que si algún programa forense encuentra este archivo, no pueda ser leído de forma clara. Quería dejarles dos métodos para eliminar archivos pero esta vez que no puedan ser recuperados por herramientas forenses.

Usando BASH
El primer método es basado en BASH, es un script que va a escribir bits aleatorios en el lugar que ocupa el archivo a eliminar en el disco duro. El script que se basa en el comando dd, es este:
#!/bin/bash
for ((n=1;n<10;n++))
do dd if=/dev/urandom of=prueba.txt bs=15 count=1 conv=notrunc
dd if=/dev/null of=prueba.txt bs=15 count=1 conv=notrunc
done
rm -f prueba.txt

Antes de que ejecuten este script, tome en cuenta que prueba.txt es el archivo que estoy eliminando y en bs=15, ese numero quince es el tamaño del archivo el cual obtuve con un simple ls, como lo pueden ver aquí:
orvtech@vps ~ $ ls -l test.dd
-rw-r--r-- 1 orvtech orvtech 15 Jun 28 16:58 prueba.txt

El script escribe la salida de /dev/urandom a prueba.txt en una salida con un tamaño de bloque de 15 y lo hace una sola vez, no se va a detener en caso de truncamiento, la segunda instrucción dd escribe el archivo con ceros. Este proceso se repetirá 10 veces, valor que puede ser alterado por un numero mas alto si así lo queremos. Por ultimo el archivo es eliminado

Usando shred
El segundo método usa el comando shred que por defecto sobrescribe el archivo 25 veces con data aleatoria. Este valor puede ser remplazado por cualquier otro usando el parámetro -n, por ejemplo:
shred -n 5 prueba.txt

shred ademas nos permite entre otras cosas ver el progreso del procedimiento usando el parámetro -v y sobrescribir ceros al archivo a eliminar con el parámetro -z, cosa que es útil si no quieres que alguien que encuentre dicho archivo crea que es un archivo encriptado y levante sospechas.
shred -n 5 -z -v prueba.txt

Si quieres eliminar el archivo luego de este procedimiento, puedes usar el parámetro –remove.

Destruye de forma segura tus archivos privados es un articulo de: orvtech.com

La semana pasada durante el FUDCon tatica me pidió que le hiciera un script para hacerle marca de agua a un lote de fotos. La marca de agua se usa mas que todo como para marcar fotos y evitar que sean usadas como parte de otros trabajos, que sean plagiadas o osadas a nivel comercial (gigantografiás, vallas publicitarias, revistas, etc). Ella me comentaba que no le importe que la gente use sus fotos siempre y cuando le avisen y esta es una forma de forzar a que si quieren la foto sin la marca de agua deban contactarla para que ella se las envié.

Durante uno de los hackfests que se llevo extendió a una de las villas intente hacerlo algo rápido, pero a las 2am se me era difícil lidiar con error que tenia de sintaxis así que lo complete hoy y quiero compartir el script con ustedes.
#!/bin.bash
WATERMARK=watermark.png
for imagenes in `ls $1 | grep -i -E 'jpg|jpeg|png|gif' | grep -v -E ^'watermark.png|wm_'`
do echo "trabajando con imagenes de $1"
composite -dissolve 20% -gravity southeast "$WATERMARK" "$imagenes" wm_"$imagenes"
done

El script acepta como parámetro el directorio el cual contiene las imágenes y va a producir imágenes con el mismo nombre que las originales pero con el prefijo wm_ y necesita un archivo, preferiblemente PNG con la imagen de agua que va a ser aplicada. El comando composite es parte de ImageMagick así que es Aquí les dejo una muestra de la misma foto, primera sin la marca de agua y la segunda con la marca de agua en la esquina inferior derecha.

Antes y después de la marca de agua en una foto donde aparece Jeroen y Neville en el FUDcon celebrado la pasada semana en Panamá

Marcado de agua de imágenes con BASH es un articulo de: orvtech.com

El día de hoy notamos que un grupo de servidores tenia carga mas alta de lo normal y estaba usando mas swap de lo normal. Revisando nagios me doy cuenta que tenia ya días así, pero todos coincidían con una fecha, Mayo 8. Como es un grupo de servidores al que varios tenemos acceso quería revisar que paquetes se instalaron ese día o el día anterior. Aquí les dejo los dos métodos que utilice.

Como reviso cuando se instalo un RPM en el servidor?
La respuesta es simple, el siguiente comando muestra que día y a que horas fueron instalados todos los paquetes en el servidor.
rpm -qa --last

Si tienes la idea de como se llama el paquete puedes direccionar la salida de este comando hacia un grep que contenga este nombre, por ejemplo, el servidor web:
rpm -qa --last | grep -i -E 'apache|httpd'
Esto va a devolver, el día y la hora en que cualquier paquete que contenga apache o httpd en su nombre (por ejemplo apache-1.3.7, httpd-2.2.1, etc..)

Si conoces el nombre exacto del paquete puedes modificar el comando y especificar el nombre del paquete, por ejemplo:
rpm -q --last wget
Este comando va a dar una salida muy parecida a esto:
wget-1.12-2.fc13 Tue 01 Feb 2011 04:26:17 PM EST

El segundo método con queryformat y querytags.
La segunda forma de hacerlo que incluso nos sirve para crear un historial de cuando se instalo cada paquete es usado. Lo primero es saber que etiquetas podemos usar con queryformat, para lo que ejecutamos:
rpm --querytags | grep -i install

La salida de este comando en mi caso es:
INSTALLTIME
INSTALLCOLOR
INSTALLTID
INSTALLPREFIX

En nuestro caso usaremos la etiqueta installtime que sera la cantidad de segundos desde el primero de Enero del año 1.970 hasta que se instalo el paquete.
El comando queda así:
rpm -qa --queryformat '%{installtime} (%{installtime:date}) %{name}\n' | sort -n

Noten que estamos usando "%{installtime:date}" para formatear installtime como fecha en vez de segundos. La salida de ese comando luce así:
1304950733 (Mon 09 May 2011 10:18:53 AM EDT) google-chrome-stable
1305060365 (Tue 10 May 2011 04:46:05 PM EDT) perf
1305060368 (Tue 10 May 2011 04:46:08 PM EDT) orc
1305060370 (Tue 10 May 2011 04:46:10 PM EDT) polkit
1305060372 (Tue 10 May 2011 04:46:12 PM EDT) polkit-desktop-policy

Como ven son tres columnas (Segundos desde Enero 1 del 1970 seguido de la fecha y luego el nombre del paquete)

Estos dos métodos deberían de funcionar con aLinux, ALT Linux, Ark Linux, Berry Linux, Caixa Mágica, cAos Linux, EnGarde Secure Linux, Fedora, Fox Linux, Mandriva, Mandriva Linux, openSUSE, PCLinuxOS, Pingo Linux, PLD Linux Distribution, QiLinux, Red Flag Linux, Red Hat Enterprise Linux, SAM Linux, Sharif Linux, SUSE Linux, Tinfoil Hat Linux, Trustix, Turbolinux, Vine Linux, White Box Enterprise Linux, Yoper o cualquier distro que use RPM como manejador de paquetes aunque es muy posible que algunas tengan utilidades que permitan hacer estas búsquedas un poco mas fácil.

Cuando se instalo un RPM? es un articulo de: orvtech.com

A pesar de que history es realmente útil y una gran ayuda en BASH, es posible que en ocasiones no quieres que algunos comandos sean guardados en tu historial. Supongamos que estas usando una maquina compartida en la que mucha gente tiene acceso, los administradores podrían simplemente hacer login como root y leer tu ~/.bash_history sin ninguna serie de hacks complicados… es así de simple, incluso si tu maquina personal es comprometida tu historia esta a la vista del hacker que este realizando el ataque. Por esta y muchas otras razones tal vez quieras mantener algo de control sobre tu historial y prevenir que algunos comandos sean guardados en tu historial.

Una forma simple de prevenir que algunos comandos sean listados por history es usando HISTCONTROL=ignorespace:ignoredups. El parámetro ignoredups te permite ignorar duplicados. ignorespace específicamente te permite ignorar comandos que son precedidos por un espacio en blanco, perfecto para esos comandos que quieres mantener en secreto. Algunas distribuciones ya traen esto por defecto pero de igual forma lo puedes asignarlo tu en el archivo .bashrc dentro de tu home

Otro método es usar la variable de entorno HISTIGNORE para que BASH ignore algunos comandos o parámetros. Digamos que no quieres que queden registrados todos los comandos que contienen el nombre de un server privado, en ese caso podrías usar HISTIGNORE="*mi_servidor_secreto*" donde mi_servidor_secreto es el nombre o parte del nombre de este server.

Recuerda que esto no te asegura que tus comandos estarán 100% seguros, en una maquina compartida o una comprometida la gente podría ver que procesos están corriendo con ps aux o que hay en memoria para determinar que comandos están siendo ejecutados. Recuerda no hacer trabajos que usan información sensitiva en maquinas en las que no confías.

Si te gusto este articulo, tal ves podría interesarte el siguiente articulo: history, mas que historia.

Privacidad y Seguridad en history es un articulo de: orvtech.com

1. El grupo de usuarios que van a publicar fotos toman las fotos con sus dispositivos, en mi caso siempre he usado mi teléfono móvil.
2. Esta foto es enviada vía correo electrónico a Picasa.
3. Picasa procesa esta foto y genera las miniaturas de la foto automáticamente, ademas de hacerlas disponibles a través de su API.
4. Mi NSLU2 que aun esta corriendo Linux hace una petición HTTP a Picasa y procesa la respuesta generando un archivo con código javascript.
5. El código javascript pre-generado por mi NSLU2 puede ser insertado en cualquier pagina web, las fotos estarán alojadas en la infraestructura de Picasa, reduciendo así el impacto a nivel de ancho de banda en nuestros servidores.

El Script
Como ven aquí abajo el script esta dividido en tres segmentos, el primero es para la declaración y asignación de variables donde puedes especificar el numero de columnas a usar para mostrar el álbum. El usuario al cual le pertenece esa cuenta de Picasa web y el nombre del álbum que contiene esas fotos. El valor de TEMPORAL debe de ser un directorio donde se van a guardar los archivos temporales que el script use.

El segundo segmento es el encargado de adquirir la data necesaria de las fotos alojadas en Picasa y generar un archivo de texto temporal que luego va a ser procesado para generar el javascript. El tercer y ultimo segmento genera el javascript y manipula el archivo temporal para que se generen columnas de fotos de acuerdo a la variable columnas.
#!/bin/bash
# livecast-1.sh
# preguntas o contacto en http://orvtech.com
# No te olvides de hacer poner un link a http://orvtech.com donde uses este script.
#!/bin/bash
columnas=3
contador=0
ultimas=6
TEMPORAL="/tmp"
USUARIO="tu_ID_de_Usuario_aqui"
ALBUM="Nombre_de_Album_aqui"
DESTINO="tu_path_de_destino_aqui.js"
#
curl -s https://picasaweb.google.com/data/feed/base/user/$USUARIO/album/$ALBUM |\
sed -e 's/\"/\ /g' -e s/\'/\ /g | tr ' ' '\n' |grep s144|\
awk -v USUARIO=$USUARIO -v ALBUM=$ALBUM '{print ""}' > $TEMPORAL/livecast.txt
#
cat $TEMPORAL/livecast.txt|tail -n $ultimas |\
while read line
do contador=$(( $contador + 1 ))
if [ $contador -eq $columnas ];then
echo "${line}
" |tr '\n' ' ' | sed -e 's/ / /g'
contador=0
else
echo "${line}"| tr '\n' ' ' | sed -e 's/ / /g'
fi
done |tr '\n' ' ' | sed -e 's/ / /g' -e 's/s144/s200-c/g' |awk '{print "var livecast='"'"'" $0"'"'"'\ndocument.write(livecast);"}' > $DESTINO

Este script genera un archivo que puede ser invocado con un simple <script src="http://dominio.ltd/archivo.js" type="text/javascript">. En mi caso a partir del álbum https://picasaweb.google.com/orvtech.com/DropBox genero el código:
var livecast='<a href="https://picasaweb.google.com/orvtech.com/DropBox"><img src="http://lh4.ggpht.com/_9SbN2dfg-eo/TVP_pLNsZNI/AAAAAAAAAC4/fPaI9Axe0vM/s144-c/4563315788_ec545d5010_o.jpg" height="144px" width="144px"/></a> <a href="https://picasaweb.google.com/orvtech.com/DropBox"><img src="http://lh5.ggpht.com/_9SbN2dfg-eo/TVP_-5OuSoI/AAAAAAAAAC4/MUoxlt--jcQ/s144-c/4546433743_2c8b357c72_o.jpg" height="144px" width="144px"/></a> <a href="https://picasaweb.google.com/orvtech.com/DropBox"><img src="http://lh4.ggpht.com/_9SbN2dfg-eo/TVQABB_L42I/AAAAAAAAAC4/3ZqVtZbS6Bc/s144-c/IMG_20110127_225432.jpg" height="144px" width="144px"/></a><br /> <a href="https://picasaweb.google.com/orvtech.com/DropBox"><img src="http://lh5.ggpht.com/_9SbN2dfg-eo/TVQAF0PRLvI/AAAAAAAAAC4/YY_T9872UMs/s144-c/Flisol2009_04.jpg" height="144px" width="144px"/></a> <a href="https://picasaweb.google.com/orvtech.com/DropBox"><img src="http://lh5.ggpht.com/_9SbN2dfg-eo/TVQAN3_ZjQI/AAAAAAAAAC4/gg2DoHP5Ybk/s144-c/p4240052.jpg" height="144px" width="144px"/></a> <a href="https://picasaweb.google.com/orvtech.com/DropBox"><img src="http://lh3.ggpht.com/_9SbN2dfg-eo/TVQAOJ9WG-I/AAAAAAAAAC4/rM8wkBYSdsA/s144-c/IMG_5571.JPG" height="144px" width="144px"/></a><br /> '
document.write(livecast);

Que al ser invocado con <script> produce estas 3 columnas de fotos:

El tamaño de los thumbnails y la cantidad de columnas puede ser configurado incluso se podría asignar en una variable del script con un poco de mas trabajo (15 minutos). Pero se podría decir que estamos listos para transmitir en vivo fotos de eventos como FLISOL, FUDcon, Google IO o cualquier otro evento de este estilo.

La segunda versión de este script
Hace poco mas de dos año hice un script que aunque mas propenso a errores por lo que involucraba muchas mas plataformas y herramientas externas, tenia mas funcionalidades. Entre las que mas les ha llamado la atención al LUG de Trujillo (que son con quienes he discutido el tema de este script en especifico) es la marca de agua y la posibilidad de insertar texto en la imagen. Veamos esta foto para que entiendan de que les estoy hablando.

 
Estas fotos fueron de un evento que cubrimos los integrantes de la comunidad subyforums.com, es parte de la copa Koni Challenge. En la parte superior de cada imagen esta información que afecta los resultados de las clasificatorias como por ejemplo temperatura y humedad (impactan mucho a los carros con turbo), hora y fecha. En la parte inferior esta el logo del foro como una marca de agua. Este script se uso durante varios eventos, incluyendo Subaru Challenge 2009, Autoshow de California y el Koni Challenge.

El script se conecta a una casilla de correos, descarga los correos, procesa los archivos adjuntos redimencionandolos y aplicándoles las marcas de agua y la información adicional, ademas de esto se crean las miniaturas de las ultimas 10 fotos para ser compartidas en otras comunidades y se suben todos estos archivos a otro servidor vía FTP donde se servirán finalmente vía HTTP.
En esa entonces use mi NSLU2 que con tan solo 266MHz y 32MB de RAM se demoraba unos 3 o 4 minutos por foto.

Entiendo que el beneficio de este script es que podemos tener fotos del FLISOL o de un Google IO en vivo con por ejemplo la marca de agua del FLISOL y en el tope la información del LUG local. Actualmente tengo algunos ajustes que hacerle al script y solventar un problema que tengo con los certificados para poder usar gmail como casilla de correo y dispongo de poco tiempo.

Pueden descargar el script de este articulo pinchando aqui. Pronto publicare el otro script y les comentare de otro proyecto de este mismo estilo que estoy trabajando en base a unas sugerencias de tatica.

Transmisión en vivo de imágenes es un articulo de: orvtech.com

La preferida por muchos es tcpdump, es una herramienta que simplemente nos permite escuchar todo el trafico de la red y graba todos estos paquetes para que luego los podamos analizar. Si tienes mas de una NIC, puedes especificar por cual quieres escuchar pasándole el parámetro -i interfaz. Una cosa que me gusta es que tcpdump pone tu NIC en modo promiscuo (o por lo menos intenta hacerlo) de forma predeterminada, de esta forma puede escuchar todo el trafico de ese segmento de la red. Para deshabilitar el modo promiscuo y limitar el trafico solo a el que le compete a tu NIC puedes usar el parámetro -p. Hay muchos otros parámetros que puedes usar, recuerda ejecutar man tcpdump para mas información.

Aquí les dejo un video que muestra como saber que sitios web estan visitanto desde nuestra red.

 
Ahora bien, vamos a cuidar nuestras espaldas y supongamos que queremos saber que ordenadores están en tu segmento de red pero queremos evitar enviar paquetes a la red preguntando por estos ordenadores para que no nos delate (recuerda, este tipo de actividad le puede parecer sospechoso al administrador). La herramienta indicada para esta tarea es p0f, esta usa técnicas pasivas para tratar de adivinar que sistemas existen en tu segmento de red y al igual que tcpdump permite especificar la interfaz a usar y grabar trafico guardándolo en un archivo estilo tpcdump.

Nuestras dos herramientas se empiezan a diferenciar a la hora de definir de forma predeterminada el estado de promiscuidad de nuestra NIC, p0f requiere que especifiques que quieres que la NIC este en modo promiscuo y solo escucha cuando un ordenador en nuestra red abre nuevas conexiones. Aquí una lista de parámetros útiles para p0f.

1. -i Especifica la NIC por la que va a escuchar (p0f -i eth0)
2. -w Guarda la salida en formato tcpdump (p0f -i eth0 -w laboratorio.dump)
3. -o Al igual que -w guarda la salida de este comando pero en un archivo de texto sin formato tcpdump
4. -O Proporciona una salida mas descriptiva. Tambien llamado modo ACK
5. -p Indica que quieres que ponga la NIC en modo promiscuo (p0f -i eth0 -p)
6. -s Analiza un archivo que previamente capturaste en formato tcpdump

El problema de todo esto hasta ahora es que es muy probable que el resto de las maquinas esten bajo una NAT y no podamos verlas como tal, solo veremos el router. Uno puede usar el parámetro -M que le indica a p0f que use un algoritmo de detección de enmascaramiento e intenta identificar estas maquinas individualmente.

Supongamos que ya sabemos cuales son los otros ordenadores que existen en nuestra red, ahora lo interesante es saber que tipo de trafico tienen, sera FTP? o tal vez HTTP?, POP?, IMAP? o cualquier otro que sea de nuestro interés. Lo segundo que en mi caso me llama la atención es ver desde donde viene este trafico, con quien se comunican estos otros ordenadores? para responder todo esto podemos usar nuestra tercera herramienta, dsniff.

Esta utilidad al igual que las anteriores nos permite especificar que interfaz queremos usar e incluso podemos usar el parámetro -p para que use archivos que han sido grabados previamente. Puedes habilitar la detección automática de protocolos usando el parámetro -m lo que te va dar detalles crudos de que hacen tus vecinos de red.

La salida de este comando luce algo asi:

~# dsniff -m
dsniff: listening on eth0
-----------------
02/01/11 09:50:19 tcp 10.153.212.26.46004 -> trillian.gtlib.gatech.edu.21 (ftp)
USER anonymous
PASS mailto:axel-devel@lists.alioth.debian.org

-----------------
02/01/11 09:51:50 tcp 10.153.212.26.48257 -> linux.nssl.noaa.gov.21 (ftp)
USER anonymous
PASS mailto:axel-devel@lists.alioth.debian.org

-----------------
02/01/11 09:53:06 tcp 10.153.212.26.39551 -> chernabog.cc.vt.edu.21 (ftp)
USER anonymous
PASS chrome@example.com

Ahora que sabemos quienes están a nuestro alcance, que hacen y con quien, podemos revisar la seguridad de los servicios que prestan, el mas común es el servicio web.

Una herramienta buena para revisar como esta la seguridad de nuestro servidor web es nitko. Puedes seleccionar el hostname con la opción -h incluso puedes pasarle una lista de host o IPs en un archivo de texto. nitko se enfoca en el puerto 80 de forma predeterminada pero puedes alterar esto usando el parámetro -p de hecho tiene un montón de parámetros que puedes usar para pruebas de seguridad especificas… mas de las que quisiera mencionar aquí.
No quería terminar este articulo sin antes mencionar chkrootkit, esta utilidad nos permite analizar sistemas y trata de terminar si han sido manipulados, para ver una lista de las pruebas disponibles puedes usar el parámetro -l. Útil para verificar si el sistema ha sido infectado o si tiene rootkits.

Este articulo es para fines didácticos, para que ‘juegues’ en tu propia red y no para que dañes sistemas ajenos ni adquieras a información que no te pertenece.

Un poco de network sniffing es un articulo de: orvtech.com

Cualquier entra en pánico al darnos cuenta que no teníamos respaldo de este script, pero en estos momentos es cuando mas calma se debe de tener. Analicemos la situación, aun hay procesos usando este archivo, en mi caso aun sigo descargando y compartiendo archivos vía torrents gracias a este script que acabo de eliminar. Lo primero es encontrar el PID para lo cual podemos ejecutar ps y hacer un grep por el nombre del archivo, el resultado tendrá en la primera columna el PID como lo podemos ver aquí:
m1n1m3@localhost ~ $ ps -p |grep -i descargador.sh
30560 pts/3 Ss+ 0:00 /bin/bash /home/m1n1m3/descargas/descargdor.sh

El sistema de ficheros /proc mantiene vínculos a los archivos abiertos por procesos dentro de el sub-directorio fd/ (File Descriptor) que a su vez esa anidado dentro de una carpeta con el nombre del PID del proceso y como acabamos de comprobar nuestro script aun se esta ejecutando.

Teniendo en cuenta el PID que obtuvimos anteriormente y ya que sabemos que la estructura de directorios es /proc/<pid>/fd/ podemos determinar que el archivo que acabamos de eliminar esta dentro de /proc/30560/fd/. Para determinar cual de todos es podemos hacer un ls -la y hacerle un grep por el nombre del archivo a la salida del ls -la. Todo esto se debería de ver así:
m1n1m3@localhost ~ $ ls -la /proc/30562/fd/* | grep descargador.sh
/proc/30560/fd/51 -> /home/m1n1m3/descargas/descargador.sh (deleted)

Para recuperar el archivo eliminado solo debemos copiar el archivo dentro de fd/ a donde queramos, en mi caso, lo quiero restaurar, así que ejecutare:
cp /proc/30560/fd/51 /home/m1n1m3/descargas/descargador.sh

Listo, archivo restaurado.

Nota: Esto funciona también en Android

Recuperar archivos borrados es un articulo de: orvtech.com

BASH como puente entre last.fm y gnewbook

Para este script nesecitamos una cuenta en gnewbook.org y una en last.fm aqui les dejo last.fm2gnewbook.sh
#!/bin/bash
USUARIO=" "
PASSWORD=" "
FMUSER=" "
URL="http://www.gnewbook.org/api/update.php"
ESTATUS=`curl -s http://www.last.fm/user/$FMUSER/tracks | \
grep "/music/" | \
sed -e :a -e 's/<[^>]*>//g;/</N;//ba' | \
sed 's/^[ \t]*//' | sed 's/[ \t]*$//' | \
grep -i [a-z] | \
head -n 1| \
awk '{print "Acabo de escuchar: " $0 ". mientras echaba codigo en #BASH"}'`
curl -u $USER:$PASSWORD -d status="$ESTATUS" --url $URL >> /dev/null
echo "estatus en gnewbook actualizado con: " $ESTATUS

Recuerda asignar los valores de $USUARIO y $PASSWORD con tus datos de gnewbook.org y $FMUSER con tu usuario de last.fm otra cosa que deben de tener en cuenta es que gNewBook aun esta en estado beta y puede que en ocasiones no actualice su estatus (me paso en un par de pruebas).

De last.fm a gNewBook es un articulo de: orvtech.com