Los dictadores benevolentes del lenguaje

Quality of implementation, however, is critically important in the satisfaction enjoyed by users of the language. It is the experiential difference between writing Ruby and JavaScript. The factor that, in my view, most affects this quality of implementation is the vision of the original creator. Where the vision is maintained by a single individual, quality thrives. Where committees determine features, quality declines inexorably: Each new release saps vitality from the language even as it appears to remedy past faults or provide new, awaited capabilities.

[...]

Benevolent dictators make decisions about the language in consultation with the community of users. They are notable for being willing to extend the spirit of the language by making hard decisions that large committees almost always eschew.

[...]

A similar benevolent dictatorship exists with C#. The language, as I have mentioned before, is remarkably well tended by a core group in Microsoft headed by Anders Hejlsberg. (Although there is an ECMA standard for C#, Microsoft is the reference implementation, and the company decides the new features.) The result is a language widely loved by its users (Miguel de Icaza: "It's a beautiful languages that is such a pleasure to program in") and admired by others. Lua, Ruby, D, and Perl are other successful instances of this model.

Leído en Dr. Dobb's. "In Praise of Benevolent Language Dictators", de Andrew Binstock.

Nueva vuelta de tuerca a la privacidad en la nube.

Quienes me conocen saben de mi escepticismo sobre la computación en la nube. No es que no me parezca un campo apasionante, que lo es, ni que reniegue de la ubicuidad de los datos y del software, pues la considero una configuración de sistemas informáticos válida e interesante hasta cierto punto y para determinados usos. Lo que no me gusta (ya no como profesional de la informática, sino como usuario de la misma) es que mis datos estén diseminados por el mundo y no sentirme dueño de mi software: que este sea única y exclusivamente un servicio (SaaS).

En lo personal he podido comprobar cómo personas cercanas a mí han sufrido problemas con la disponibilidad del servicio de aplicaciones en la nube y, aunque obviamente esto es algo que puede ocurrirnos con cualesquiera otros de cuantos están involucrados en el proceso, como el acceso a Internet por parte de nuestro proveedor, por ejemplo, lo cierto es que tener un plazo de entrega de un trabajo determinado y no poder llevarlo a cabo porque hay problemas con los servidores puede resultar algo exasperante. De cualquier forma, esto es soluble mediante replicación de servicios y una mejora de la confianza y la asistencia técnica de los mismos.

Sin embargo, que los datos se encuentren en la nube es una cuestión más delicada. ¿Qué empresa dejaría en un servidor remoto el detalle de sus operaciones contables? ¿Y los datos de sus clientes o trabajadores? ¿Almacenaríamos nuestro historial médico en un disco duro “virtual” accesible a través de Internet? ¿Quién nos asegura que los datos no serán robados, como ocurriera recientemente con las cuentas bancarias de usuarios de Sony? ¿Y que no serán usados por nuestra compañía para ofrecernos otros servicios –como publicidad personalizada– al más puro “estilo Google”?

Hasta hace poco, nadie podía asegurarnos que nuestros datos no pudieran ser robados, usados o alterados sin nuestro consentimiento y/o conocimiento. Sin embargo, esta noche leía con interés una noticia sobre un avance en la resolución de esta problemática llevado a cabo por la gente de Microsoft. Se trata de una implementación parcial de un sistema de cifrado homomórfico, en la que se permiten algunos cálculos básicos (sumas, multiplicaciones) que, no obstante, permitirán ser combinados para llevar a cabo operaciones más avanzadas, como funciones estadísticas del tipo del modelo logístico.

Este avance es importante ya que el cifrado homomórfico permitiría vislumbrar un futuro interesante para el almacenamiento de datos en la nube. Sin embargo, desde la publicación del artículo de Ronald L. Rivest en 1978 (On Data Banks And Privacy Homomorphisms) transcurrieron más de 30 años de debates hasta que se ofreció un posible escenario de resolución de un sistema de cifrado homomórfico completo. Fue en su tesis de doctorado, A Fully Homomorphic Encryption Scheme, donde Craig Gentry presentó un modelo matemático completamente funcional; con todo, la gran cantidad de cálculos necesarios para hacerlo funcionar llevaron al experto en seguridad Bruce Schneier a afirmar que transcurrirían al menos cuarenta años más hasta que pudiera ser llevado a la práctica un sistema así de complejo con el mismo rendimiento que uno que no use cifrado. Schneier llegó a sus conclusiones basándose en la ley de Moore y en los datos aportados por Gentry en un artículo acerca del cifrado homomórfico y el tiempo requerido para llevar a cabo las operaciones de búsqueda por parte de un hipotético Google que usase de este mecanismo de cifrado.

El funcionamiento básico del cifrado homomórfico es el siguiente: supongamos un esquema criptográfico con un sistema de cifrado simétrico o asimétrico donde tenemos dos funciones, C(x,k), que cifra el valor ‘x’ usando la clave ‘k’ y otra D(y,k) que descifra ‘y’ usando la clave ‘k’. Entonces podemos afirmar que

D(C(x,k),k) = x

Esto es así para cualquier sistema de cifrado. Se cumplirá que es homomórfico si además existe un conjunto de pares de funciones (F, G) tales que

D(F(C(x,k)) = G(x)

Las funciones F y G pueden ser o no la misma, pero dada F podemos saber G, y viceversa. 

Como resultado de lo anterior, podemos llevar a cabo operaciones sobre los datos cifrados, sin descifrarlos, por lo que el proveedor de servicios no tiene la necesidad de almacenarlos en claro y únicamente nosotros, como clientes, tenemos acceso a los mismos sin cifrar.

¡Ay, qué feliz habría sido nuestro paso por la asignatura de matemática discreta si hubiéramos encontrado ejemplos así de prácticos en el primer año de carrera! ;)

A pesar de lo interesante del avance de Microsoft y sus aplicaciones prácticas en la nube, los esquemas de cifrado con homomorfismo parcial no son demasiado raros. Por ejemplo, uno que todos conoceréis es RSA, que es homomórfico respecto a la multiplicación. Dadas un par de claves pública y privada (K,k), para todo par de valores ‘x’ e ‘y’ se cumple que:

D(C(x*y,k),K) = x*y

