El rincón de Zerial » Tips http://blog.zerial.org Informática, GNU/Linux, Seguridad, Hacking, Programación, Ocio Tue, 20 Jul 2010 18:13:34 +0000 en hourly 1 http://wordpress.org/?v=3.0 DPMS y ScreenBlanking: Controlar el ahorro de energía de la pantalla http://blog.zerial.org/linux/dpms-y-screenblanking-controlar-el-ahorro-de-energia-de-la-pantalla/ http://blog.zerial.org/linux/dpms-y-screenblanking-controlar-el-ahorro-de-energia-de-la-pantalla/#comments Tue, 20 Jul 2010 18:13:34 +0000 Zerial http://blog.zerial.org/?p=1795 Despues de una actualización, magicamente, cuando veia alguna película en mi portatil despues de 10 minutos se iba a negro y se apagaba la pantalla. Es un comportamiento normal si pensamos en que el laptop estaba inactivo, pero no me sucedía cuando dejaba corriendo VLC o mplayer. Ultimamente comenzó a suceder … entonces pensé inmediatamente que era la opción DPMS de la X.

Probé poniendo la opción Options “DPMS” “false”, configurando la X usando xset para desactivar la opción de ahorro de energia y tambien probé con vbetool, pero ninguna me dio resultado.

Buscando y buscando, encontré que existen dos opciones: DPMS y ScreenBlanking.

ScreenBlanking: Es un “apagado de pantalla/monitor” de mentira, hace que la pantalla se “apague” y se ponga negra, pero realmente sigue prendida, por lo que solamente le baja el brillo. Por defecto está seteado en 10 minutos.

DPMS: Esta es una función real del manejo de energia para las pantallas. Por defecto pasa a un estado “StandBy” luego de 20 minutos, “Suspend” luego de 30 minutos y “Off” luego de 40.

Para manejar las configurar los parametros de estas opciones podemos hacerlo mediante la configuración de la X o usando xset.

Si ejecutamos xset -q podemos ver la configuración actual:

Keyboard Control:
auto repeat:  on    key click percent:  0    LED mask:  00000000
XKB indicators:
00: Caps Lock:   off    01: Num Lock:    off    02: Scroll Lock: off
03: Compose:     off    04: Kana:        off    05: Sleep:       off
06: Suspend:     off    07: Mute:        off    08: Misc:        off
09: Mail:        off    10: Charging:    off    11: Shift Lock:  off
12: Group 2:     off    13: Mouse Keys:  off
auto repeat delay:  660    repeat rate:  25
auto repeating keys:  00ffffffdffffbbf
fadfffefffedffff
9fffffffffffffff
fff7ffffffffffff
bell percent:  50    bell pitch:  400    bell duration:  100
Pointer Control:
acceleration:  2/1    threshold:  4
Screen Saver:
prefer blanking:  yes    allow exposures:  yes
timeout:  0    cycle:  600
Colors:
default colormap:  0×20    BlackPixel:  0    WhitePixel:  16777215
Font Path:
/usr/share/fonts/misc,/usr/share/fonts/100dpi:unscaled,/usr/share/fonts/75dpi:unscaled,/usr/share/fonts/TTF,/usr/share/fonts/Type1,/usr/share/fonts/misc/,/usr/share/fonts/TTF/,/usr/share/fonts/Type1/,/usr/share/fonts/100dpi/,/usr/share/fonts/75dpi/,built-ins
DPMS (Energy Star):
Standby: 600    Suspend: 600    Off: 600
DPMS is Disabled
Font cache:
Server does not have the FontCache Extension

Fijarse en la sección “DPMS”, aparecen tres valores, standby, suspend, off que estan seteados en 600 segundos, es decir, 10 minutos. Para configurar estos valores debemos hacer lo siguiente:

xset dpms 300 600 900
El primer número corresponde a Standby, el segundo a Suspend y el tercero a Off. Para desactivarlo podemos dejarlo en cero:
xset dpms 0 0 0
Tambien podemos desactivar directamente el DPMS con
xset -dpms
Y para activarlo cambiamos el signo menos (-) por un signo mas: +

Si desactivamos DPMS veremos que seguirá apagandose el monitor, pues debemos desactivar (o aumentar el valor) de ScreenBlanking.

xset s 0
Seteamos el valor a 0 (desactivado).

Para más información les recomiendo el siguiente link (fue el que me ayudó a mi):

http://www.shallowsky.com/linux/x-screen-blanking.html

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/dpms-y-screenblanking-controlar-el-ahorro-de-energia-de-la-pantalla/feed/ 1 Script monitor de sistemas de archivos y particiones http://blog.zerial.org/linux/script-monitor-de-sistemas-de-archivos-y-particiones/ http://blog.zerial.org/linux/script-monitor-de-sistemas-de-archivos-y-particiones/#comments Wed, 14 Jul 2010 19:15:42 +0000 Zerial http://blog.zerial.org/?p=1782 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”

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/script-monitor-de-sistemas-de-archivos-y-particiones/feed/ 1 Creación de passwords aleatorias con /dev/urandom http://blog.zerial.org/linux/creacion-de-passwords-aleatorias-con-devurandom/ http://blog.zerial.org/linux/creacion-de-passwords-aleatorias-con-devurandom/#comments Wed, 23 Jun 2010 14:34:02 +0000 Zerial http://blog.zerial.org/?p=1762

/dev/random es un archivo especial que sirve como un generador de números aleatorios, o un generador de números seudo-aleatorios. Permite el acceso a ruido ambiental recogido de dispositivos y otras fuentes [...] /dev/urandom que reutiliza la fuente interna para producir más bits seudoaleatorios. Esto implica que llamadas de lectura nunca se bloquearán, pero la salida puede contener menos entropía que una lectura de /dev/random. La intención es servir como un generador de números seudoaleatorios criptográficamente seguro. Éste puede ser utilizado en aplicaciones que no necesiten de tanta seguridad. (Wikipedia)

Para generar password aleatorias usaremos una combinación de los comandos tr y head, para poder hacer legible para humanos los bits aleatorios que nos entregará urandom.

Si hacemos un cat directamente a /dev/urandom solamente vamos a ver caracteres raros

Para “traducir” estos bits aleatorios a caracteres legibles por nosotros usaremos translate.

De esta forma, le decimos a tr que nos interprete los bits en caracteres de la A a la Z (mayúscula). Podemos jugar con el juego de caracteres que queremos obtener, por ejemplo decirle que me muestre letras de la a-z y A-Z

Tambien podemos decirle que nos muestre números y caracteres como guión o guión bajo. El comando final quedaria de la siguiente forma:

tr -dc A-Za-z0-9_ < /dev/urandom | head -c 8

Con head -c 8 le diremos que nos muestre solo los primeros 8 caracteres. Podemos cambiar su valor si deseamos caracteres de mayor o menor longitud. Al final de la linea podemos agregarle un && echo “” para que nos muestre un salto de linea al final.

