A ver, una rapidita que me voy de fin de semana :-)

A lo  mejor alguna vez usando una herramienta de monitorización de red (o un simple netstat) has observado que tu ordenador está haciendo peticiones a una URL "sospechosa" como esta: http://sqm.msn.com/sqm/wmp/sqmserver.dll

"¡Diosss! ¡Es cierto, Microsoft nos espía!" habrá pensado más de uno, jajaja

Bueno, realmente es una forma de espiarte anónimamente, pero es una para la que tú explícitamente has dado permiso.

Se trata ni más ni menos del "Programa de mejora de la experiencia del cliente de Microsoft" y que has aceptado como una opción cuando instalabas Visual Studio, SQL Server u otros productos abarcados por la iniciativa. Este programa recopila información anónima sobre el uso de los productos, su rendimiento, etc... para ayudar a microsoft en su mejora contínua, así que no debe preocuparte: no es spyware :-)

¿Cómo me lo quito de encima?

Bueno, cada programa tiene su sitio para desconectarlo. Por ejemplo en Visual Studio 2008 vete a "Help·Customer Feedback Options" (o similar en catellano) y verás aparecer este diálogo:

Desde el mismo se explica en qué consiste el progrma y se da la opción de desactivarlo.

En mi anterior post comentaba los peligros de usar alegremente los controles UpdatePanel de AJAX y mostraba con la excelente herramienta Fiddler cómo eran las peticiones que se enviaban y recibían.

Alguien me ha preguntado cómo hago para poder utilizar Fiddler con el servidor Web de desarrollo que viene con Visual Studio (conocido comunmente como Cassini), ya que por mucho que actives Fiddler por defecto no captura las peticiones hechas a dicho servidor.

El servidor de desarrollo sólo admite peticiones locales y accedemos a ése a través de una URL del tipo:

http://locahost:3572/miapp

Eligiendo un puerto aleatorio de cada vez.

Cuando lanzas Fiddler éste se coloca como proxy de Internet Explorer interceptando todas las llamadas que hace éste a las páginas Web. Lo que ocurre es que IE cuando detecta que una llamada se va a hacer en local (contra localhost vamos) automáticamente hace caso omiso de los posibles proxy que hubiera y lanza la petición directamente, de ahí que Fiddler no funcione.

Podemos solucionar este problema de una manera sencilla usando el siguiente truco.

Modificación al vuelo de la URL en Fiddler

La herramienta Fiddler nos permite responder a diferentes eventos mientras realiza una petición, los cuales podemos interceptar con código de Script. Se puede ver el ´codigo por defecto de estos eventos usando el menú "Rules" de fiddler, así:

Uno de estos eventos se produce justo antes de lanzar la petición desde el proxy y se llama "OnBeforeRequest". Por lo tanto podemos modificar la URL local para que IE piense que es externa, y volver a modificarla en el evento mencionado antes de que el proxy lance la petición. La manera más fácil es añadir a la palabra 'localhost' un punto justo al final. Así IE no la reconocerá como la URL local y la petición pasará a través de Fiddler. En el evento OnBeforeRequest sólo tenemos que añadir los siguiente al principio:

        if (oSession.host.substr(0, 10)=="localhost.")
        {
                 oSession.host=oSession.host.replace("localhost.", "127.0.0.1");
        } 

Esto hace que cuando Fiddler detecta una petición a cualquier url que empiece por "localhost." la transforma en una llamada a la misma URL dentro de "127.0.0.1", que es equivalente.

Obviamente podríamos usar cualquier otro añadido a la URL local para cambiar la petición. Incluso en lugar de un simple punto añadir un subdominio especial del estilo ".local", para que fueran URLs del estilo "localhost.local" o algo así, cambiando por tanto el pequeño código de intercepción en el evento, pero el punto es el camino más rápido y va de maravilla.

Así que ya sabes, haz ese retoque en el evento, y a partir de entonces lanza tu aplicación y justo tras haber lanzado Fiddler añádele un punto a localhost al final para que Fiddler entre en acción y puedas analizar con detalle todo el trasiego de información entre cliente y servidor que produce tu aplicación, incluyendo peticiones AJAX encualquier puerto :-)