Un posible escenario de uso del cifrado homomórfico podría ser el de una empresa que desee hacer uso de un servicio en la nube para almacenar datos de sus clientes. La explotación de una vulnerabilidad en el servidor podría exponer dichos datos al atacante en un sistema como los actuales y, si el servicio almacenase todos los datos cifrados como mejora de la seguridad, el acceso a los mismos sería demasiado penoso. Imaginemos que nuestra empresa desea realizar una consulta sobre sus datos de clientes para obtener aquellos residentes en una provincia determinada que hayan alcanzado un determinado volumen de compras. La consulta sobre la tabla de clientes requeriría ir descifrando cada una de las filas, comprobar si se cumplen las condiciones requeridas y devolverlo, o no, en función de ello. En un servidor que usase el cifrado homomórfico la consulta se haría sobre los datos cifrados directamente, devolviendo únicamente aquellos que se vieran afectados por la consulta y podrían ser descifrados en el propio equipo del cliente sin ser expuestos a “miradas ajenas” en ningún momento.

En resumen, se trata de un interesante avance en lo tocante a la seguridad y la privacidad en la nube, para evitar que esta devenga en nubarrón.


Para saber más:

• Gentry, C., "A Fully Homomorphic Encryption Scheme". [Consultado el 11/08/2011]


• Gentry, C. et al. (2009), "Fully Homomorphic Encryption over the Integers". Eurocrypt 2010. [Consultado el 11/08/2011]


• Gentry, C (2009), "Fully Homomorphic Encryption Using Ideal Lattices". ACM New York.  [Consultado el 11/08/2011]


• Rivest, R. L. et al. (1978), "On Data Banks and Privacy Homomorphisms", Massachusetts Institute of Technology. [Consultado el 11/08/2011]


• Stuntz, C. (2010), "A Math Primer for Gentry's Fully Homomorphic Encryption". [Consultado el 11/08/2011]


• "Análisis forense digital en la nube", artículo en IT-Insecurity. [Consultado el 11/08/2011]

El cuadro que ilustra la entrada es un óleo de J. M. William Turner, "Rain Cloud", y la camiseta la he encontrado en Nerdy T-Shirt.

Primeros pasos con Reflexil (2)

En la entrada anterior veíamos cómo era posible utilizar Reflexil como plugin de Reflector para modificar el valor de una variable, en concreto la que comprobaba nuestra aplicación de ejemplo para permitir el acceso del usuario a la misma. Hoy veremos cómo es posible incluir código propio en un ensamblado .NET para modificar el funcionamiento de la aplicación (inyección de código).

Deseamos que, cuando el usuario haya accedido al programa “crackeado” este realice una serie de acciones; en el ejemplo consistirá únicamente en mostrar un mensaje en pantalla pero podría tratarse de cualquier tipo de comportamiento inesperado. Para ello, creamos una DLL que contiene el siguiente código, la compilamos y la llevamos a la carpeta donde tenemos nuestra aplicación “ContaConta”.

[csharp]
namespace EjemploReflexil
{
public class Sorpresa
{
public static void Infectar()
{
MessageBox.Show("¡Pardillo!", "Sorpresa",
MessageBoxButtons.AbortRetryIgnore,
MessageBoxIcon.Exclamation);
}
}
}
[/csharp]

Partiremos del ejecutable que obtuvimos en la entrada anterior tras sustituir el valor de la contraseña por una cadena vacía (ContaConta.Patched.exe), incluyéndolo en Reflector. El usuario ahora espera utilizar el programa modificado para no tener que introducir contraseña alguna. Cuando el usuario introduce la palabra esperada (ninguna en este caso), la aplicación ejecuta un método que muestra un mensaje de bienvenida. Vamos a insertar una llamada a nuestro método Infectar() de la clase Sorpresa justo cuando esto ocurra.

Lo primero que debemos hacer es incluir una referencia a nuestro ensamblado (Sorpresa.dll).

Damos simplemente el nombre del ensamblado que, recordemos, se encuentra en la misma carpeta que nuestra aplicación:

Reflexil nos avisa de que los cambios que realizamos sobre el código no son visibles de inmediato en las ventanas de Reflector, así que debemos salvar los cambios y proceder a recargar la DLL. Podemos hacerlo desde el menú contextual o en las opciones que habrán aparecido en la zona de trabajo del plugin.

Tras recargar la DLL vemos que el ensamblado aparece ahora referenciado:

Abrimos el código del método Hola(System.String) para proceder a incluir en él la llamada a Sorpresa.Infectar(). Nos situamos sobre la primera instrucción y seleccionamos la opción de crear una nueva operación. Será una llamada (MSIL call) al método que deseamos, de modo que configuramos en el cuadro de diálogo el tipo de operación y de operando.

Seleccionamos, dentro del ensamblado Sorpresa, el método que deseamos llamar

y guardamos los cambios indicando que inserte la operación antes de la que teníamos seleccionada para que esta nueva sea la primera que se ejecute. Ahora guardamos los cambios y ejecutamos la aplicación con el nuevo parche.

Tras pulsar cualquier botón terminaría la ejecución del código inyectado, por lo que la aplicación prosigue con la del código preexistente:

En próximas entradas veremos cómo podemos reemplazar por completo el código fuente de una determinada clase del ensamblado directamente en C# o Visual Basic.NET mediante la opción “Replace all with code...”

Primeros pasos con Reflexil (1)

Una de las ventajas de los compiladores que generan código intermedio es que las aplicaciones resultantes (ejecutables y librerías dinámicas) pueden desensamblarse con facilidad, reconstruyendo el código en su lenguaje original. Con .NET Framework esto es posible, incluso, obteniendo el código fuente descompilado al cualquier lenguaje de la CLI (Common Language Infrastructure), como bien sabréis, así que realizar un ejercicio de ingeniería inversa sobre sus ensamblados es algo, a priori (y sin ofuscador mediante), bastante ilustrativo.