[zerial@balcebu ~]$ tr -dc A-Za-z0-9_ < /dev/urandom | head -c 8 && echo
Z2_gaCcE
[zerial@balcebu ~]$ tr -dc A-Za-z0-9_ < /dev/urandom | head -c 8 && echo
Tob68gN0
[zerial@balcebu ~]$ tr -dc A-Za-z0-9_ < /dev/urandom | head -c 8 && echo
boEzFU3O
[zerial@balcebu ~]$ tr -dc A-Za-z0-9_ < /dev/urandom | head -c 8 && echo
EFfcRcuf
[zerial@balcebu ~]$ tr -dc A-Za-z0-9_ < /dev/urandom | head -c 8 && echo
cTY330uO
[zerial@balcebu ~]$ tr -dc A-Za-z0-9_ < /dev/urandom | head -c 8 && echo
l3UnaDPo
[zerial@balcebu ~]$

O una forma más elegante:

$ tr -dc A-Za-z0-9_ < /dev/urandom | head -c 8 | xargs

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/creacion-de-passwords-aleatorias-con-devurandom/feed/ 1 Violando sistemas: Sniffeando la red http://blog.zerial.org/seguridad/violando-sistemas-sniffeando-la-red/ http://blog.zerial.org/seguridad/violando-sistemas-sniffeando-la-red/#comments Thu, 01 Apr 2010 01:42:12 +0000 Zerial http://blog.zerial.org/?p=1626 Cuando se logra vulnerar la seguridad de un sistema informático y obtenemos acceso al servidor tenemos varias formas de continuar el ataque, ya sea revisando los archivos del servidor buscando información interesante, controlar distintos servicios como el de base de datos o de correo, revisar la información de cada usuario de sistema, dejar una puerta trasera para volver a ingresar al servidor, etc. Una de las cosas que más me gustan es saltar a otros servidores, hacer un análisis de la red y poder tener control sobre la mayor cantidad de máquinas que forman la red, ya sean servidores físicos o virtuales.
El primer paso para armar un diagrama lógico de red es empezare a ver la configuración de la o las tarjetas de red, ver los últimos accesos que se han hecho en forma local o desde la lan, revisar logs, archivo de hosts y obviamente empezar a escanear usando nmap (obviamente de forma local) o alguna otra utilidad que tenga instalada o que podamos instalar. Si no tenemos nmap lo podemos hacer con un simple script en bash que haga ping a todo un rango y nos diga qué dirección está arriba:

#!/bin/bash
NETWORK=192.168.1
FROM=100
TO=110
for x in $(seq $FROM $TO)
do
	ping -c 1 $NETWORK.$x >/dev/null 2>&1
	if [ $? -eq 0 ]; then
		echo $NETWORK.$x is up.
	else
		echo $NETWORK.$x is down.
	fi
done

Una vez que tengamos el mapa mental-lógico de la red podemos empezar a analizar el tráfico que pasa por ellas y acá es donde entran en juego los famosos sniffers, que nos ayudarán a reforzar nuestro diagrama:

En informática, un packet sniffer es un programa de captura de las tramas de red.

Existen distintos métodos y herramientas para sniffear y para envenenar la red.

ettercap Ettercap es un interceptor/sniffer/registrador para LANs con switch. Soporta direcciones activas y pasivas de varios protocolos (incluso aquellos cifrados, como SSH y HTTPS). También hace posible la inyección de datos en una conexión establecida y filtrado al vuelo aun manteniendo la conexión sincronizada gracias a su poder para establecer un Ataque Man-in-the-middle(Spoofing). Muchos modos de sniffing fueron implementados para darnos un conjunto de herramientas poderoso y completo de sniffing.

tcpdump es un herramienta en línea de comandos cuya utilidad principal es analizar el tráfico que circula por la red. Permite al usuario capturar y mostrar a tiempo real los paquetes transmitidos y recibidos en la red a la cual el ordenador está conectado. Está escrito por Van Jacobson, Craig Leres, y Steven McCanne que trabajaban en … (más)

wireshark o ethereal La funcionalidad que provee es similar a la de tcpdump, pero añade una interfaz gráfica y muchas opciones de organización y filtrado de información. Así, permite ver todo el tráfico que pasa a través de una red (usualmente una red Ethernet, aunque es compatible con algunas otras) estableciendo la configuración en modo promiscuo. También incluye una versión basada en texto llamada tshark.

(nota: Las definiciones fueron obtenidas desde Wikipedia)

Luego de identificar qué máquinas nos interesan, podemos aplicar la técnica del hombre en el medio (Man In The Middle) o MiTM para capturar información para poder acceder a otros sistemas.

Link: Top 11 Packet Sniffers

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/violando-sistemas-sniffeando-la-red/feed/ 0 Imagenes y snapshots: Respaldo de servidores http://blog.zerial.org/linux/imagenes-y-snapshots-respaldo-de-servidores/ http://blog.zerial.org/linux/imagenes-y-snapshots-respaldo-de-servidores/#comments Mon, 22 Feb 2010 13:15:02 +0000 Zerial http://blog.zerial.org/?p=1563 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.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/imagenes-y-snapshots-respaldo-de-servidores/feed/ 10 Script para escanear la red en busca de servidores y servicios http://blog.zerial.org/linux/script-para-escanear-la-red-en-busca-de-servidores-y-servicios/ http://blog.zerial.org/linux/script-para-escanear-la-red-en-busca-de-servidores-y-servicios/#comments Wed, 10 Feb 2010 13:40:07 +0000 Zerial http://blog.zerial.org/?p=1515

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.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/script-para-escanear-la-red-en-busca-de-servidores-y-servicios/feed/ 2 SSH, Port Forwarding y Tunneling: Saltarse las restricciones del firewall http://blog.zerial.org/seguridad/ssh-port-forwarding-y-tunneling-saltarse-las-restricciones-del-firewall/ http://blog.zerial.org/seguridad/ssh-port-forwarding-y-tunneling-saltarse-las-restricciones-del-firewall/#comments Sat, 06 Feb 2010 19:59:04 +0000 Zerial http://blog.zerial.org/?p=1502 En mi nuevo lugar de trabajo, misteriosamente está bloqueado por el firewall, entre otras cosas, la salida al puerto 25 de cualquier servidor. Desde mi portatil uso el cliente de correo Thunderbird conectandose a distintas cuentas  de correo que tengo alojadas en Google Apps asi que no podía quedarme sin revisar mis cuentas de correo, por lo que tuve que buscar la forma de hacerlo.
Lo primero que se me vino a la cabeza es hacer un port forwarding con ssh usando un servidor externo, sabiendo que tengo el puerto 22 desbloqueado para salir. Entonces, accedería a cualquier servicio corriendo en el puerto 25 mediante un redireccionamiento a traves del puerto 22. Con esta técnica podemos saltarons el firewall y todas las restricciones.

El port forwarding, según el mismo manual de ssh, corresponde a:

Specifies that the given port on the local (client) host is to be
forwarded to the given host and port on the remote side. This
works by allocating a socket to listen to port on the local side,
optionally bound to the specified bind_address. Whenever a con-
nection is made to this port, the connection is forwarded over
the secure channel, and a connection is made to host port
hostport from the remote machine. Port forwardings can also be
specified in the configuration file. IPv6 addresses can be spec-
ified with an alternative syntax:
[bind_address/]port/host/hostport or by enclosing the address in
square brackets. Only the superuser can forward privileged
ports. By default, the local port is bound in accordance with
the GatewayPorts setting. However, an explicit bind_address may
be used to bind the connection to a specific address. The
bind_address of “localhost” indicates that the listening port
be bound for local use only, while an empty address or ‘*’ indi-
cates that the port should be available from all interfaces.

En simples palabras, lo que se hace, es habilitar un puerto local, por el cual se hara un redireccionamiento, a traves de ssh y el servidor remoto, hacia nuestro destino.

Paso a paso

Mapear la dirección de destino a nuestor localhost, en mi caso (y como ejemplo) usaré smtp.gmail.com. Debemos editar el /etc/hosts y agregar a la línea de 127.0.0.1 nuestro destino:
127.0.0.1 localhost.localdomain localhost smtp.gmail.com
Verificamos:
$ ping -c1 smtp.gmail.com
PING localhost.localdomain (127.0.0.1) 56(84) bytes of data.
64 bytes from localhost.localdomain (127.0.0.1): icmp_seq=1 ttl=64 time=0.038 ms
Ahora, para nuestro sistema, el host smtp.gmail.com está apuntando a nuestra misma máquina.

Ahora, hacemos el port forwading usando el parámetro -L de la siguiente forma:
# ssh -L25:smtp.gmail.com:25 zerial@mydomain.org

Una véz logeados, ya va a estar hecho el redireccionamiento de puerto. Lo que hacemos con esa linea es decirle que todo el trafico desde localhost:25 lo lleve a traves de mydomain.org:22 a nuestro destino smtp.gmail.com:25.

Ahora realizamos la prueba, para ver si realmente tenemos salida a smtp.gmail.com:25:
$ telnet localhost 25
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
220 mx.google.com ESMTP 42sm25383892vws.12

Listo. Obviamente, el Firewall no podrá bloquear el tráfico de localhost y tampoco el de ssh, ya que va cifrado.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/ssh-port-forwarding-y-tunneling-saltarse-las-restricciones-del-firewall/feed/ 1 Emulación de consolas en GNU/Linux: NeoGeo, MAME, SNES y PSX http://blog.zerial.org/linux/emulacion-de-consolas-en-gnulinux-neogeo-mame-snes-y-psx/ http://blog.zerial.org/linux/emulacion-de-consolas-en-gnulinux-neogeo-mame-snes-y-psx/#comments Fri, 15 Jan 2010 01:55:11 +0000 Zerial http://blog.zerial.org/?p=1387 No soy muy amante de los juegos pero debo reconocer que hay algunos que si me gustan, especialmente los de consola como NeoGeo, Súper Nintendo y Play 1. En busca de entretención y de distracción, el otro día me compré un joystick que me costó CLP$1.600 (unos USD$3)

Y luego me puse a probar distintos emuladores y juegos de consolas: NeoGeo, MAME, SNES, N64, PSX, etc.

Para emular juegos de NeoGeo tenemos el gngeo y el mame-sdl, para snes el famoso zsnes, para n64 mupen64 y para psx el epsxe.
A continuación, una pequeña muestra de cada emulador corriendo algún juego en especial.

Primero les voy a mostrar gngeo con su frontend XGngeo

Para descargarlo pueden encontarlo en su sitio oficial http://gngeo.berlios.de/ o bien buscarlo en los repositorios de la distribución que estén usando. Pueden descargar el frontend XGnGeo desde aquí: http://www.choplair.org/?XGngeo

Con el emulador de MAME puedes jugar tambien los juegos de neogeo. Para emular mame tienes el emulador por línea de comando “mame-sdl” y el frontend llamado qmc2.

Para emular súper nintendo, uso el conocido zsnes (muuuuy antiguo), que está en la mayoría de los repositorios de las distribuciónes GNU/Linux y también lo podemos encontrar en zsnes.com.

Yo recuerdo haber usado este mismo emulador hace muchos años atrás, era uno de mis preferidos, con zsnes pasé varias horas frente al pc jugando. El emulador permite configurar hasta 5 players y además, permite jugar en línea.

Para PlayStation 1 (PSOne, PSX) uso el epsxe. Este emulador es un poco complicado de instalar, necesita un plugin para cada cosa. Por ejemplo, un plugin de video y otro de sonido, aunque generalmente puedes encontrar el emulador con todos sus restos dentro del mismo repositorio. Por ejemplo, en Archlinux lo puedes descargar e instalar directamente de AUR. Luego debes intrusear un poco la configuración hasta llegar a la más óptima para tu hardware. En mi caso, me uso este emulador simplemente para jugar Silent Hill 1.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/emulacion-de-consolas-en-gnulinux-neogeo-mame-snes-y-psx/feed/ 2 Bottom Stack en Dynamic Window Manager (DWM) http://blog.zerial.org/linux/bottom-stack-en-dynamic-window-manager-dwm/ http://blog.zerial.org/linux/bottom-stack-en-dynamic-window-manager-dwm/#comments Thu, 07 Jan 2010 00:10:49 +0000 Zerial http://blog.zerial.org/?p=1358 Hace meses que me decidí por usar DWM y de a poco voy teniendo distintas necesidades, por lo que he ido configurando poco a poco el gestor. Ultimamente, me dieron ganas de querer ordenar las ventanas de forma horizontal y revisando el sitio de DWM he encontrado el llamado “Bottom Stack”, que me ayudará a cumplir mi propósito.

Para lograrlo, simplemente tenemos que agregar un par de líneas al config.h y volver a compilarlo.

Debemos descargar los ficheros bstack.c y bstackhoriz.c y agregar las siguientes líneas a nuestro fichero de configuración config.h, despues de la definición de la variable mfact y antes de la definición de layouts:

#include "bstack.c"
#include "bstackhoriz.c"

Y dentro de la definición de layouts debemos agregar:

{ "TTT",      bstack },
{ "===",      bstackhoriz },

El fichero config.h se debería ver mas o menos así:

[...]

/* layout(s) */
static const float mfact      = 0.55; /* factor of master area size [0.05..0.95] */
static const Bool resizehints = True; /* False means respect size hints in tiled resizals */

#include "bstack.c"
#include "bstackhoriz.c"

static const Layout layouts[] = {
        /* symbol     arrange function */
        { "TTT",      bstack },
        { "[]=",      tile },    /* first entry is default */
        { "><>",      NULL },    /* no layout function means floating behavior */
        { "[M]",      monocle },
        { "===",      bstackhoriz },
};

/* key definitions */
#define MODKEY Mod1Mask
#define TAGKEYS(KEY,TAG) \

