Un microgestor de descargas casero

Llevo tiempo dándole vueltas a adentrarme en el estudio de una nueva carrera (sí, soy un poco masoquista), aunque la aparición de Bolonia con sus pros y sus contras (más de estos últimos, según parece) me daba que pensar en cuanto a mi decisión. Obviamente, con el trabajo únicamente me puedo plantear estudios a distancia, por lo que acceder a mi más deseada titulación (Biología) queda, de momento, un poco lejos. Ya el año pasado estuve dándole vueltas a los másteres homologados para el EEES (Espacio Europeo de Educación Superior), en concreto a uno de redes y seguridad informática que me llamaba poderosamente la atención. Sin embargo, y mientras nuestra titulación no obtenga por parte de quienes gobiernan la deferencia que merecen, y se nos otorguen las atribuciones (es decir, tanto obligaciones como derechos) que deberíamos ostentar creo que dejaré correr lo del máster y, a lo sumo, me adentraré en algún estudio por el mero placer de aprender.

En fin, volviendo a lo que iba, este fin de semana he estado mirando alguna información sobre los Grados que empiezan a impartirse este curso académico, y algunos de los que se iniciarán en el próximo, siempre en la UNED. Además de las guías de la carrera y las de cada asignatura, resulta interesante echar un vistazo a los exámenes de años anteriores, para hacerse a la idea del nivel que alcanzan los conocimientos esperados y los contenidos que entran en juego a la hora de evaluar nuestro trabajo.

Uno de los centros asociados más interesantes a este respecto es el de Calatayud, que cuenta en su página web con un depósito de exámenes realmente apabullante. Accedemos a la carrera deseada, marcamos las asignaturas de las que queremos consultar los exámenes y tenemos ante nosotros los correspondientes a los últimos años (desde 2005 en adelante). Según sea la carrera, pueden rondar cerca de los mil exámenes en total para cada una de ellas. Los exámenes aparecen en PDF, y se pueden descargar o visualizar simplemente con pulsar sobre el enlace correspondiente. Así que nada, me dispuse a descargar unos pocos y aunque sólo quería los de los últimos años, el proceso era harto engorroso: “Botón derecho->Guardar enlace cómo…->Aceptar” y con Google Chrome, en el mejor de los casos (ya que descarga los PDF directamente) ir pulsando en cada enlace. Cuando llevaba unos pocos, como habréis imaginado, me he dicho: ¿por qué no hago un programita para automatizar esto? Dicho y hecho, se tarda menos en ello que en descargar los exámenes de una asignatura. El programa no es nada del otro mundo, y lo cierto es que tiene poco interés, pero ya que está hecho, me he dicho: ¿por qué no divago un poco en el blog y dejo el código fuente?

[CSharp]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Net;
using System.IO;

namespace Lobosoft.Utilidades
{
public class Downloader
{
WebClient webClient = new WebClient();
Regex urlRegEx = new Regex(@"(((f|ht){1}tp://)[-a-zA-Z0-9@:%_\+.~#?&//=]+)");

///
/// Descarga los archivos apuntados por los enlaces al path indicado.
///
///
La lista de enlaces. ///
La ruta donde descargarlo. public void GetLinksContent(string html, string extension, string outputPath)
{
string filename;

foreach (string url in GetLinksUrl(html, extension))
{
filename = url.Substring((url.LastIndexOf('/') + 1), url.Length - url.LastIndexOf('/') - 1);
webClient.DownloadFile(url, Path.Combine(outputPath , filename));
}
}

// Obtiene todas las URL dentro de los enlaces existentes en la web cuyo código HTML examinamos
List GetLinksUrl(string htmlSource, string extension)
{
List links = new List();

// Obtiene todas las URL de la web
foreach (Match match in urlRegEx.Matches((htmlSource)))
{
//Pero únicamente agrega aquellas que terminen con la extensión dada.
// Podría sustituirse la expresión regular en tiempo de ejecución para devolver únicamente
// las que nos interesan, pero así puede quedar algo más genérico.
if (match.Value.EndsWith(extension))
{
links.Add(match.Value);
}
}

return links;
}
}
}
[/CSharp]