Utilizando una de las herramientas que no puede faltar en la particular mochila virtual de cualquier desarrollador .NET, Reflector, es posible no solo descompilar el ensamblado sino incluso reconstruir un proyecto de Visual Studio que permita editarlo y volver a reconstruirlo. Sin embargo, podemos llegar más allá. Es posible, además, editar desde el propio Reflector un determinado ensamblado y modificar su funcionalidad utilizando el plugin Reflexil. Desarrollado por Sébastien Lebreton, se trata de un proyecto de código abierto que podemos incluir como dentro de los add-in de Reflector para extender su funcionalidad permitiéndonos alterar la funcionalidad de un determinado componente de la correspondiente aplicación ya sea inyectando código (en MSIL, C# o Visual Basic.NET) o modificando alguna de sus propiedades. He estado “jugando” un poco con el plugin y me ha gustado tanto que he decidido traerlo al blog aunque sea, de momento, con una introducción muy básica a algunas de las características que podemos encontrar en él.

Partimos de una aplicación realmente básica que simula un formulario de autenticación de usuarios que permitiría acceder a la misma. En nuestro ejemplo simplemente mostrará un mensaje indicando si el usuario introdujo la contraseña correcta o no. El sistema de protección es realmente rudimentario pero nos servirá a título de ejemplo para comenzar a familiarizarnos con Reflexil.

Si no lo hemos hecho antes, deberíamos bajarnos la última versión del plugin de su página oficial e instalarlo (simplemente descomprimirlo y agregarlo a Reflector a través de su menú View->Add-Ins).

Agregamos el ejecutable (o DLL) que deseamos analizar y modificar; en nuestro caso, ContaConta.exe. Si activamos el plugin (Tools->Reflexil vx.y ) veremos cómo, al acceder a un determinado método, campo o propiedad, aparecen diversas opciones que permiten modificar su tipo, los argumentos recibidos e, incluso, su comportamiento.

Por ejemplo, nuestra aplicación comprobaba simplemente si el usuario introducía el texto necesario para permitirle el paso. Una posible modificación sería eliminar esta palabra de paso. Si nos fijamos en las instrucciones en IL del método que se encarga de hacer la comprobación (el propio delegado que se suscribe al evento del clic de ratón sobre el botón Acceder) veremos que comienza situando en la pila de evaluación una referencia al objeto System.String que contiene la cadena a comparar (operación ldstr) para, a continuación, recuperar el valor que contiene el cuadro de texto donde el usuario introduce la contraseña y realizar una comparación entre ambas. Vamos a editar la cadena para sustituirla por una vacía. Para ello, accedemos al menú contextual de la primera instrucción pulsando de ella con el botón derecho del ratón y accedemos a la opción Edit. Veremos un pequeño cuadro de diálogo desde el que es posible editar el tipo de operación a realizar así como los argumentos con los que es llamada. Borramos de aquí el texto del argumento y aceptamos.

Tras ver cómo ha sido eliminado el valor del parámetro en la lista de argumentos, si queremos comprobar que el cambio ha tenido éxito debemos guardar el ensamblado. Para ello, en el árbol de ensamblados de Reflector pulsamos con el botón derecho sobre ContaConta para acceder al menú Reflexil->Save As… y le dejamos el valor predeterminado (ContaConta.Patched.exe).

Si ejecutamos ahora la aplicación y pulsamos simplemente en el botón de acceso veremos cómo nos deja pasar.

En la siguiente entrada veremos cómo inyectar código propio en un ensamblado .NET existente.

Lunes por la mañana, llegas a trabajar a primera hora y te encuentras con esto:

Empezamos bien... ¿Pero qué le he hecho yo a los hados? ¿Abro una incidencia para que lo resuelvan los chicos de Sistemas? ¿O le pregunto primero a Google?

Hecho lo segundo, te encuentras con la siguiente duda en un foro:

I cannot open the default profile in outlook 2007 since service pack 2 was installed on my vista ultimate 64-bit edition machine by windows update.  I receive the error "Cannot start Microsoft Office Outlook.  Cannot open the Outlook window."  I have created a new profile and it works ok, but would really like to get the settings from the other profile.  Is there anyway to recover this apparently "broken" profile?

Vaya, si es lo que me pasa a mí... Más o menos. El viernes instalé todas las actualizaciones de Windows para descartar un posible problema con aplicaciones desarrolladas en Visual C++ y hoy recibo el mensajito.¿La solución? Si os ocurre lo mismo, basta con arrancar Outlook con el siguiente parámetro:

Outlook.exe /resetnavpane

Y listo. ¡A trabajar se ha dicho!

Examinando los ADS

Hace unos días veíamos cómo podíamos crear varios streams alternativos de datos o ADS en un fichero dentro de un sistema de archivos NTFS. Aunque el manejo y creación de los streams es simple, lo cierto es que los sistemas operativos de Microsoft no han incluido una gestión de los mismos orientada al usuario hasta Windows Vista, y aun en Windows 7 el soporte es mínimo. Se trata, ciertamente, de una característica no destinada al usuario común de los sistemas, sino más bien orientada a usuarios avanzados como los desarrolladores, pero a causa del desconocimiento de esta característica puede ser usada con fines menos benévolos de los que podría esperarse.

En la primera entrada creamos varios ADS sobre un fichero de texto, pero no éramos capaces de saber si un determinado archivo contiene o no ADS. Existe una forma bastante simple y fácil de constatarlo, que no es otra que intentar copiar el fichero a un sistema de archivos que no sea NTFS. En ese caso, Windows nos mostrará una alerta ante la pérdida de estos streams alternativos, si llevamos a cabo la operación:

De hecho, la inclusión de un fichero dentro de un ZIP, por ejemplo, también provoca la pérdida de los streams alternativos. Sin embargo, existe una herramienta que realiza una copia del archivo con sus ADS correspondientes: ntbackup, muy usada para realizar copias de seguridad y con la que tendremos oportunidad de enfrentarnos algo más adelante, cuando llevemos a cabo tareas de gestión de los ADS.

Si os fijáis, junto al nombre del stream se incluye la cadena :$DATA, es decir, está accediendo al bloque de datos del stream indicado. Si recordáis, existía un stream principal equivalente al bloque DATA de sistemas como FAT, que contenía los datos del archivo en cuestión. Por tanto, es posible “invocar” al stream principal del archivo llamándolo con

Mifichero.txt::$DATA

Lo que introduce un pequeño gran problema de seguridad en el acceso a los archivos. Uno de los problemas de anteriores versiones del servidor web IIS era que un usuario malicioso podía ver el contenido de cualquier archivo simplemente llamándolo desde la URL del modo siguiente:

http://miserver/fichero.aspx:$DATA

De hacer esto, IIS no era capaz de reconocer una llamada ASP.NET, por lo que el fichero no se interpretaba por parte del runtime y era servido directamente, quedando expuesto el código fuente.

Sobran las palabras si añadimos que no se trata de un método muy práctico para constatar la existencia de ADS en el sistema. Eso sí, nos sirve además para librarnos de los ADS, ya que el fichero resultante de la copia no los contendrá si decidimos restaurarlo a su ubicación original. Sin embargo, a partir de Windows Vista existe un nuevo parámetro sobre el comando dir, el /R, que permite obtener un listado de estos ADS.

Existen aplicaciones más avanzadas, que podemos usar incluso en Windows XP ó 2000, como LADS. Creada por Frank Heyne su descarga es gratuita y, como veremos, nos permite analizar un directorio y su contenido (con recorrido recursivo mediante el parámetro /s) , exponiendo todos los ADS encontrados y su tamaño. Como curiosidad, veamos su ejecución sobre algunos de los archivos usados en la entrada de introducción a los ADS:

Como veis, el fichero dinos.jpg incluye el identificador de zona que os comentaba, ya que fue descargado de Internet. Por otro lado, MiFichero.txt incluye otro ADS llamado Texto, con el texto del “hola mundo” que incluí en un primer momento en la entrada.

En cuanto al identificador de zona, como curiosidad, el valor se corresponde con la siguiente tabla:

0: Local Machine
1: Intranet
2: Trusted
3: Internet
4: Untrusted
1000 o superior: User Defined

También veíamos el otro día que era posible incluir otros archivos dentro de un stream usando copy o type. Sin embargo, el funcionamiento de ambos comandos no es el mismo. En la siguiente imagen podemos observar, gracias a LADS, que hemos incluido varios archivos en MiFichero.txt. Los de tamaño pequeño (Calculadora.exe, dinos, dinos.jpg) fueron llevados a cabo mediante un comando copy. El tamaño es mucho menor del esperado, y no contienen el archivo completo. Para incluir un archivo dentro de un ADS podemos usar el comando type. Es el caso de los streams calcu.exe y dinos2.jpg.

De hecho, es posible ejecutar la calculadora de Windows desde este stream. Para ello, usaremos la orden start indicando como parámetro el nombre del archivo que contiene el ADS y el nombre del stream. En el ejemplo siguiente vemos cómo, por motivos de seguridad, hay que especificar la ruta completa del archivo que contiene el ADS (la captura de pantalla de error se correspondería con la primera ejecución, que devuelve el mensaje de "Acceso denegado" en la consola de comandos, en el segundo caso se muestra la calculadora de Windows):

Incluso es posible comprobar, dentro de los procesos de sistema, que la calculadora en cuestión se ha ejecutado desde dentro de un ADS. A continuación muestro las capturas de pantalla del Administrador de Tareas del sistema

y del Explorador de Procesos de SysInternals.

Como vemos, los ADS ofrecen un interesante y amplio campo de estudio. En próximas entradas intentaremos centrarnos algo más en la programación y la seguridad.

ADS, una introducción

El sistema de archivos NTFS alberga algunas características que, no por poco conocidas por el usuario son menos usadas por los desarrolladores. Entre otras, cuenta con los flujos alternativos de datos, o Alternate Data Streams (ADS, también conocidos como named streams), que permiten adjuntar información de muy diverso tipo a los ficheros tradicionales. Los ADS van más allá de los metadatos, y permiten incluir tanta o más información como el fichero que los contiene, aunque sus características y, en especial, el escaso conocimiento o publicidad que se ha dado hasta la fecha sobre su existencia constituyen, como cualquier característica desconocida, una vulnerabilidad que puede aprovechar esta debilidad para llevar a cabo ataques sobre nuestros sistemas.

Ya que llevo tiempo deseando escribir sobre el tema, y debido a que en los últimos meses he andado con el blog “a medio gas” por diversos motivos y compromisos adquiridos, creo que lo mejor será presentar una introducción a los ADS para, a continuación, profundizar en el uso que podemos darles desde nuestras aplicaciones.

Como ya refería al comienzo, los ADS son una característica propia de NTFS, por lo que no está disponible en otros sistemas de archivos (FAT, Ext3, …). Es más, si un archivo creado en un sistema que use NTFS incluye uno o más flujos alternativos, éstos desaparecerán al copiar el archivo a otro sistema de archivos que no los soporte. Bueno, en realidad serán eliminados todos menos uno: el que tiene el archivo de forma predeterminada. Pero veamos en qué consiste exactamente un ADS.

En la siguiente gráfica, podemos ver cómo se estructura la información (datos y metadatos) de un archivo en FAT y NTFS. Vemos que en el antiguo sistema de archivos, un hipotético archivo de llamado “nombre.ext” contiene una serie de atributos (sólo lectura, archivo, oculto…) y un bloque de datos, es decir, el contenido real del archivo. En NTFS, por el contrario, el archivo contiene los atributos además de una información de seguridad (permisos) y una serie de streams asociados. El stream principal es el predeterminado que mencionaba antes. No tiene un nombre asociado y se correspondería con el bloque de datos del archivo en FAT. Es decir, al llevar un archivo NTFS a FAT mantendríamos la información de atributos y la del stream principal que se correspondería al bloque de datos, pero se perdería el resto de información, incluidos los streams o flujos alternativos. De hecho, este stream principal es obligatorio, y si por un casual creásemos un archivo directamente accediendo a uno de los streams con nombre (alternativos), el sistema crearía un stream principal de 0 bytes, vacío y sin nombre. Cabría señalar que los atributos se corresponden a todo el archivo, no al stream principal, por lo que todos los flujos son afectados por un cambio en aquellos.

Cuando un programa abre un fichero NTFS, realmente está accediendo al stream principal. Para acceder a uno de los streams alternativos debe interponerse un símbolo de dos puntos ( : ) entre el nombre del archivo y el del stream al que deseamos acceder. Al corresponderse los dos puntos con el identificador de una unidad, para acceder a un stream llamado “MiStream” dentro del archivo “C”, tendríamos que hacerlo con la secuencia con “C: MiStream”, pero el sistema siempre resuelve la ambigüedad creada dando prioridad a la identificación de unidades. Por esto, si lo que deseamos es acceder a un stream, deberíamos hacerlo con “.\C:MiStream”.

Por último, antes de entrar en algunos ejemplos sobre cómo usar los ADS desde el propio sistema operativo, indicar que los directorios también pueden tener asociados diversos ADS con nombre, pero no tienen ninguno principal o por defecto.

Desde la propia consola de comandos de Windows podemos crear y acceder a los ADS de un fichero o directorio. Obviamente, no es la mejor forma de hacerlo; sin embargo, los sistemas operativos Windows 2000 y Windows XP no ofrecen herramientas específicas para trabajar con esta característica de NTFS.

Podemos crear un archivo de texto normal y consultar su tamaño desde la consola de comandos:

Crear un stream alternativo, de nombre “Texto” con un contenido textual es tan simple como escribir sobre ese stream. Como puede observarse, un comando type solamente muestra el contenido del stream principal, el de datos. Para consultar el contenido textual del stream alternativo creado debemos usar el comando more (ni tan siquiera el type funciona, como veremos más adelante en otro ejemplo).

Si vemos el contenido del directorio, observaremos que el tamaño del fichero no ha cambiado, aunque sí la hora de modificación.

Es posible copiar un archivo dentro de un stream. Como vemos en el ejemplo, hemos incluido un archivo de imagen dentro del archivo de ejemplo sin que cambie su tamaño, considerablemente menor al de la imagen incrustada.

Por último, vemos que es posible ver el contenido del stream de texto, pero se nos hace algo más dificultoso recuperar el del binario con la imagen. En la próxima entrada veremos cómo podemos acceder a este contenido en particular.

Ahora bien: ¿para qué se usa, o qué usos podemos darle a los ADS? Bueno, en principio Microsoft introdujo los ADS en NTFS para dar soporte a funcionalidades avanzadas de sistemas UNIX, OS/2 y Macintosh, pero en la actualidad se le dan usos tan interesantes como incluir un identificador de zona (en el ADS Zone.Identifier) con información del la zona del mundo desde la que se ha descargado un determinado fichero de Internet. También algunos metadatos de los archivos, como el nombre de autor, título, comentarios, etc. son almacenados en respectivos ADS. En nuestro caso, como desarrolladores, deberíamos plantearnos la información que queremos almacenar en estos compartimentos y si es necesario realmente usarlos. En principio no debería incluirse información vital para nuestras aplicaciones, ya que una copia del archivo a través de un sistema que no use NTFS haría que se perdiese esta información. Tal vez podría sernos útil para almacenar información fácil de recuperar pero que, con el uso de los ADS, nos permite un acceso más inmediato. Sería el caso de las imágenes a pequeña escala para archivos de imagen (thumbnails), metadatos para documentos… De esta manera el archivo podría almacenarse en cualquier sistema de ficheros, pero en un NTFS mejoraríamos el rendimiento y el acceso a esta información no vital pero sí útil.

Esto es todo, de momento. En sucesivas entradas veremos algunas características más avanzadas de los ADS y, sobre todo, investigaremos un poco en torno al uso que podemos hacer de los mismos desde nuestras aplicaciones.

La gacela encontradiza

Hace tiempo que quiero escribir algunas líneas sobre el nuevo (novísimo) navegador que está forjándose en los hornos de alto rendimiento de Redmond. Se trata de Gazelle, el navegador que acompañará a Explorer 8 en el lanzamiento de Windows 7, y que promete convertirse en su sustituto. Resulta sorprendente que Microsoft anunciase hace unos meses que estaba trabajando en dicho navegador, máxime cuando acababa de lanzar al mercado su Internet Explorer 8. Sin embargo, Gazelle parece destinado a ocupar un lugar destacado entre los navegadores de última generación, como Google Chrome, ya que hace especial hincapié en la seguridad de ejecución de páginas y aplicaciones web, y podría estar destinado a ser el navegador de referencia con La Nube (léase con mayúsculas) de la Internet que está por venir (llamada Azure, por parte de los chicos de Bill).

Gazelle promete ser un navegador rápido y seguro. Actualmente cuenta con unos cuantos de miles de líneas de código en C#, por lo que su ejecución vendrá controlada por el .NET Framework imperante en el momento, el 3.5 y, muy posiblemente, preparado para el 4.0. En el sitio web de Microsoft puede encontrarse un PDF descriptivo con información sobre el navegador, incluidas algunas esquematizaciones del funcionamiento del navegador y su interacción con el sistema operativo, que podrá ser de momento MacOS o Windows ¿Para cuándo GNU/Linux? Chrome, inicialmente, también lo dejó de lado, tal vez por las expectativas que tiene Google con Android, y su posible incursión futura en el mundo de los sistemas operativos.

En cuanto a la seguridad, el navegador considerará cada parte del sitio web por separado (inframe, subframe y plug-ins), intentando minimizar los ataques XSS. En cuanto a su inclusión en Windows 7, parece ser que vendrá determinada por la imposición de la Comisión Europea de incluir navegadores de otras compañías junto al sistema operativo, si Microsoft desea incluir Internet Explorer, así como la posibilidad de que sea desinstalado. En resumen, la antiquísima batalla por los navegadores entre Netscape y Explorer actualizada a fecha de hoy.

Veremos lo que nos depara Gazelle en un mercado cada vez más repleto de opciones a la hora de escoger entre uno u otro navegador. Eso, y si no le sale al paso algún Cheetah browser ;)