Las tecnologías de Microsoft han adolecido tradicionalmente de un problema que es a la vez, paradójicamente, su mayor ventaja: la sencillez aparente de uso. Pienso que  la clave del éxito de Windows, Office y otros muchos productos de la casa de Redmond ha sido y es su sencillez de uso. Pero esta misma sencillez de uso se convierte también un arma de doble filo: hace que la gente se quede en la superficie de las cosas, sin comprender bien las consecuencias de lo que hacen. Ha pasado toda la vida con las versiones de servidor de Windows, y ha pasado y pasa con las herramientas de desarrollo. Al ser fáciles de configurar y utilizar la gente enseguida "controla" la tecnología correspondiente, lo cual es un error grave.

En este caso me estoy refiriendo en concreto a la tecnología ASP.NET AJAX que tanto facilita el desarrollo de aplicaciones de interfaz avanzada para la Web. Desde mi punto de vista el Update Panel es una obra de arte que debería llevar un premio al diseño de componentes y arquitecturas. Antes de su existencia la creación de aplicaciones AJAX era compleja, a pesar de los diversos frameworks para ello que existían. El uso de los Update Panel convierte en algo realmente sencillo el crear aplicaciones Web con capacidad de respuesta rápida y sin refresco de página. Una maravilla vamos.

Lo cierto es que su sencillez ha hecho que la gran mayoría de los que los utilizan lo hagan sin un buen criterio. Todo el mundo "sabe" hacer aplicaciones AJAX hoy en día. Los lamentos vienen después cuando las aplicaciones deben escalar y ser eficientes, como en casi todos los casos en los que se ve a diferencia entre un buen y un mal programador.

Veamos qué pasa cuando colocas un Update Panel en una página ASPX para hacer algo tan tonto como actualizar la hora actual en una etiqueta. En una página vacía colocas un ScriptManager, un Update Panel y dentro de éste una etiqueta y un botón. al pulsar el botón asignas en un evento de servidor la hora actual a la etiqueta, así:

    protected void Button1_Click(object sender, EventArgs e)
    {
        Label1.Text = DateTime.Now.ToShortTimeString();
    }

Una chorrada total. Vale ahora ejecutas y voilá!, mágicamente el Update Panel hace su trabajo y ves aparecer la hora en la eiqueta sin hacer un postback tradicional al servidor ysin que la página ni siquiere parpadee.

Estupendo. Pero vamos a analizar qué pasa entre bambalinas y más en concreto qué información se envía y se recibe a y desde el servidor. Para ello he utilizado a mi fiel amigo Fiddler, el analizador de tráfico que más me gusta. El resultado de la petición de ida y vuelta del Update Panel es el que se puede ver en esta figura:

En la parte de arriba podemos ver la petición que se envía y en la de abajo la respuesta recibida. ¡En total 889 caracteres (casi 1 KB) para realmente obtener una información (la hora) que ocupa solamente 8 caracteres!

Impresionante. Ahora imagínate esta situación en una página compleja en la que el avezado programador se ha dedicado a dejar caer UpdatePanels por doquier (cosa muy común y una mala práctica). Ahí es nada.

Existen formas mucho más eficientes de conseguir lo mismo eficientemente usando el mucho más amplio framework de ASP.NET AJAX, tal y como se explica en nuestro curso de ASP.NET AJAX.

La conclusión es que hay que utilizar las tecnologías con cabeza y comprendiendo lo que se hace. Lo fácil de usar es un arma de doble filo.

Hace un rato, al llegar a casa y quitar de suspensión mi portátil, me encuentro con que me saltan actualizaciones del Sistema Operativo, lo cual me pareció raro porque aún ayer o anteayer tuve que instalar unas cuantas. "Será importante", me dije.

Tengo la buena costumbre de repasarlas siempre antes de que admitir que se instalen, y así me voy enterando de qué me instalan los chicos de Redmond todos los meses. El caso es que la primera de las actualizaciones (KB955020) de hoy ocupaba bastante (56,3 MB) y según indicaba era para actualizar los diccionarios de inglés y alemán (mi sistema de casa está en castellano).

Primera noticia que tengo de que Windows (y no Word u Outlook) incorpora "de serie" un diccionario. Oye, y además resulta que la actualización es considerada importante y me dice que seguramente tengo que reiniciar el equipo:

El caso es que claro, me voy a la KB a ver qué tipo de actualización es esta, porque no me gusta nada reinicair mi equipo y descargarme casi 60MB por una chorrada, y cual sería mi sorpresa cuando veo esto (pulsa la imagen para ir al original):

¿Comorrrrrl? Que mi Windows no va a reconocer en inglés y alemán palabras tan útiles como "Friendster," "Klum," "Nazr," "Obama," o "Racicot". Diosss, me tengo que bajar cuanto antes esta actualización ;-)

¡Hombre, por Dios!, menuda tomadura de pelo, no me fastidies. Imagino que tiene que haber sido un despiste, porque sino no se entiende tamaño desatino. En fin, ya sabes, desmarca la descarga de esa actualización y ahorrarás ancho de banda, tiempo, un reinicio y contribuirás a que Internet vaya un poquito más rápido. Lástima que en el ordenador de la oficina no pueda evitar que se instale (por eso esta mañana tuve que reiniciarlo, en fin).

No digas que no te lo avisé, jeje

Este es un truco muy sencillo pero que puede resultar realmente útil.

Cuando estamos navegando por Internet en busca de información hay veces que nos interesa guardar ciertos contenidos pero:

· A lo mejor no nos permite guardarlos a disco.

· Está deshabilitado copiar y pegar mediante JavaScript (fácil de solucionar, pero un "peñazo")

· La información no nos interesa exactamente cómo está, sino que queremos quitar cosas o añadir algunos comentarios propios que los complementen.

· La página tiene muchas otras cosas alrededor que nos sobran.

· Etc...

Para estos casos hay un snippet de JavaScript puede sernos de gran utilidad. Al utilizarlo lo que conseguimos es que cualquier página que estemos visualizando se convierta en editable, de forma que podamos modificarla a voluntad antes de copiarla (o cortarla) para almacenar el contenido. Así podremos quitar lo que no nos guste, redimensionar gráficos, mover partes de un lado a otro, añadir comentarios, etc... Realmente útil.

Para tenerlo a mano siempre haz lo siguiente:

1. navega a cualquier página. Por ejemplo: about:blank (que es una página en blanco).
2. Agrega esa página a tus favoritos, por ejemplo en la sección de "Vínculos" para que esté siempre a mano en la barra de herramientas
3. Edita el favorito con el botón derecho·Propiedades. En la URL sustituye tu página por el siguiente texto:

javascript:document.body.contentEditable='true'; document.designMode='on'; void 0

¡Listo! Ahora a disfrutar y a editar a tu gusto las páginas :-)

Por cierto, esto funciona tanto en Internet Explorer como en Firefox.

Ya está disponible para que veas on-line la grabación del Webcast que hizimos anteayer Luis Miguel Blanco y yo sobre el uso de rejillas en Windows Forms (él) y en Web (yo).

Puedes verlo pulsando sobre esta imagen:

También te puedes descargar el código de ejemplo desde aquí. En el caso de mi ponencia para la Web tienes disponibles versiones de los ejemplos tanto en VB como en C#. Espero que te resulten útiles.

Y recuerda: si esto te gusta ni te imaginas lo que te pueden gustar y lo que puedes aprender con nuestros cursos on-line de campusMVP :-)

Pues nada, hoy toca cuña publicitaria, pero creo que os va a interesar :-)

Y es que hoy hemos lanzado nuestro nuevo catálogo de cursos de campusMVP. Y esto es sólo el principio, pues a lo largo del verano lo ampliaremos y además iremos lanzando muchas cosas nuevas que estamos seguros de que te van a encantar.

Hemos hecho caso a todo lo que nos han dicho los alumnos últimamente y encontrarás muchas novedades: cursos más baratos, más tiempo para hacerlos, descuentos para desempleados, posibilidad de pagar todos los cursos con tarjeta y cursos gratuitos para que pruebes como se siente un alumno de campusMVP.

Cuantos más cursos elijas más descuentos puedes obtener. Y también tenemos soluciones específicas para las empresas. Nunca fue tan fácil construirte una formación a la carta.

Consulta nuestra nueva oferta formativa y aprovecha el verano para aprender. Échale un vistazo también a la nueva colección de cursos 'Al día en un día', que te permitirá controlar los fundamentos de las últimas tecnologías en unas horas de formación rápida, y a un precio muy asequible.