Como veis, no tiene demasiado misterio. Un método, GetLinksUrl() se encarga de buscar en el código HTML de la página las URLs que contenga, y lo devuelve como una lista de enlaces a GetLinksContent(), que se encarga de ir recorriéndola y descargando los archivos a una determinada carpeta que habremos creado previamente. La llamada a este método se llevaría a cabo con el código fuente de la página en cuestión. Podemos haberlo leído de un archivo local, o bien recuperarlo de Internet mediante un WebClient (con su método estático DownloadString(url)), o si lo usamos desde una aplicación Windows, utilizando un objeto WebBrowser y accediendo a su propiedad DocumentText en un momento determinado). El misterio (o no tanto) estará en saber de qué carrera ando buscando información ;)

Bueno, y ahora, a hacer lo mismo en Python. Estoy mirando una librería, PycURL, que pinta bastante bién, y vamos a ver si consigo lograrlo. Si me pongo a ello os contaré algo por aquí, claro está. ¡Vamos a ello!

Evitando fallos de carga dinámica de ensamblados

En ocasiones necesitamos cargar un tipo contenido en una DLL de forma dinámica, sin haber establecido una referencia cuando generamos nuestra aplicación. Es el caso de un sistema de plugins en el que una aplicación debe cargar en tiempo de ejecución una serie de DLLs que le ofrecen una funcionalidad adicional. En .NET disponemos de la poderosa herramienta de la reflexión (reflection) para cargar una DLL dinámicamente e instanciar un objeto de una determinada clase para hacer uso del mismo. En principio su uso es bastante sencillo y no suele darnos demasiados problemas pero ¿qué ocurre cuando una DLL que cargamos dinámicamente hace referencias a otras? Si esas librerías están ubicadas en la ruta de nuestro ejecutable no tendremos mayor problema. Recordemos que el comportamiento establecido por diseño en .NET para localizar una DLL es el siguiente:

1. Busca en el GAC.


2. Intenta localizarla en el directorio que contiene el ejecutable.


3. La busca en un subdirectorio dentro de la ruta del ejecutable, cuando se ha establecido a través de un archivo de configuración.

En el caso en que nuestras DLLs no estén en ninguno de estos lugares, se producirá una excepción al intentar cargar el ensamblado correspondiente.

Para la primera situación, la solución es fácil: basta con instalar en el Global Assembly Cache la DLL en cuestión. Sin embargo, no es algo que convenga hacer con todas nuestras DLLs: el GAC debe mantenerse tan limpio como sea posible.

En el segundo caso, por supuesto, bastaría con tener todas las DLLs en la ruta del ejecutable en cuestión, pero no es algo recomendable ni siempre debe ser así. Comenzaríamos a tener librerías duplicadas en el sistema y las aplicaciones terminarían por ser difíciles de mantener.

Para el tercer caso, la solución pasa por incluir unas etiquetas que especifiquen dónde buscará el CLR nuestro ensamblado. Hay que llevar a cabo una firma del ensamblado para obtener su strong name, usar los atributos publicKeyToken y la versión del ensamblado para terminar incluyendo en nuestro archivo de configuración algo como lo siguiente (se trata de un XML, claro está, aunque sustituyo un carácter para que no se interprete como tal y sea visible):