La red se mueve

Vivimos días de movimiento en la red de redes. Por un lado, Microsoft se lanza al ruedo de los buscadores, dando carpetazo al proyecto Live Search, que sustituyó en su día a MSN Search y que, como aquél, resultó un proyecto fallido (y no me extraña, porque era un poco regularcillo). Ahora ve la luz Bing, el Microgle, por decirlo de alguna forma. Es decir, el equivalente de Google para Microsoft, de aspecto agradable (parece ideal para planificarnos un viaje por vacaciones), y con algunas opciones interesantes en la búsqueda. Habrá que ver en qué algoritmo se basan para presentar los resultados de búsqueda, pero a priori parece rápido, y ofrece páginas de resultados muy similares a las de Google.

Pero el grande de los buscadores también tiene una oferta que hacernos: Google Wave, o la integración de todos los sistemas de comunicación conocidos: ¿Cómo se concebiría un conglomerado de e-mail, SMS, blogging, twitter, grupos de discusión, news y redes sociales varias? Pues con Wave, con el que Google quiere atraernos a una nube conceptual, donde no sólo residan las aplicaciones, sino también el concepto de uso de las mismas.

Inicialmente, la propuesta es muy aparente, aunque para quienes prefieren no mezclar churras con merinas, como es mi caso, inicialmente no resulte del todo apetecible. Si no quiero un móvil con cámara digital, reproductor de MP3, GPS, pantalla táctil y acelerómetro, sino únicamente un cacharrito que me permita llamar y recibir llamadas, y opto por tener el MP3 en otro dispositivo independiente, ¿por qué iba a querer mezclar correo con redes sociales, por poner un ejemplo? Tras los lanzamientos de nuevas herramientas de Google, siempre ingeniosas, y el buenrrollismo del código abierto y el abrazar todos los estándares habidos y por haber, Google se me antoja como un inmenso gestor de información, del que no me queda muy claro hasta qué punto se impone (o impondrá) límites a sí mismo a la hora de gestionarla y obtener información para el que, hasta ahora, parece su único negocio rentable: la gestión de búsquedas y, por encima de todo, la publicitaria.