[...]

Imágenes:

Pueden encontrar el artículo original en el siguiente link:
http://dwm.suckless.org/patches/bottom_stack

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/bottom-stack-en-dynamic-window-manager-dwm/feed/ 2 Error de actualización desde WordPress 2.8 a 2.9 http://blog.zerial.org/tips/error-de-actualizacion-desde-wordpress-2-8-a-2-9/ http://blog.zerial.org/tips/error-de-actualizacion-desde-wordpress-2-8-a-2-9/#comments Sat, 19 Dec 2009 20:51:13 +0000 Zerial http://blog.zerial.org/?p=1272

Hace un rato que actualicé la versión de wordpress de mi blog junto a otros wordpress que administro, pero sólo mi versión tuvo un problema. Me mostraba todas las páginas en blanco. Al parecer no soy el único que tuvo ese problema, ya que puedo ver en distintos sitios a mucha gente que le ocurre lo mismo:

http://es.wordpress.org/2009/12/19/error-de-pagina-en-blanco-tras-actualizar
http://ayudawordpress.com/wordpress-2-9-espanol-ya-disponible/

Algunos hablan de hacer un downgrade y otros hablan de volver a instalar wordpress. Pues yo me di el trabajo de depurar el problema y determinar que archivo era el que estaba generando conflictos.
Al actualizar a wordpress 2.9, al parecerno se está actualizando correctamente el fichero wp-includes/functions.php.

¿Qué hice para solucionarlo?
Simplemente me descargué la nueva versión de WordPress (en español o en inglés) y copié el fichero hacia mi instalación.

Actualización: Se ha publicado una version 2.9.1 Beta 1 donde corrigen, entre otras cosas, éste error.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/tips/error-de-actualizacion-desde-wordpress-2-8-a-2-9/feed/ 8 Acceder a una base de datos, que sólo permite conexiones desde localhost, remotamente http://blog.zerial.org/seguridad/acceder-a-una-base-de-datos-que-solo-permite-conexiones-desde-localhost-remotamente/ http://blog.zerial.org/seguridad/acceder-a-una-base-de-datos-que-solo-permite-conexiones-desde-localhost-remotamente/#comments Fri, 23 Oct 2009 01:06:02 +0000 Zerial http://blog.zerial.org/?p=1047 Hace unos días recibí un correo preguntandome cómo acceder -remotamente- a un servidor de base de datos que sólo acepta conexiones desde localhost, sin tener phpMy/PgAdmin ni acceso “directo” (ssh) al servidor. Responderé publicamente la pregunta.

s_key

La respuesta a primera vista sería “Es imposible, ya que sólo tiene permitido ingresar desde localhost y, generalmente, el puerto no está a la escucha de 0.0.0.0” pero si vamos más allá y tenemos un poco de imaginación, podemos llegar a pensar de que si es posible; jugando un poco con los conceptos y aplicando distintas técnicas de penetración y de búsqueda de vulnerabilidades que nos lo permitan.

La idea de ingresar “remotamente” queda descartada si pensamos en conectarnos directamente a la base de datos desde un client externo, pero podemos pensarlo cómo el hecho de lograr acceder (remotamente) de una u otra forma para lograr la conexion con el host. Por ejemplo, subiendo un fichero php que tenga las líneas necesarias para conectarse a la base de datos y hacer lo que necesitemos.

No vamos a usar fuerza bruta ni técnicas de robo de información, simplemente nos aprovecharemos de algunas vulnerabilidades comunes.

Existen muchas vulnerabilidades que nos van a permitir ejecutar algún tipo de código arbitrario de manera tal de poder conectarnos a la base de datos a nuestra manera. A continuación enumeraré las distintas vulnerabildiades que nos podrían permitir lograr nuestro objetivo.

  • Remote Code Execution (RCE): Mediante ejecución de código remoto, es posible manejar arbitrariamente una conexión a la base de datos y de esta forma obtener y/o modificar los datos que nos interesan. Esta técnica podría permitir al atacante tener un control total sobre la base de datos del usuario en cuestión. Podemos ejecutar comandos como mysqldump o pg_dump en el caso de mysql o postgres, respectivamente. Tambien podemos ejecutar código php usando el la interfáz de línea de comandos (php-cli), python, perl, etc.
  • Local|Remote File Include (L|RCI): Incluyendo ficheros remotos tambien es posible ejecutar código arbitrariamente, tal cómo lo describí en el punto anterior. Podemos escribir un script en php que nos haga un dump de la base de datos y que la deje en un directorio al cual tengamos acceso desde internet para luego poder descarga la información. Tambien se puede usar usando la técnica de inclusión de ficheros locale, siempre y cuando tengamos algún tipo de acceso para lograr subir ese fichero (cómo lo que explicaré en el próximo punto).
  • File Upload by Authentication Bypass: Esta vulnerabilidad es muy común (lo digo por experiencia) y corresponde nada más ni nada menos al hecho de ingresar en un sistema de gestión de contenido y/o usuarios, el cual permita subir algún archivo sin validarlo (o validandolo incorrectamente). Por ejemplo, típico sistema de gestión de usuario que nos permite adjuntar un curriculum, imágen o sistema de gestión de contenido que nos permite subir alguna imágen adjunta o archivo relacionado a alguna noticia o contenido. Muchas veces estos ficheros no son validados correctamente, aveces simplemente usan una triste validación por javascript o simplemente validan la extensión, sin tomar en cuenta el mime. Entonces es cuando debemos subir algún fichero en php o el lenguaje que sea necesario para ejecutar arbitrariamente el código que necesitemos.
  • FTP password discovery: Esto es súper sencillo. Con este punto me refiero al intentar descargar ficheros de configuración (mediante Directori Transversal) y tener acceso a distintos usuarios y claves para probar el acceso ftp y poder subir algún fichero que nos permita lograr nuestro propósito.
  • PhpMy/PgAdmin: Simplemente, con este último punto, quiero hacer referencia a buscar instalaciones de phpmyadmin o phppgadmin en otros sitios del servidor. Generalmente, un servidor aloja más de un sitio web y más de alguno es vulnerable (nuestra puerta de entrada).

Hay veces que hay que recorrer todo el servidor para encontrar una única puerta de entrada. Como bien dije en el último punto, generalmente los servidores alojan más de un sitio web y nunca falta que uno de ellos sea vulnerable, el que nos permita el ingreso directo o indirecto al servidor y de esta forma ejecutar código arbitrariamente.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/acceder-a-una-base-de-datos-que-solo-permite-conexiones-desde-localhost-remotamente/feed/ 5 Cómo validar correctamente la descarga de un archivo en php http://blog.zerial.org/seguridad/como-validar-correctamente-la-descarga-de-un-archivo-en-php/ http://blog.zerial.org/seguridad/como-validar-correctamente-la-descarga-de-un-archivo-en-php/#comments Sun, 18 Oct 2009 13:10:22 +0000 Zerial http://blog.zerial.org/?p=1009 Este post es debido a un correo que recibí preguntando como evitar el full path disclosure y el directory transversal desde un fichero php que realiza descargas. El error que plantearé a continuación es muy común en muchos sistemas web y ya he publicado varias webs vulnerables con este mismo problema. Corresponde a la forma de descarga tipo download.php?dir=ficheros/&file=test.pdf.

