Month: mayo 2007

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.

Categories
CSRF Seguridad Web WordPress XSS

Múltiples vulnerabilidades (Cross Site Scripting – Cross Site Request Forgery) en WordPress

Existen múltiples fallos de tipo XSS y CSRF que afectan tanto la versión en desarrollo como a toda la rama 2.x (2.0.x, 2.1.x, 2.2) de WordPress. A diferencia de los reportes anteriores donde ponía a disposición soluciones temporales, esta vez por falta de tiempo y porque los archivos afectados no son imprescindibles para el funcionamiento de un blog, recomiendo que eliminen todos los archivos que se encuentran en wp-admin/import/ puesto que la mayoría de esas páginas son vulnerables.

Me parece que este tipo de fallos van a seguir apareciendo en la siguiente versión mayor (2.2) de WordPress, no sólo porque se agrega nueva funcionalidad, sino también porque muchos usamos plugins y temas vulnerables a XSS, CSRF e inclusive a Inyección de SQL. En mi opinión, mostrar al público los plugins instalados es jugar con fuego, ya que puede ser algo contraproducente para el autor del blog 😉

Nota: Para los curiosos, pueden ver las pruebas de concepto que envié al equipo de desarrollo de WordPress.