Lo que es indudable es que tendremos que echarle un vistazo a fondo cuando lo lancen de forma definitiva. Hay nuevos aires en la red, que no podemos dejar pasar.

Para saber más:

• Sintoniza la onda de Google.


• Google Wave API.


• Google Wave, potencial navaja suiza de la comunicación.

¡Ordenadores para todos!

Entre las noticias que el Presidente del Gobierno hiciese públicas durante el Debate sobre el Estado de la Nación destaca una que, por afinidad a los contenidos del blog y al propio desasosiego que me creó, no puedo resistirme a comentar hoy. Se trata de la iniciativa de otorgar a las familias españolas un “cheque digital” de 50€ por niño y ayudas a la concesión de créditos de bajo coste para la adquisición de ordenadores portátiles que contribuyan a que los niños estudien, en casa y en el aula. Ante esto, me vienen a la cabeza una serie de situaciones, pasadas, presentes y futuras, que no dejan de inquietarme.

La primera, como no podía ser menos, es el actual analfabetismo digital que sufre el país. Por llamarlo de algún modo, esta carencia de conocimientos sobre informática en España es una rémora que venimos sufriendo desde que Infovía era lo más parecido a Internet que teníamos aquí y de aquellos tiempos en los que la conexión a Internet era, a la par que penosa (¡ay, qué fue de aquellos modems a 56Kb!) extremadamente cara. Ah, cierto, salvando las distancias, hoy día sigue siendo cara para el servicio que ofrece, comparativamente hablando, claro está, con respecto al resto de Europa. Obviamente, España necesita modernizarse, entrar de pleno en las nuevas tecnologías, y esta es una labor que debe llevarse a cabo fundamentalmente con los niños. Hasta ahí, totalmente de acuerdo, por más que éste y anteriores gobiernos hayan hecho caso omiso a estas necesidades de modernización.