[configuration>
  [runtime>
    [assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      [dependentAssembly>
        [assemblyIdentity name="Dummy"  culture="neutral"
         publicKeyToken="589048994a485948"/>
        [codeBase version="1.0.1423.13588" 
         href="FILE://C:/Lobosoft/Dummy.dll"/>
      [/dependentAssembly>
    [/assemblyBinding>
  [/runtime>
[/configuration>

Pero, ¿qué ocurre si las DLLs pueden estar en distintas ubicaciones, no tenemos posibilidad de firmar digitalmente las mismas, o se da algún otro impedimento para optar por esta solución? En ese caso, tal vez debamos optar por controlar el evento AssembyResolve, asociado al dominio de aplicación actual. Su uso es bastante simple:

AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.AssemblyResolve += new ResolveEventHandler(AssemblyResolveEventHandler);

Al incluir este par de líneas, en el momento en que deba resolverse si un determinado ensamblado ha sido cargado. Esto ocurre, por ejemplo, al hacer una llamada al método CreateInstance() de un determinado Assembly, para instanciar un objeto de un tipo determinado. En el caso de que alguna de las DLLs referenciadas por el ensamblado no esté disponible, nuestro manejador de evento procederá a llevar a cabo la carga correspondiente:

[Csharp]
Assembly AssemblyResolveEventHandler(object sender, ResolveEventArgs args)
{
//Este manejador es llamado únicamente cuando el CLR intenta cargar un ensamblado y se produce un error.
//Recupera la lista de ensamblados referenciados
Assembly needAssembly, objExecutingAssemblies;
string assemblyTemporalPath = "";
/* myAssembly, en este caso, es el objeto que intentó realizar la carga fallida. Es el Assembly que hemos cargado
* mediante reflection, y que ha lanzado el evento al hacer un CreateInstance() sobre él. Si quisiéramos llevar a
* cabo el control sobre nuestra aplicación podríamos sustituir myAssembly por Assembly.GetExecutingAssembly();
*/
objExecutingAssemblies = myAssembly;
AssemblyName[] arrReferencedAssmbNames = objExecutingAssemblies.GetReferencedAssemblies();
foreach (AssemblyName strAssmbName in arrReferencedAssmbNames)
{
if (strAssmbName.FullName.Substring(0, strAssmbName.FullName.IndexOf(",")) == args.Name.Substring(0, args.Name.IndexOf(",")))
{
assemblyTemporalPath = DllBasePath + @"\" + args.Name.Substring(0, args.Name.IndexOf(",")) + ".dll";
break;
}
}
needAssembly = Assembly.LoadFrom(assemblyTemporalPath);
return needAssembly;
}
[/Csharp]

Es el caso para un Assembly (myAssembly) que pudimos cargar con un Assembly.LoadFile(DllBasePath + “\DllName.dll”), y que al recuperar sus tipos e intentar instanciar uno de ellos con Assembly.CreateInstance() ha intentado acceder a otra DLL de la que haga uso o herede. Si la ubicación de esa DLL no coincide con los tres casos que especificábamos antes, la carga dará un error. Será entonces cuando entre en acción el manejador del evento AssemblyResolve y llevará a cabo la carga de las DLLs necesarias para continuar con la creación de la instancia de nuestro objeto.

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 decadencia 2.0

Ayer mencionaba de pasada el tema de los blogs y, en general, de las páginas enmarcadas en la web 2.0, que tras pasar por periodos de mayor o menor bonanza, con un número considerable de artículos mensuales y visitas diarias, llegaban a un punto, en muchas ocasiones de no retorno, en el que dejaban de actualizar sus contenidos, e iban languideciendo poco a poco hasta que sus incondicionales lectores terminaban por abandonarles. Otro problema existente en la web 2.0 y la profusión de información que generan las aplicaciones inscritas en ella es la generación de contenido sin interés, nacido de la mera repetición de lo escrito en otros lugares, cuando no en un descarado plagio que no lleva a ningún lado. La democratización de Internet, que llegó con las aplicaciones “sociales”, marcadas por la interacción con el usuario (con los usuarios, cientos, miles, que nos siguen) y con el propio autor de los contenidos, ha llevado a que se genere muchísima información, demasiada diría yo, y con esta avalancha informativa, perecen sepultados en ocasiones los contenidos más interesantes. Ni el buscador de buscadores, Google, es capaz en ocasiones de discernir entre la información de calidad y la paja.

Acabo de leer un artículo que me ha parecido, por lo demás, bastante interesante. Se trata de una reflexión en torno a este tema, que lo trata con profundidad y establece relaciones entre la crisis actual y la caída de los ingresos por publicidad, que al fin y al cabo son los que mantienen en multitud de ocasiones a las páginas web, les aportan beneficios o, por lo menos, llegan a cubrir los gastos generados por su mantenimiento. Lo encontraréis en Pons Asinorum.

Todos estos temas me parecen, por lo demás, muy interesantes, y dan mucho de sí. Aunque quiero huir del blog de opinión y de breves reseñas en el que se estaba convirtiendo Lobosoft, y volver al blog técnico, con artículos que puedan resultaros de verdad interesantes (permitiéndome algún que otro escarceo, claro está, con mis siempre presentes temáticas medioambientales), no me resisto a recomendaros alguna que otra lectura interesante, al menos cuando no la he visto repetida en infinidad de blogs justo cuando pienso en escribir sobre ella, claro está.

¿Qué pensáis vosotros sobre la web 2.0, ahora que parece que está viviendo los estertores previos a su ¿desaparición? ante los nuevos servicios de la nube y de la Internet en la que estamos a punto de adentrarnos?