secure

Con una URL de este tipo, es posible forzar un FPD modificando las variables “dir” y “test”, cambiadolas por cualquier cosa que sepamos que no existe y de esta forma obtendremos un fichero php con un error, el cual nos revelará el path de la aplicación. Si cambiamos el valor de la variable “dir” a “../../../../../../etc/” y “file” a “passwd”, es muy probable que nos deje descargar el fichero /etc/passwd, lo mismo con cualquier otro fichero. De esta misma forma, podemos ir descargando uno a uno los códigos fuentes del sistema php y poder acceder a los usuarios y claves de conexion a la base de datos y otro tipo de información confidencial.

Me voy a basar en casos reales y tomando como ejemplo los típicos errores e irresponsabilidades de programación de los desarrolladores.

  1. < ?
  2. $nombre = $_GET[‘archivo’]; // Nombre del archivo
  3. $contenido = ‘Texto del archivo’; // Contenido del archivo
  4. $enlace = $_GET[‘folder’]."/".$_GET[‘archivo’];
  5. header ("Content-Disposition: attachment; filename=".$nombre."");
  6. header ("Content-Type: application/octet-stream");
  7. header ("Content-Length: ".filesize($enlace));
  8. readfile($enlace);
  9. ?>

Este es un script que me descargué hace un tiempo y no recuerdo de que sitio, pero es un ejemplo real y lo más probable es que aún esté en línea. Si nos fijamos línea por línea, el script realiza lo siguiente:

Lee las variables directamente desde la URL (GET) y en primera instancia, obtiene el valor de la variable “nombre” y se la asigna a $nombre, esto es para darle el nombre al archivo una vez que lo descarguemos. Luego, en la variable $enlace, guardará el path completo de lo que deseamos descargar, si le pasamos por URL los parametros folder=archivos/&archivo=test.pdf, el valor de la variable $enlace será “archivos/test.pdf”. Luego se enviarle las cabeceras al navegador, el script php leerá el fichero correspondiente al valor de la variable $enlace y forzará al navegador a descargarlo. De esta forma, si modificamos la url a nuestro modo, podremos descargar el fichero que queramos, ya que el script no tiene ninguna validación.

La forma correcta para hacer un script de este tipo, sería sin trabajar directamente con los parametros pasados por url y tenerlos encapsulados en algun lugar, ya sea en una base de datos, un switch o como sea, pero nunca directamente o bien, teniendo definido de forma explícita el directorio donde se trabaja.
Si tomamos el mismo ejemplo anterior y lo corregimos, debería quedar algo así:

  1. < ?
  2. $folder = "archivos_para_descargar";
  3. $nombre = $_GET[‘archivo’]; // Nombre del archivo
  4. $contenido = ‘Texto del archivo’; // Contenido del archivo
  5. $enlace = $folder."/".$_GET[‘archivo’];
  6. header ("Content-Disposition: attachment; filename=".$nombre."");
  7. header ("Content-Type: application/octet-stream");
  8. header ("Content-Length: ".filesize($enlace));
  9. readfile($enlace);
  10. ?>