Dicho esto, y partiendo de la necesidad de acercar la informática a los niños y jóvenes, me embarga un sentimiento de “Abuelo Cebolleta” que me lleva a plantearme cómo hemos llegado a un punto tan crítico en la falta de educación de estas generaciones. No hablo ya del acercamiento a las tecnologías, sino de materias básicas. Los diversos cambios organizativos y estructurales impulsados por las distintas legislaturas han llevado al sistema educativo español a un nivel de paupérrima calidad. Cada vez se enseña menos y peor. Los niños, los jóvenes (y hablo en general, obviamente existen honrosas excepciones que confirman la regla) a día de hoy escriben y se expresan peor, tienen menos conocimientos que antes, menor comprensión lectora… En general, y valga la redundancia, no “aprenden a aprender”. ¿Solucionará esto la introducción de los ordenadores en las aulas? Sinceramente, no lo creo. En mi caso (personal y particular), no me considero un negado para la informática. Para bien o para mal, aquí me tenéis, con más de 20 años a las espaldas de quemarme las retinas frente a monitores TFTs y CTRs, pantallas de fósforo verde y televisores (en los tiempos gloriosos de los 8 bits es lo que había :P), por devoción y profesión dedicado a la informática, y a día de hoy no concibo aprender frente a un ordenador. Aprender, entiéndase, leyendo libros o usando cursos on-line. Y que conste que he sido alumno de numerosas acciones formativas a distancia, con plataformas de todos los sabores, e incluso durante unos cuantos años me dediqué a la docencia, usando entre otros recursos formativos estos portales y otros contenidos multimedia. Sinceramente: se asimila un 50 ó 60%, siendo generoso, de lo que sería posible con un medio más tradicional, y de este porcentaje se retiene una ínfima parte. Entonces, ¿no es posible aprender con un ordenador? Mi respuesta es que sí, pero depende de cómo y de qué, los resultados serán mejores o peores. A todo esto habría que sumarle la reticencia del profesorado (como en el caso anterior, generalizo pero por desgracia la tendencia es la que describo) a reciclarse, a acercarse y aprender sobre nuevas tecnologías. Triste pero cierto, los docentes no quieren ser discentes para mejorar en su trabajo.

Por último, y pasando a un plano más técnico, se me ocurre pensar en qué condiciones establecerá el Gobierno a la hora de otorgar las ayudas, o seleccionar los equipos que deberán usar los alumnos. ¿Se decantará por una alianza con Microsoft u otras grandes compañías de software para preinstalar en los equipos el sistema operativo y software ofimático necesario para sacarles partido? ¿Pagaremos de nuestro bolsillo 100 milloncejos de euros al año en licencias? ¿O se optará, como ya están haciendo las Comunidades Autónomas de Extremadura, Andalucía y  la Comunidad Valenciana con sus distribuciones de GNU/Linux, por promocionar  y usar software libre? ¿Y el hardware? Se habla de portátiles (infiero que netbooks), muy prácticos pero a la vez difícilmente actualizables. ¿Qué ocurrirá con los equipos que vayan quedando obsoletos? ¿Se obligará a los distribuidores a garantizar su reciclado? ¿Se exigirá que cumplan con directivas internacionales en torno a eficiencia energética? Muchas preguntas y muy pocas respuestas.

A vosotros, ¿qué os ha parecido la noticia? ¿Cómo enfocaríais un proceso de enseñanza guiado por medios informáticos? ¿Qué tipo de requisitos exigiríais a los equipos y al software instalado en los mismos?

Para leer más sobre esta noticia, y conocer algunas posturas al respecto:

• La noticia en El País.


• El atraco escolar, en la Asociación de Internautas y en blog El Incordio.
  


• En Periodista Digital.


• Stallman al rescate ;)


• Y la opinión de las compañías.

Actualización, a 19 de mayo de 2009:

He encontrado un par de recursos interesantísimos en torno al aprendizaje utilizando libros electrónicos, que me encantaría compartir con vosotros:

• El futuro de los libros de texto, por Jordi Adell.


• Libros de texto u ordenadores.

Cierre la puerta al salir

Hay ocasiones en las que es necesario impedir que un ordenador sea reiniciado o apagado de forma involuntaria,  sin llevar a cabo una serie de tareas, generalmente de mantenimiento o de seguridad (copias de respaldo, "limpieza" con herramientas del tipo de CCleaner). Puede ocurrir, simplemente, que deseemos programar estas tareas para que se ejecuten al final del uso diario de nuestros equipos, o bien prevenir posibles olvidos por nuestra parte.

Ante casos así, podemos echar mano de los scripts de Windows (Windows Script File .WSF, para Windows Script Host). Estos ficheros, muchos los conoceréis, albergan un script en algún lenguaje común (VBScript, JScript, Perl…), y permiten automatizar diversas tareas dentro de entornos Windows. Hasta cierto punto, guardan diversas similitudes con los scripts de NAnt y similares, que vimos en días pasados, aunque el uso que podemos dar a los mismos es ciertamente distinto.

Un script muy básico, que ejecutaría el shutdown.exe –a, podría ser el siguiente:

[?XML version="1.0"?]
[?job error="true" debug="true"?]
[job id="StopShutdown"]
 [script language="VBScript"]
  Set WshShell = WScript.CreateObject("WScript.Shell")
   WshShell.Run("%windir%\system32\shutdown.exe -a")
 [/script]
[/job]

Se trata de un XML al que he cambiado por [ y ], para que se visualice correctamente en el blog. Para utilizarlo basta con volver a reemplazar estos signos por los originales, y guardar el archivo con extensión .WSF. Para ejecutarlo bastaría hacer doble click sobre el mismo. Con un script de este tipo conseguiríamos lo mismo que con un acceso directo a dicha herramienta, con el mencionado parámetro: detener el reinicio de nuestro sistema, cuando se ha ejecutado un shutdown, o se ha procedido a iniciar un reinicio de sistema (siempre que lleguemos a tiempo, claro está).

Ahora bien, ¿cómo conseguimos que nuestro script “abortareinicios” se ejecute al apagar el ordenador? Basta, simplemente, con incluir el script dentro de la lista de scripts de inicio y finalización del sistema, en las políticas de grupo, para este usuario. Así, ejecutamos gpedit.msc desde Inicio->Ejecutar, y tendremos ante nosotros el cuadro de diálogo Group Policy (Directiva de Equipo Local). Dentro de User Configuration, Windows Settings, Scripts (Logon/Logoff), hacemos doble clic en Logoff, e incluimos el script que acabamos de crear. Guardamos los cambios y probamos a reiniciar el equipo. A ver qué pasa ;) .

Pues, ciertamente, que el ordenador se apaga. Sin embargo, si os decidís a probarlo (este, u otro script cualquiera), observaréis cómo Windows procede, durante el apagado o el reinicio, a llevar a cabo una nueva fase de ejecución de scripts de cierre. Cuando ha llegado a esta fase, me temo, ya no es posible dar marcha atrás al proceso de apagado, pero sí podemos usar los scripts para llevar a cabo otras tareas de finalización.

Ahora bien, ya por curiosidad malsana, ¿se os ocurre algún modo de impedir el reinicio indebido del sistema por parte de los usuarios?

Para saber más:

• Microsoft TechNet Script Center.


• PCTools Scripting Guide.


• Windows Scripting.
  

Asistente para Interop

Hay múltiples ocasiones en las que tenemos que utilizar código nativo desde una aplicación manejada en .NET. Es el caso habitual de tener que reutilizar aplicaciones o componentes COM antiguos, desarrollados tiempo atrás en lenguajes como el obsoleto Visual Basic y para los que no está prevista una migración a .NET, o bien cuando debemos trabajar con drivers y componentes a bajo nivel, programados habitualmente en C/C++. En esos casos, tenemos que vérnoslas con Interop y, de paso, con la conversión de tipos entre las distintas tecnologías.

Dicha tarea no tiene porqué ser necesariamente dificultosa (aunque puede provocarnos más de un dolor de cabeza si decide no funcionar, a la hora de llevar a cabo depuraciones y averiguar a qué componente corresponde la responsabilidad del problema que nos estemos encontrando), pero sí es, como mínimo, tediosa. Por eso, los chicos de Microsoft lanzaron hace tiempo una herramienta que, he de confesarlo, no había probado hasta ahora, que andaba investigando un poco el tema y me he topado de frente con ella. Se trata de PInvoke Interop Assistant, un asistente que genera automáticamente el código en C# o VB.NET que maneja las llamadas a la API de Windows y DLLs provenientes de código no manejado (desarrollado en C).

Como puede verse en las capturas que adjunto, basta con consultar en la API de Windows, de la que ya trae información, o cargar una DLL que contenga su correspondiente manifiesto para obtener el código fuente correspondiente.

Toda una ayuda para los desarrolladores que tengan que enfrentarse al marshalling entre código manejado y nativo. La herramienta, documentación y código fuente asociados pueden descargarse desde la página del grupo en CodePlex.

De puente a puente...

Llega un nuevo fin de semana y, siendo algo más prolongado de lo habitual, es el momento ideal para ponernos al día con tantas cosas como quedan pendientes debido al ajetreo diario y la semana de trabajo. Entre otras, podríamos citar las lecturas atrasadas, probar tal o cual elemento que despertó nuestro interés (desde software a un dispositivo del tipo que sea), investigar un poco o, simplemente, descansar. Sirvan como propuestas algunas de las lecturas que despertaron mi interés durante la semana, y alguna que otra situación que me resultó curiosa.

Empiezo, como viene siendo habitual, dando un pequeño (brevísimo) repaso a algunas entradas de blogs de informática que me llamaron la atención. El primero de ellos es un nuevo descubrimiento, el blog de Versvs que he llegado a conocer gracias a la entrada que publicaba días atrás Sergio Hernando, y que os recomiendo encarecidamente. De su autoría es también el libro La sociedad de control, un texto más que interesante que he empezado a leer con fruición, y que por lo que veo en su web ya está a la venta en formato, digamos, tradicional. Así que una buena descarga para disfrutar y aprender (a la par que reflexionar) estos días, y un (auto)regalo seguro.