Finalmente lanzamos una nueva convocatoria de nuestros cursos de formación oficial Microsoft. Comienzan el día 15 de Julio y tenemos varias novedades. A nuestro exitoso curso 70-536 que hemos reformado y mejorado, se le unen la nueva certificación en desarrollo web para Visual Studio 2008, así como un curso oficial de desarrollo de aplicaciones seguras y el curso oficial de Transact SQL para SQL Server 2005-2008.

No te quedes sin plaza y apúntate cuanto antes. ¡Comenzamos el día 15!.

Apúntate a nuestro boletín para estar al tanto de todas las novedades y recibir trucos de programación, noticias y nuestras clásicas secciones de "Gambadas" y "Frikadas", jeje

Pues nada, ahí queda eso :-)

Como es sabido, desde hace ya bastantes años (1.999) la firma digital de documentos tiene validez legal en España. Además se puede utilizar en multitud de trámites con el Gobierno y las Administraciones Regionales y Locales. Por ello fui de los que se dio prisa en sacarle partido y solicitarla para poder firmar contratos, correos electrónicos, etc... Y no sólo yo, sino con el certificado digital de la empresa también.

Bien, el caso es que una de las aplicaciones de firma digital más comunes y utilizadas en el mundo es Adobe Acrobat Professional. Lo que se hace es pasar el documento a PDF y luego con esta herramienta estampar una firma digital en el documento usando el certificado digital correspondiente. A partir de ese momento cualquier mínima modificación del mismo anula la validez de la firma y además se ofrece el "no repudio", es decir, atestigua de forma fehaciente que el que firma el documento es quien dice ser.

Yo dispongo de Acrobat 7.0, que no es la última versión sino una más antigua pero que para lo que yo lo uso me sobra. Cuando lo instalas bajo Windows Vista (o actualizas tu XP a Vista) resulta que las firmas digitales dejan de funcionar. Cuando vas a firmar cualquier documento ya de entrada no te deja elegir todos los certificados, pero además es que cuando elijes uno de los que sí te deja (aunque sea para probar) obtienes un error que dice:

"Creation of this signature could not be completed.
Certificate parsing error:

x.509 parsing error

Error encounted while BER decoding: "

¿Qué diablos es esto?. Además por más que busques en Internet no hay apenas información y en la web de soporte de Adobe menos (desde mi punto de vista son muy malos en este y otros aspectos).

Bueno, pues os voy a dar la solución que he encontrado yo...

Todo el problema viene porque no es capaz de reconocer y leer correctamente un certificado especial que introduce Windows Vista para facilitar las comunicaciones Peer To Peer en Vista (para productos como el Área de Encuentro y otros). El último parche para la versión más reciente del producto (la 8.0 y pico) sí soluciona el problema,pero en el resto de los casos hay que buscarse la vida.

La solución pasa por retirar ese certificado especial. Para ello vete al menú Avanzadas·Configuración de seguridad y en el primer nodo "IDs digitales" verás todos los certificados disponibles:

El certificado "chungo" que debes retirar es el que tiene fecha de caducidad en el año 3008 :-)

Así que selecciónalo y pulsa el botón "ELiminar ID". A partir de ese momento ya te volverá a funcionar de manera normal la firma digital.

Ojo, si crees que puedes necesitar ese certificado en el futuro debes exportarlo antes de borrarlo. Al hacerlo asegúrate de que exportas tanto la clave pública como la privada. Guárdalo en un sitio a buen recauso y si vuelves a necesitarlo sólo tienes que volver a importarlo.

Espero que esto le pueda sacar a alguien de un apuro alguna vez :-)

En mi anterior post hablaba de cómo construir un programa "clon" de la utilidad de línea de comandos Windows RunAs. En esta primera parte vimos cómo se lanzaba un proceso suplantando a un usuario, que era el objetivo principal de la aplicación, si bien es la parte más fácil.

La tarea que nos quedó pendiente de ver es la más complicada y consiste en solicitar al usuario la clave de manera segura, sin que llegue a estar almacenada en claro en la memoria siquiera. Para ello usamos la clase SecureString, que apareció para estos menesteres en la versión 2.0 del framework.

