Encriptar QueryString en ASP .NET sin modificar código

En un momento de calma y tranquilidad, cuando la aplicación está a punto de ser liberada… muy profesionalmente, el cliente pregunta: ¿Se encriptó la información de la URL?

Es el momento en donde sueltas el teclado y te vas corriendo piensas en lo que eso implica.  —«¿Cómo puedo modificar todo mi código de una manera rápida para encriptar y desencriptar todos los parámetros de todas las URL que manejo en mi aplicación?».

Profundizando en el problema: Necesitamos que «automáticamente» todas las variables que pasan a través de la URL sean cifradas. ¿Por qué? Porqué no quiero desvelarme toda la noche buscando en todos los lugares donde hice Request.QueryString para descifrar el parámetro (eso suponiendo que ya sabemos como cifrar información) y además, en todos los lugares donde envío el parámetro.  —«No me sirve esa opción, no a estas alturas».

Utilizando WebForms, es normal que en muchos lugares (demasiados en mi caso) habrá código como:

//
string valorDeParametro = Request.QueryString["nombreDeParametro"].ToString();
//

(Por cierto, me gusta más la palabra «cifrar» que «encriptar», incluso creo que está mal dicho… pero seguro más personas lo encontrarán con «encriptar», y tal..)

El caso es que se puede solucionar fácilmente. Alguna vez encontré éste método en algún artículo, por más que busqué no lo volví a encontrar. Así que lo dejo como parte de las memorias de ThanksNetwork… Si alguien lo encuentra por favor decidme!.

Entonces, la pregunta del millón ¿que hacemos?. Fácil (una vez que ya lo sabes), pues necesitamos ayuda de los magníficos módulos HTTP.

HttpModules

Los módulos Http son una especie de filtros que pueden «atrapar» un post antes y después de ser enviado. Es decir, pueden pre y post procesar las solicitudes a medida que se van generando. Una gran cantidad de servicios que ofrece ASP.NET se implementan bajo los módulos HTTP, por ejemplo: la seguridad, el estado de la sesión, etc.

El nivel más básico que podemos utilizar es implementando la interfaz System.Web.IHttpModule, basta con ver «desde metadatos» lo que deberíamos implementar:

using System;

namespace System.Web
{
    // Resumen:
    //     Proporciona eventos de inicialización y eliminación de módulos a la clase
    //     que lo implementa.
    public interface IHttpModule
    {
        // Resumen:
        //     Elimina los recursos (distintos de la memoria) utilizados por el módulo que
        //     implementa System.Web.IHttpModule.
        void Dispose();
        //
        // Resumen:
        //     Inicializa un módulo y lo prepara para el control de solicitudes.
        //
        // Parámetros:
        //   context:
        //     Un objeto System.Web.HttpApplication que proporciona acceso a los métodos,
        //     propiedades y eventos comunes a todos los objetos de aplicación existentes
        //     en una aplicación ASP.NET.
        void Init(HttpApplication context);
    }
}

Más información sobre la implementación de los módulos Http

Además, ¿debería estar registrado en algún lado, no? ¿O como se podría configurar mi aplicación para que entienda que cada petición debe pasar por mis clases que implementan la interfaz IHttpModule?

Desde el web.config ¿Por qué no? Por algo debe llamarse archivo de configuración!

<httpModules>
<add type="classname,assemblyname" name="modulename"/>
<remove name="modulename"/>
<clear/>
</httpModules>

Más información sobre el elemento httpModules

Encriptalo ya!

Solución:

Para hacerme la vida fácil, solo crearé una clase (al cliente le importa un carajo SOLID) a la cual bautizaré como QueryString, ésta heredará de IHttpModule (Ojo, sin olvidarnos que es una interfaz y debemos implementar sus métodos).

Y para agilizar mi post, los comentarios de cada situación van dentro del código:

public class QueryString : IHttpModule
{
    ///
/// variables const
    ///
    private const string nombreParametro = "q=";
    //private const string nombreParametro;
    private const string llaveEncriptacion = "key";

    ///
/// Salt para "reforzar" encriptado
    ///
    private readonly static byte[] salt = Encoding.ASCII.GetBytes(llaveEncriptacion.Length.ToString());

    ///
///
    ///
    public QueryString()
	{
        //Algún día necesitaré esto lol
	}

    ///
/// Implementamos Dispose de interfaz
    ///
    public void Dispose()
    {
        //Nothing
    }

    ///
/// Implementamos Init de Interfaz
    /// Con esto construimos un nuevo evento para manejar la petición
    ///
    ///
    public void Init(HttpApplication context)
    {
        context.BeginRequest += new EventHandler(context_BeginRequest);
    }