De esta forma, jamás podremos cambiar el valor de la variable “$folder” y nunca podremos descargar un fichero que esté detrás del directorio de descarga explícitamente definido “archivos_para_descarga”. Esto, sería una forma rápida y fácil de solucionarlo, pero creo que la mejor forma es volver a hacerlo y hacerlo bien. Teniendo un “administrador” de subidas que almacene la información en una base de datos para luego realizar la descarga sólo con el ID del fichero o bien, hacer las descargas directamente con su path absoluto (http://sitio.com/archivos_para_descarga/2009/mi_documento.pdf).

Como ya he dicho, este error es muy común y basta con preparar una búsqueda con los parámetros necesarios en Google para poder acceder a sitios con estas vulnerabilidades. El problema es que con este bug, no solo comprometes la seguridad de tu sistema y de tu usuario, tambien la seguridad del resto de los usuarios del servidor, ya que el script se ejecutará como usuario www-data o apache (en la mayoría de los servidores) y tiene acceso no solo a tus ficheros.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/como-validar-correctamente-la-descarga-de-un-archivo-en-php/feed/ 10 Migración de datos en Drupal http://blog.zerial.org/linux/documentacion/migracion-exportacion-importacion-datos-drupal/ http://blog.zerial.org/linux/documentacion/migracion-exportacion-importacion-datos-drupal/#comments Fri, 02 Oct 2009 01:25:14 +0000 Zerial http://blog.zerial.org/?p=926 drupal_migra Drupal 6 nos provee de una API que nos permitirá trabajar directamente con el core, usando las funciones, módulos y configuraciones ya existentes. De esta forma, y gracias a los hooks, podemos realizar distintas funciones tales como agregar, eliminar y modificar usuarios y contenidos, manejar los comentarios, configuraciones, etc.
La idea de este artículo es ayudar a las personas que necesiten realizar una migración (importación/exportación) desde un sistema distinto hacia Drupal.

Las funciones que necesitamos de la API de Drupal son:

  1. user_save(): Permite la manipulación de los usuarios.
  2. node_save(): Manipulación de los nodos (contenidos).
  3. db_query(): Nos permite realizar consultas a la base de datos usando la configuración de Drupal.

Con estas funciones ya podemos pensar en realizar una migración total o partial de un sitio. La lógica del asunto es sencilla, tenemos que hacer un “wrapper” que conecte ambas plataformas (hablando de base de datos y ficheros), hacer que por un lado se conecte a la base de datos de la plataforma antigua y por otro lado a Drupal, que vaya leyendo los datos desde la plataforma antigua y luego insertandolos en la nueva plataforma usando las funciones de la API, por ejemplo, si tenemos la tabla usuarios con los tipicos campos nombre, email, usuario, password, en Drupal la estructura de la tabla {users} es similar, contiene los campos email, name y pass (los que nos sirven) entre otros. Entonces lo que debemos hacer es un pequeño script que haya un SELECT email, password, usuario FROM usuarios y hacer que cada registro que lea, lo inserte en la tabla {users} mediante la API (función user_save()).
Ejemplo:

  1. $var1 = mysql_query("SELECT email,password,usuario FROM usuarios", $link);
  2. while($data = mysql_fetch_array($var1)){
  3.    $userdata = array(
  4.                         ‘status’ => 1,
  5.                         ‘name’ => $data[‘usuario’],
  6.                         ‘pass’ => ’123′,
  7.                         ‘picture’ => $_avatar,
  8.                         ‘mail’ => $data[‘email’],
  9.                 );
  10.                 user_save(”, $userdata);
  11. }

El tema de la contraseña es más complicado, va a depender únicamente de que si la contraseña está en texto plano o encriptada en la base de datos de origen. Si esta en texto plano, entonces basta con agregar al arreglo userdata el valor $data['password'] a la variable pass. De lo contrario, tendremos que hacer un pequeño truco. Creamos el usuario asignandole una clave fake, por ejemplo 123456 y posteriormente, usando la función db_query, hacemos el UPDATE necesario para cambiarle el password al usuario creado, ingresando directamente el HASH original (pensando que esta en md5).

Para realizar la migración de contenido, el procedimiento es de la misma forma, seleccionar la información de un lado y llevarla a otra usando la función node_save.
Si algo se nos escapa de las manos y no sabemos como hacerlo, basta con que entendamos el modelo de la base de datos e ingresemos directamente las consultas a la base de datos (no lo recomiendo).

Hace unos días me tocó la tarea de realizar la migración de una plataforma X a Drupal, para esto diseñe una clase que me permite hacer la migración paso por paso.

  1. < ?php
  2.  
  3. chdir("api/");
  4. include_once ‘api/includes/bootstrap.inc’;
  5. drupal_bootstrap(DRUPAL_BOOTSTRAP_FULL);
  6. flush();
  7.  
  8. class Drupal{
  9.         private $user;
  10.         private $id_uid;
  11.  
  12.         public $counter;
  13.  
  14.         public function __construct(){
  15.                 $this->id_uid = array();
  16.                 $this->counter = array(‘users’ => 0, ‘news’ => 0, ‘comments’ => 0);
  17.                 $this->clearDatabase();
  18.         }
  19.         public function clearDatabase(){
  20.                 $_queries = array(
  21.                         ‘users’ => ‘DELETE FROM dp_users WHERE name != \’admin\’ AND name != \’asdf\’‘,
  22.                         ‘nodes’ => ‘DELETE FROM dp_node WHERE type NOT IN (\’intro\’, \’adminpage\’)’,
  23.                         ‘comments’ => ‘DELETE FROM dp_comments’,
  24. //                      ‘terms_rel’ => ‘DELETE FROM dp_term_node’,
  25. //                      ‘terms’ => ‘DELETE FROM dp_term_data WHERE tid NOT IN (3, 6)’,
  26.                         ‘groups’ => ‘DELETE FROM dp_og’,
  27.                         ‘groups_uid’ => ‘DELETE FROM dp_og_uid’,
  28.                         ‘groups_ancestry’ => ‘DELETE FROM dp_og_ancestry’,
  29.                         ‘groups_notifications’ => ‘DELETE FROM dp_og_notifications’,
  30.                         ‘dp_job_posting’ => ‘DELETE FROM dp_job_posting’,
  31.                         ‘dp_job_posting_country’ => ‘DELETE FROM dp_job_posting_country’,
  32.                 );
  33.                 foreach($_queries as $query){
  34.                         print ">>[DP_SQL] ".$query."\n";
  35.                         db_query($query);
  36.                 }
  37.         }
  38.         public function createUser($data){
  39.                 $_avatar_base_path = "sites/default/files/pictures/";
  40.                 $_avatar = ($data[‘avatar’] == "usuarioSinAV.jpg")?NULL:$_avatar_base_path.$data[‘avatar’];
  41.                 $_user = array(
  42.                         ‘status’ => 1,
  43.                         ‘access’ => time(),
  44.                         ‘name’ => $data[‘username’],
  45.                         ‘pass’ => ’123′,
  46.                         ‘picture’ => $_avatar,
  47.                         ‘profile_nombres’ => $data[‘nombres’],
  48.                         ‘profile_apellido’ => $data[‘apellidos’],
  49.                         ‘profile_intereses’ => $data[‘about’],
  50.                         ‘profesion’ => $data[‘profesion’],
  51.                         ‘mail’ => $data[‘email’],
  52.                 );
  53.                 $user = user_save(”, $_user);
  54.                 self::_setPassword($user->uid, $data[‘password’]);
  55. //              self::_setUserRole($user->uid);
  56.                 self::_configureProfile($data, $user->uid);
  57.                 if($data[‘admin’]) self::_setAdmin($user->uid);
  58.                 $this->user = &$user;
  59.                 $this->id_uid[$data[‘id’]] = $user->uid;
  60.                 $this->counter[‘users’]++;
  61.         }
  62.         public function createContent($data, $type){
  63.                 $node = new stdClass();
  64.                 $node->type = $type;
  65.                 $node->uid = $this->user->uid;
  66.                 $node->name = $user->user->name;
  67.                 $node->promote = 1;
  68.                 $node->format = FILTER_FORMAT_DEFAULT;
  69.                 $node->status = 1;
  70.                 $node->title = html_entity_decode($data[‘titulo’]);
  71.                 $node->body = $data[‘cuerpo’];
  72.                 $node->taxonomy = self::_convertTaxonomy();
  73.                 $node->comment = 2;
  74.                 $node->created = strtotime($data[‘fecha’]);
  75.                 print ">>[node:".$type."] ".substr($node->title, 0, 30)."… (".substr($node->body, 0, 20)." …) [tax:{".implode(";", $node->taxonomy)."},uid:".$node->uid."]\n";
  76.                 $this->counter[‘news’]++;
  77.                 node_save($node);
  78.                 $q = "INSERT INTO dp_node_access(nid, grant_view, realm) VALUES((SELECT MAX(nid) FROM dp_node),1, ‘all’)";
  79.                 db_query( $q );
  80.         }
  81.         public function insertCommentProfile($data){
  82.                 print ">>[comment;autor:".$this->id_uid[$data['autor']].",uid:".$data['userid']."] (".rtrim(substr($data[‘comentario’], 0, 30))." …)\n";
  83.                 db_query("INSERT INTO {comments} (pid, uid, hostname, comment, status, name, mail, homepage, timestamp) VALUES(%d, %d, ‘%s’, ‘%s’, %d, ‘%s’, ‘%s’, ‘%s’, %d)", $data[‘userid’], $this->id_uid[$data[‘autor’]], ’127.0.0.1′, $data[‘comentario’], 1, ”, ”, ”, time());
  84.                 $this->counter[‘comments’]++;
  85.         }
  86.  
  87.         private function _convertTaxonomy($taxonomy = NULL){
  88.                 $_categories = array();
  89.                 $_categories[] = 29;
  90.                 $_categories[] = 30;
  91.                 $_categories[] = 31;
  92.                 $_categories[] = 32;
  93.                 $_categories[] = 33;
  94.                 $_categories[] = 34;
  95.                 $_categories[] = 35;
  96.                 return array( ($taxonomy)?$_categories[–$taxonomy]:35 );
  97.         }
  98.         private function _setPassword($id, $md5){
  99.                 $query = "UPDATE dp_users SET pass = ‘".$md5."’ WHERE (name != ‘asdf’ AND name != ‘admin’) AND uid = ".$id;
  100.                 print ">>[DP_SQL] ".$query."\n";
  101.                 db_query($query);
  102.         }
  103.         private function _setAdmin($id){
  104.                 $table = "dp_users_roles";
  105.                 //$query = "UPDATE ".$table." SET rid = 4 WHERE uid = ".$id; # 4 es el que corresponde segun SELECT * FROM dp_role
  106.                 $query = "INSERT INTO ".$table."(rid, uid) VALUES(4, ".$id.")"; # 2 es el que corresponde segun SELECT * FROM dp_role
  107.                 print ">>[DP_SQL] ".$query."\n";
  108.                 db_query($query);
  109.         }
  110.         private function _setUserRole($id){
  111.                 $table = "dp_users_roles";
  112.                 $query = "INSERT INTO ".$table."(rid, uid) VALUES(2, ".$id.")"; # 2 es el que corresponde segun SELECT * FROM dp_role
  113.                 print ">>[DP_SQL] ".$query."\n";
  114.                 db_query($query);
  115.         }
  116.         private function _configureProfile($info, $_uid){
  117.                 $uid = $info[‘id’];
  118.                 $query = "SELECT a.nombre_esp FROM cat_paises a LEFT JOIN usr_users b ON b.pais = a.id WHERE b.id = ".$uid;
  119.                 $_r = mysql_result(sqlExec($query, ‘query’), 0, ‘nombre_esp’);
  120.                 db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(8, ".$_uid.", ‘".$_r."’)");
  121.  
  122.                 $query = "SELECT a.nombre_esp FROM paises a LEFT JOIN users b ON b.pais_residencia = a.id WHERE b.id = ".$uid;
  123.                 $_r = mysql_result(sqlExec($query, ‘query’), 0, ‘nombre_esp’);
  124.                 db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(9, ".$_uid.", ‘".$_r."’)");
  125.  
  126. /*                $query = "SELECT a.profesion FROM users a WHERE a.id = ".$uid;
  127.                 $_r = mysql_result(sqlExec($query, ‘query’), 0, ‘profesion’);
  128.                 db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(3, ".$_uid.", ‘".$_r."’)");*/
  129.  
  130.                 $query = "SELECT a.nombre FROM cat_usr a LEFT JOIN usr_users b ON b.categoria = a.id WHERE b.id = ".$uid;
  131.                 $_r = mysql_result(sqlExec($query, ‘query’), 0, ‘nombre’);
  132.                 db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(4, ".$_uid.", ‘".$_r."’)");
  133.  
  134.                 $query = "SELECT a.subcategoria_es FROM areas_ciencia_subcat a, usr_users b WHERE b.area_ciencia_subcat != 0 AND b.area_ciencia_subcat = a.id_subcat AND b.id = ".$_uid;
  135.                 if($_r = mysql_result(sqlExec($query, ‘query’), 0, ‘subcategoria_es’)){
  136.                         db_query("UPDATE dp_profile_values SET value = ‘".$_r."’ WHERE fid = 7 AND uid = ".$_uid);
  137. //                      db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(7, ".$_uid.", ‘".$_r."’)");
  138.                 }
  139.         }
  140. }

Esta clase nos permite crear una instancia para trabajar con Drupal y de esta forma poder migrar usuarios, contenidos, asignar taxonomias/categorias, resetear claves, insertar comentarios, etc. Cada método público debe ser llamado pasando como argumento un array con la información que desea ser insertada. Por ejemplo, una llamda al método createUser:

  1. $_users = mysql_query("SELECT * FROM usuarios", $link);
  2. while($_users_row = mysql_fetch_array($_users)){
  3.         // Llamada a API drupal para crear usuario
  4.         $drupal->createUser($_users_row);
  5. }

Sencillamente, lo que hace este pedazo de código es consultar en una base de datos por todos los usuarios y posteriormente, por cada registro encontrado, llamar al método “createUsers” pasándole como argumento el row correspondiente al ciclo.

Les dejo el script “Migrar.php” que instancia la clase Drupal y hace uso de sus métodos:

  1. < ?php
  2. /*
  3.  * Lunes, 21 de Septiembre del 2009.
  4.  *
  5.  * Migrador de plataformas para
  6.  * Drupal.
  7.  *
  8.  */
  9.  
  10. // Config
  11. require_once("Config.php");
  12.  
  13. $conexion = mysql_connect($host, $username, $password) OR die("Error al conectar a la base de datos.\n");
  14.  
  15. // Llamada a nuestro wrapper
  16. require_once("Drupal.class.php");
  17.  
  18. if(!mysql_select_db($database, $conexion)){
  19.         print "Error al seleccionar la base de datos.\n";
  20. }
  21. else{
  22.         $start = time();
  23.         $drupal = new Drupal();
  24.        
  25.         // Usuarios
  26.         $table = "usr_users";
  27.         $query = "SELECT * FROM ".$table;
  28.         $_users = sqlExec($query, "print_query");
  29.         getRows($_users);
  30.         while($_users_row = mysql_fetch_array($_users)){
  31.                 // Llamada a API drupal para crear usuario
  32.                 $drupal->createUser($_users_row);
  33.                 // Fin
  34.                 $table = "infoc_news";
  35.                 $query = "SELECT * FROM ".$table." WHERE autor = ".$_users_row[‘id’]." ORDER BY fecha";
  36.                 $_news = sqlExec($query, "print_query");
  37.                 getRows($_news);
  38.                 while($_news_row = mysql_fetch_array($_news)){
  39.                         // Llamada a API drupal para crear contenido
  40.                         $drupal->createContent($_news_row, "news");
  41.                         // Fin
  42.                 }
  43.         }
  44.        
  45.         // Comentarios en perfiles
  46.         $table = "usr_comments";
  47.         $query = "SELECT * FROM usr_coments WHERE responseTo = 0";
  48.         $_comments = sqlExec($query, "print_query");
  49.         getRows($_comments);
  50.         while($_comments_row = mysql_fetch_array($_comments)){
  51.                 // Llamada a API drupal para insertar comentarios en perfiles
  52.                 $drupal->insertCommentProfile($_comments_row);
  53.                 // FIn
  54.         }
  55.         $stop = time();
  56.         $time = $stop – $start;
  57.         print "Migration done.\n";
  58.         print "+ Summary:\n";
  59.         print "|- Users:\t".$drupal->counter[‘users’]."\n";
  60.         print "|- Nodes:\t".$drupal->counter[‘news’]."\n";
  61.         print "|- Comments:\t".$drupal->counter[‘comments’]."\n";
  62.         print "|_ Time:\t".date("s", $time)." secs.\n";
  63. }
  64. /* sqlExec()
  65.  * Ejecuta y/o imprime una consulta SQL
  66.  */
  67. function sqlExec($query, $type){
  68.         global $conexion;
  69.         switch($type){
  70.                 case ‘print’:
  71.                         print ">>[SQL] ".$query."\n";
  72.                         break;
  73.                 case ‘query’:
  74.                         return mysql_query($query, $conexion);
  75.                         break;
  76.                 case ‘print_query’:
  77.                         print ">>[SQL] ".$query."\n";
  78.                         return mysql_query($query, $conexion);
  79.                         break;
  80.                 case ‘default’:
  81.                         print "Error en el modo de trabajo.\n";
  82.                         break;
  83.         }
  84.         return NULL;
  85. }
  86.  
  87. /* getRows()
  88.  * Imprime la cantidad de resultados obtenidas desde una consulta
  89.  */
  90. function getRows($resource){
  91.         print "< < ".mysql_num_rows($resource)." rows.\n";
  92. }
  93. ?>

NOTA Estos scripts son los originales que he usado para migrar una plataforma, si alguien quiere darle un uso personal debe hacer las modificaciones correspondientes que se adapten a su propio modelo de datos y a sus propias necesidades.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/documentacion/migracion-exportacion-importacion-datos-drupal/feed/ 0 Jugando con Festival TTS http://blog.zerial.org/tips/jugando-con-festival-tts/ http://blog.zerial.org/tips/jugando-con-festival-tts/#comments Mon, 28 Sep 2009 03:30:17 +0000 Zerial http://blog.zerial.org/?p=979 Festival es un software text-to-speech (TTS) o sintetizador de vóz que nos permite lograr que nuestra máquina nos hable o, más bien, nos lea algún texto. Con un poco de imaginación se pueden lograr cosas bastante simpáticas como hacer que nuestro computador nos diga la hora, nos lea los sitios web o el texto seleccionado o simplemente para ocio.
Existen paquetes para distintas distribuciones, como Archlinux o Debian, entre otras, para instalarlo directamente desde el gestor de paquetesa como pacman o apt-get, respectivamente. Podemos buscarlo como festvox o como festival y para ejecutarlo es súper simple:

comando | festival --tts

Y automaticamente leerá el texto pasado mediante pipe.
Por ejemplo, un sencillo script para que nos diga la hora en español:

  1. #!/bin/bash
  2.  
  3. hora=`date`
  4. hora=`echo $hora |cut -f4 -d " "`
  5. h=`echo $hora |cut -f1 -d ":"`
  6. m=`echo $hora |cut -f2 -d ":"`
  7. s=`echo $hora |cut -f3 -d ":"`
  8.  
  9. echo "Son las $h horas, $m minutos con $s segundos." |festival --tts --language spanish

Cuando usaba fluxbox, tenía uno atajo de teclado para hacer que me leyera lo que tenia en el portapapeles:

xsel --clipboard |iconv -f utf-8 -t iso-8859-1|festival --tts --language spanish

Con esto, pasamos el cotneindo del clipboard a ISO-8869-1 y le decimos a festival que lo lea en español.
Acá hay un video demostrativo de lo que se puede hacer con festival:

www.youtube.com/watch?v=VP3TUDm_9nk

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/tips/jugando-con-festival-tts/feed/ 1 Drupal como Content Management Framework http://blog.zerial.org/mis-cosas/drupal-como-content-management-framework/ http://blog.zerial.org/mis-cosas/drupal-como-content-management-framework/#comments Sun, 27 Sep 2009 19:41:17 +0000 Zerial http://blog.zerial.org/?p=925 drupalEstán muy de moda los CMS (Content Management System) tales como WordPress, Joomla y Jaws, entre otros, por la facilidad y extensibilidad que tienen mediante módulos, plugins, widgets, themes, templates, etc. Desde hace 8 meses mas o menos que estoy en un proyecto que involucra la creación de un sistema para una comunidad de cientificos, usando Drupal.

¿Por qué Drupal?

Drupal pretende ser mucho más que un gestor de contenidos, lo que busca ser es un gestor de comunidades, un framework para gestionar comunidades, lo que yo llamo CMF. Es extensible, permite la reutilización de código, utilización de templates/themes propios y muchas otras cosas.

¿Por qué NO WordPress, Joomla u otro CMS?

Un CMS, com su nombre lo dice, es un sistema gestor de contenidos, están más orientados a blogs o sitios que no implican una cantidad grande de usuarios y contenido y tipos de contenidos. Lo que yo necesitaba, era un framework para gestionar una comunidad.

¿Se entiende?

El sitio en el que estoy trabajando tiene más de mil usuarios y tiene una cantidad enorme de contenido que se va generando día a día, para esto es necesario algo que me permita gestionarlo y que tenga gran parte del código desarrollado, es decir, que existan plugins o módulos ya hechos y que sólo haga falta modificarlos o adaptarlos a lo que necesitamos. Para Drupal encontramos una serie como por ejemplo el conocido OG:

Organic Groups: Enable users to create and manage their own ‘groups’. Each group can have subscribers, and maintains a group home page where subscribers communicate amongst themselves

Con esto tenemos la posibilidad de que los usuarios creen sus propios grupos, manejen sus suscripciones, creen noticias relacionadas al grupo, privadas o públicas, administración y moderación de grupos, etc.
Tambien es posible crear perfiles personalizados para cada usuario usando el módulo ContentProfile:

Content Profile: is module builds user profiles as content (aka nodes), which opens the opportunity to use all the powerful modules for content for user profiles too, e.g. the Content Construction Kit (CCK).

La creación de módulos propios es bien sencilla, sólo hay que entender cómo trabaja los templates, páginas, nodos, etc. La tarea de creación de módulos se facilita bastante gracias a los hooks, con esto es posible modificar comportamientos de otros módulos (contrib y propios del sistema) y lograr tener un control casi completo del sistema. La idea es, por ningun motivo, tocar el core de Drupal, de lo contrario será muy difícil la mantención del sistema (actualizaciones, etc).
Drupal tambien nos provee de una API, muy completa, la cual podemos trabajar usando las funcionalidades y bondades de Drupal sin tener que usar Drupal -valga la redundancia-. Por ejemplo, hace unos meses tuve que usar sólo el módulo “forum” de Drupal para integrarlo con un sitio que ya estaba desarrollado, ajeno a Drupal. Tambien es muy útil cuando se necesita hacer migración de usuarios y/o contenido de una plataforma a otra. Para usar la API sólo necesitamos descargar el código fuente y tener las siguientes líneas:

  1. include_once ‘api/includes/bootstrap.inc’;
  2. drupal_bootstrap(DRUPAL_BOOTSTRAP_FULL);

(siendo el directorio api dónde tenemos el código fuente de Drupal)

Y listo, ya podemos usar todas las funciones o métodos, variables, constantes, etc.

La versión estable actual de Drupal es la 6, se está trabajando en la 7 que será orientada a objetos. El problema de esto, es que cada vez que se lanza una version nueva (4→5, 5→6, 6→7), los desarrolladores deben volver a programar sus módulos, ya que Drupal no tiene compatibilidad retroactiva.

Links:

Drupal Modules: Repositorio muy completo con distintos módulos para distintas versiones de Drupal .
Documentación de la API

Lectura recomendada:

images

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/mis-cosas/drupal-como-content-management-framework/feed/ 1