Sin más vueltas vamos a ver directamente cómo se solicita dicha clave y pasamos a explicar los puntos de interés:

        private static SecureString PideClave(string nomUsuario)
        {
            Console.WriteLine("Escriba la contraseña para {0}:", nomUsuario);

            int top, left;
            ConsoleKeyInfo cki;
            SecureString clave = new SecureString();

            top = Console.CursorTop;
            left = Console.CursorLeft;

            bool ModoEntrada = true;
            while (ModoEntrada)
            {
                cki = Console.ReadKey(true);

                switch(cki.Key)
                {
                    //Si se pulsa ESC salimos del bucle
                    case ConsoleKey.Escape:
                        ModoEntrada = false;
                        clave = null;   //devolvemos un null para indicar que el programa debe terminar
                        break;

                    //Con ENTER terminamos la entrada de datos
                    case ConsoleKey.Enter:
                        ModoEntrada = false;
                        break;

                    //Si se pulsa la tecla de borrado hacia atrás hay que "currarse" el eliminar el caracter
                    //y que se vea en la pantalla eso
                    case ConsoleKey.Backspace:
                        if (clave.Length > 0)
                        {
                            Console.SetCursorPosition(left + clave.Length - 1, top);
                            Console.Write(" ");
                            Console.SetCursorPosition(left + clave.Length - 1, top);
                            clave.RemoveAt(clave.Length - 1);
                        }
                        break;
                    
                    //Cualquier otra tecla
                    default:
                        if (Char.IsLetterOrDigit(cki.KeyChar) || cki.KeyChar == '_')
                        {
                            clave.AppendChar(cki.KeyChar);
                            //Se sustituye por un asterisco
                            Console.SetCursorPosition(left + clave.Length - 1, top);
                            Console.Write('*');
                        }
                        break;
                }
            }
            Console.Write("\n");
            return clave;
        }

Básicamente lo que se hace es ir solicitando las letras de la clave una a una, capturando las pulsaciones de las teclas con el método ReadKey de la clase Console. Este método toma un parámetro opcional que indica si se debe mostrar el caracter pulsado por pantalla o no. En este caso le indicamos que debe interceptar la pulsación de la tecla y no mostrarla por pantalla (valor true en el parámetro del método). Lo que hacemos posteriormente es escribir un asterisco. De este modo damos información visual sobre cuántos caracteres se han introducido, pero no los mostramos ni permitimos que se almacenen en lado alguno, sino que los metemos dentro de la cadena segura con su método AppendChar.

También capturamos algunas teclas especiales que se pueden pulsar:

• ESC: con esto devolvemos un nulo que se comprueba en el código llamante parando la ejecución del programa.
• ENTER: finalizamos la introducción de datos dando por válida la contraseña introducida hasta el momento.
• BACKSPACE: la tecla de borrado (con la flechita a la izquierda), que sirve para corregir el último caracter.

Listo. con esto pedimos la clave al usuario sin comprometer la seguridad haciéndola pasar por una cadena normal. Éstas son objetos inmutables que permanecen en memoeria mientras no las reclame el recolector de basura y aunque las "sobrescribamos" (es un decir, por que lo que conseguiríamos es sólo una nueva cadena, ya que no se destruyen al asignarle otro valor a la misma variable, como se comenta en ese post antiguo que referencio).

Exactamente el mismo principio se podría aplicar para pedir de manera segura una clave en una aplicación Windows (capturando letra a letra y sin dejar que éstas se reflejen luego en la interfaz de usuario o en alguna cadena).

También os dejo, como prometí, el código completo del programa RunAsClon (20 KB) para que el que quiera le pueda echar un vistazo. He usado regiones condicionales para laznar el programa de manera cómoda para depurar mientras estamos en modo de desarrollo (debug), pero es lo único a mayores que tiene el código. Lo he hecho con Visual Studio 2008 pero funcionará perfectamente con Visual Studio 2005 también si importas el .cs. He incluido el resultado de la compilación tanto en depuración como en "release" por si alguien lo quiere utilizar directamente sin tener que compilarlo.

Si alguien quiere crear su propio programa RunAs que se ejecute sin pedir la clave al usuario, sino incluyéndola como parte de la lñinea de comandos (no recomendable pero útil en muchos casos) puede tocar ligeramente este código para conseguirlo sin problema.