    ///
/// Evento que maneja la petición
    ///
    ///
    ///
    void context_BeginRequest(object sender, EventArgs e)
    {
        HttpContext context = HttpContext.Current; //Contexto http actual

        if (context.Request.Url.OriginalString.Contains("aspx") && context.Request.RawUrl.Contains("?")) //url contiene ".aspx" && "?" ?
        {
            string query = ExtraerCadena(context.Request.RawUrl);
            string ruta = ObtenerRutaVirtual();

            if (query.StartsWith(nombreParametro, StringComparison.OrdinalIgnoreCase))
            {
                // Desencripta queryString y se vuelve a establecer la ruta
                string rawQuery = query.Replace(nombreParametro, string.Empty);
                string decryptedQuery = Desencriptar(rawQuery);
                context.RewritePath(ruta, string.Empty, decryptedQuery);
            }
            else if (context.Request.HttpMethod == "GET")
            {
                // Encripta queryString y reedirecciona a la url encriptada
                //Encripta todas las queryString automáticamente. ****Eliminar esta parte si no se desea encriptar automáticamente y realizar otras acciones
                string encryptedQuery = Encriptar(query);
                context.Response.Redirect(ruta + encryptedQuery);
            }
        }
    }

    ///
/// Analiza la url actual y extrae la ruta virtual sin usar la queryString
    ///
    /// Ruta virtual de la url actual
    private static string ObtenerRutaVirtual()
    {
        string ruta = HttpContext.Current.Request.RawUrl;
        ruta = ruta.Substring(0, ruta.IndexOf("?"));
        ruta = ruta.Substring(ruta.LastIndexOf("/") + 1);
        return ruta;
    }

    ///
/// Analiza la url y regresa la queryString
    ///
    ///url a analizar
    /// QueryString sin signo "?"
    private static string ExtraerCadena(string url)
    {
        int indice = url.IndexOf("?") + 1;
        return url.Substring(indice);
    }

    ///
/// Encripta cualquier cadena con el algoritmo Rijndael.
    ///
    ///Cadena a encriptar
    /// Cadena encriptada Base64
    public static string Encriptar(string cadenaEntrada)
    {
        RijndaelManaged rijndaelCipher = new RijndaelManaged();
        byte[] textoPlano = Encoding.Unicode.GetBytes(cadenaEntrada);
        PasswordDeriveBytes llave = new PasswordDeriveBytes(llaveEncriptacion, salt);

        using (ICryptoTransform encryptor = rijndaelCipher.CreateEncryptor(llave.GetBytes(32), llave.GetBytes(16)))
        {
            using (MemoryStream memoryStream = new MemoryStream())
            {
                using (CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
                {
                    cryptoStream.Write(textoPlano, 0, textoPlano.Length);
                    cryptoStream.FlushFinalBlock();
                    return "?" + nombreParametro + Convert.ToBase64String(memoryStream.ToArray());
                }
            }
        }
    }

    ///
/// Desencripta la cadena encriptada previamente
    ///
    ///Cadena a desencriptar
    /// Cadena desencriptada
    public static string Desencriptar(string cadenaEntrada)
    {
        try
        {
            RijndaelManaged rijndaelCipher = new RijndaelManaged();
            byte[] datosCifrados = Convert.FromBase64String(cadenaEntrada);
            PasswordDeriveBytes llave = new PasswordDeriveBytes(llaveEncriptacion, salt);

            using (ICryptoTransform decryptor = rijndaelCipher.CreateDecryptor(llave.GetBytes(32), llave.GetBytes(16)))
            {
                using (MemoryStream memoryStream = new MemoryStream(datosCifrados))
                {
                    using (CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
                    {
                        byte[] textoPlano = new byte[datosCifrados.Length];
                        int contador = cryptoStream.Read(textoPlano, 0, textoPlano.Length);
                        return Encoding.Unicode.GetString(textoPlano, 0, contador);
                    }
                }
            }
        }
//Por implementación rápida, cualquier error o cualquier dato extra que introduzca el usuario en la url encriptada o algo por el estilo, lo enviaré a la misma //página de error personalizada
        catch (FormatException)
        {
            HttpContext context = HttpContext.Current;
            context.Response.Redirect("wfrmErrorPagina.aspx");
            return null;
        }
        catch (CryptographicException)
        {
            HttpContext context = HttpContext.Current;
            context.Response.Redirect("wfrmErrorPagina.aspx");
            return null;
        }
        catch (IndexOutOfRangeException)
        {
            HttpContext context = HttpContext.Current;
            context.Response.Redirect("wfrmErrorPagina.aspx");
            return null;
        }
        finally
        {
            //Destruimos o finalizamos lo que necesitemos. No olvidar que existe el método Dispose ;)
        }
    }
}

Una vez teniendo la clase creada, hay que añadirla al Web.config

<configuration>
    <system.web>
       <httpModules>
           <add type="QueryString" name="QueryString"/>
       </httpModules>
    </system.web>
<configuration>

Con todo eso, ya deberíamos estar viendo nuestros parámetros de la URL encriptados, sin necesidad de modificar alguna parte de nuestro código.

Saludos!