Muy relacionada con esta sociedad de control, en los últimos días se han producido bastantes manifestaciones de repulsa en contra de la última jugada del Gobierno en connivencia con la siempre “amiga de los niños” SGAE. Se trata, claro está, de la ingeniosa, imaginativa y singular campaña, Si eres legal, eres legal. Me habría gustado escribir algo al respecto, pero la verdad es que la semana vino un poco cargada y apenas pude preparar ese par de entradas que “adornaron” el blog, más parado que nunca. Sin embargo, material de lectura hay, y mucho. Os recomiendo, por ejemplo, las entradas de Informática Verde, de Mangas Verdes (que es un punto de entrada a muchas otras que giran en torno a la misma cuestión). Por cierto, y aunque no venga al caso más que por el nombre de la campaña: si eres informático, ¿qué se supone que eres? Curioso dilema, digno de figurar en alguno de los libros de Smullyan, ¿verdad?

En fin, ya que sigo hablando de libros os voy a recomendar otro. Viene directo de la imprenta del Imperio, pero resulta muy interesante. Es la Application Architecture Guide 2.0 del grupo de patrones y buenas prácticas de Microsoft. Es un documento Beta 2 (que debe ser algo así como 0.0.0.1.1), pero que ya os adelanto que pinta bien. Podéis descargarlo desde su página web y es free, colegas. Otra lectura para la saca.

Seguimos con la programación, y en esta ocasión con el blog PHP Senior, de Enrique Palace, que también resultar ser un descubrimiento reciente, de la última semana, gracias a una serie de artículos-guía que debe seguir un programador para convertirse en un as del PHP. De hecho, lo que buscaba no era eso, sino buenas prácticas en programación orientada a objetos para brindar lecturas interesantes a unos alumnos de .NET, y en cualquier caso, como os digo, resulta un blog con artículos de calidad. Por cierto, días después me sorprendí encontrando un enlace desde el blog de DES, en un artículo sobre buenas prácticas de desarrollo.

Se me quedan en el tintero bastantes cositas de interés, como siempre, pero no quería despedir la semana sin recomendaros una página que vi a través de Eco Microsiervos. Se trata de un buscador inmobiliario (Real State Tool) que se encarga de encontrar la vivienda ideal en función de nuestra vida diaria (familiar). Le damos información sobre nuestros trabajos, la escuela de los niños, la dirección de la biblioteca que más frecuentamos o nuestro gimnasio, y se encarga de buscar la localización más idónea para la vivienda, minimizando los desplazamientos hasta el lugar. Una forma más de ser un poquito más eco, y perjudicar menos nuestro medio ambiente. Por lo pronto he hecho la prueba y creo que a mi querida Lycis le daré una alegría. Nos sugiere mudarnos (lo haremos en breve) a una zona que ella se había planteado.

¡Buen fin de semana!

Pruebas de caja blanca automatizadas en .NET

Una de las tareas más tediosas a la hora de desarrollar pruebas unitarias sobre código existente es tener en cuenta todas las posibles entradas y flujos de ejecución. Sin embargo, es necesario (imprescindible incluso) un correcto control de ambos aspectos durante el desarrollo de nuestras aplicaciones. Durante el proceso de desarrollo, las prácticas recomendadas por metodologías como la Programación eXtrema (XP) y el Desarrollo Guiado por Pruebas (TDD) nos dicen que debemos escribir los tests necesarios para validar el código que estamos creando. Sin embargo, no se nos dice qué pruebas debemos escribir, aunque sabemos que las pruebas, si están bien escritas son, además de una herramienta insustituible para la verificación del código, un modo de reflejar mediante código las especificaciones que deberá cumplir nuestro código.

Por todo esto, Microsoft ha preparado un nuevo framework (sí, uno más, a mí también me sorprendió cuando me hablo del mismo un compañero de trabajo) que permite facilitar la tarea del desarrollador mediante la creación de pruebas unitarias mediante la inspección automática del código. Estoy hablando de Pex (Program EXploration), que puede ser descargado desde la página de Microsoft Research, y que durante su instalación nos adelanta una futura integración con Visual Studio 2010, el próximo IDE de la compañía. Aunque el sistema operativo recomendado es Windows Vista, no he tenido problema alguno para probarlo con mi Windows XP SP2 y Visual Studio 2008. Tras instalarlo, a ser posible incluyendo los complementos para Visual Studio, tendremos un nuevo grupo de programas con el propio Pex, una carpeta de ejemplos para juguetear un poco y una documentación bastante completa y muy interesante.

Ahora podemos hacer uso del mismo simplemente incluyendo una referencia a Microsoft.Pex.Framework en nuestro proyecto, y etiquetando adecuadamente las clases y métodos con los atributos PexClass y PexMethod respectivamente.

Hecho esto, podemos acceder al menú contextual dentro del código y seleccionar la opción “Run Pex Explorations”. Aparecerá un panel con los resultados de la exploración, y el análisis que ha llevado a cabo Pex en nuestro código.

Como se puede observar, podemos analizar las diversas entradas que Pex habrá usado como parámetros de entrada en nuestros métodos, un pequeño resumen o control de excepciones y el mensaje de error obtenido, si es el caso.

Si seleccionamos una de las entradas, aparecerá una zona con los detalles del código que Pex generará por nosotros para ejecutar la prueba correspondiente. Si esa entrada provoca una excepción, es posible automatizar incluso el control de la excepción, etiquetando el método que ejecutará la prueba para que la misma sea una excepción esperada.

En el cuadro de diálogo Herramientas->Opciones, podemos establecer una serie de configuraciones sobre Pex como, por ejemplo, la generación de informes. Si habilitamos dicha opción, en la carpeta destino de la compilación se creará una carpeta con el informe en formato HTML. Podemos observar en el mismo los tests que han sido generados y la cobertura que suponen sobre el código.

La verdad es que Pex pinta realmente bien. Parece una herramienta interesantísima a la hora de gestionar y generar las pruebas unitarias de forma automatizada. La documentación es muy completa e incluye, además del manual de uso de Pex, una serie de documentos sobre patrones de pruebas para un uso eficiente de Pex, o el uso de stubs. Conforme vaya profundizando en él iré dejando por aquí mis impresiones.

Ah, y no es lo único que se nos viene encima. Los chicos de DevLabs en Microsoft tienen en mente proyectos tan interesantes como CHESS, una herramienta para la búsqueda automática de interbloqueos, condiciones de carrera y otros heisenbugs en nuestro código concurrente.