¡Espero qué te resulte útil!

Esta es la primera parte de una serie de dos. El planteamiento es crear un programa que replique la funcionalidad básica de "RunAs", la utilidad de línea de comandos que permite ejecutar cualquier programa suplantando a otro usuario. Nuestro particular RunAs se encargará de solicitarnos de forma segura la clave para el usuario indicado y luego lanzará el .exe indicado suplantando al mismo y por lo tanto permitiéndonos hacer una escalada de privilegios o, por el contrario, ejecutar un programa con menos privilegios que el usuario actualmente autenticado en el sistema.

Su uso básico es este:

runas usuario ejecutable.exe

o bien

runas dominio\usuario ejecutable.exe

si queremos indicar el dominio también.

En este primer post voy a mostrar lo más sencillo que es lanzar el proceso suplantando a un usuario. Dejaré para el próximo la obtención de la clave del usuario y su almacenamiento seguro y pondré el código completo para descarga.

El código principal del programa es el que muestro a continuación y que ahroa explicaré:

public static void Main(string[] args)
        {
            if (args.Length != 2)
            {
                MuestraUso();
                return;
            }

            //Nombre de usuario a suplantar
            string usuario = args[0];
            string[] partes = usuario.Split('\\');

            SecureString claveSegura = PideClave(usuario);

            //Si no han introducido han pulsado ESC salimos sin hacer nada.
            if (claveSegura == null)
                return;

            //Programa a ejecutar
            string programa = args[1];

            try
            {
                ProcessStartInfo psi = new ProcessStartInfo(programa);
                psi.UseShellExecute = false;

                if (partes.Length == 2)
                {
                    psi.Domain = partes[0];
                    psi.UserName = partes[1];
                }
                else
                {
                    psi.UserName = partes[0];
                }

                psi.Password = claveSegura;

                Process.Start(psi);
            }
            catch (Win32Exception e)
            {
                Console.WriteLine("Se ha producido un error ejecutando la aplicación:");
                Console.WriteLine(e.Message);
            }

Si no se introducen dos argumentos en la línea de comandos se usa el método MuestraUso que muestra por pantalla la ayuda del programa (no lo voy a poner aquí pues es trivial). Para poder depurar el programa deberemos introducir unos parámetros de ejemplo en la pestaña "Debug" de las propiedades del proyecto:

En el primer parámetro se espera el nombre de usuario, el cual puede estar formado (o no) por dos partes: el dominio y el nombre de usuario separado por una barra inclinada "\", por lo que lo separamos para manejarlos indpendientemente.

El método PideClave, el más interesante de todo el código, se encarga de solicitar la clave al usuario de forma segura (lo veremos en el próximo post).

Usamos la clase ProcessStartInfo, aparecida en .NET 2.0, para lanzar el proceso indicado. Como vemos el código es directo excepto por dos o tres puntos interesantes:

1.- Establecemos la propiedad UseShellExecute a false. Esta propiedad sirve para especificar si se usará el Shell de Windows para lanzar la nueva aplicación o si por el contrario se lanzará directamente un proceso. La principal diferencia entre una u otra opción es que si esta propiedad es false podremos redirigir los flujos de consola (entrada, salida y errores) a voluntad. Además sólo nos permitirá lanzar ejecutables, que es el propósito de este programa. Si usásemos el valor true se podrían lanzar también los ejecutable a partir de un archivo asociado con éstos. Así, si pusiésemos "miDocumento.docx" se ejecutaría Microsoft Word, pero en nuestro caso tendríamos que poner el ejecutable siempre (lo que es más adecuado para el propósito de este programa). Todos los detalles en la página de MSDN para UseShellExecute.

2.- Sólo es posible asignar la clave en la propiedad PassWord usando una cadena segura, es decir, una clase SecureString, también aparecida con .NET 2.0. Más en el próximo.

3.- El método Start de la clase Process se usa para lanzar el proceso a partir de la información almacenada en la clase ProcessStartInfo.

El próximo día comentaré lo que es para mi más interesante de todo este programa: cómo pedir al usuario que introduzca su contraseña por consola de una manera segura, sin almacenarla nunca en memoria y usando la clase SecureString. También dejaré entonces el código de ejemplo completo.

¡Hasta pronto!