Lluís Franco on Geeks.ms : API

ClickOnce, actualizar una aplicación ‘on demand’

Lluis Franco — Thu, 02 Apr 2009 14:47:00 GMT

Una de las grandes características disponibles a partir de VS2005 fue la tecnología ClickOnce, que permitía distribuir aplicaciones de forma asombrosamente sencilla. Hoy no nos vamos a dedicar a explicar con detalle esta tecnología (supongo que muchos de vosotros ya la estaréis utilizando), si no que nos vamos a centrar en extender su funcionalidad para comprobar por código si existen nuevas versiones publicadas, y en caso afirmativo actualizar la misma.

La verdad es que utilizar la API de ClickOnce está tirado, y nos permite hacer cosas tan chulas como esta:

El código para comprobar si existen actualizaciones es el siguiente:

private static void InstallUpdateSyncWithInfo()

    UpdateCheckInfo info = null;

    if (ApplicationDeployment.IsNetworkDeployed)

        ApplicationDeployment ad = ApplicationDeployment.CurrentDeployment;

try

            info = ad.CheckForDetailedUpdate();

        catch (DeploymentDownloadException dde)

            MessageBox.Show(String.Format(

                Properties.Settings.Default.CLICKONCE_CANT_DOWNLOAD_UPDATE,

                dde.Message, MessageBoxButtons.OK,

                MessageBoxIcon.Exclamation));

            return;

        catch (InvalidDeploymentException ide)

            MessageBox.Show(String.Format(

                Properties.Settings.Default.CLICKONCE_CORRUPT_DEPLOYMENT,

                ide.Message, MessageBoxButtons.OK,

                MessageBoxIcon.Exclamation));

            return;

        catch (InvalidOperationException ioe)

            MessageBox.Show(String.Format(

                Properties.Settings.Default.CLICKONCE_NO_CLICKONCE_DEPLOYMENT,

                ioe.Message, MessageBoxButtons.OK,

                MessageBoxIcon.Exclamation));

            return;

        if (info.UpdateAvailable)

            Boolean doUpdate = true;

            if (!info.IsUpdateRequired)

                DialogResult dr = MessageBox.Show(

                    string.Format(Properties.Settings.Default.CLICKONCE_UPDATE_AVAILABLE,

                    info.AvailableVersion.ToString()),

                    Application.ProductName, MessageBoxButtons.OKCancel,

                    MessageBoxIcon.Information);

                if (!(DialogResult.OK == dr))

                    doUpdate = false;

            else

                MessageBox.Show(

                    String.Format(Properties.Settings.Default.CLICKONCE_MANDATORY_UPDATE,

                    info.MinimumRequiredVersion.ToString(),

                    ApplicationDeployment.CurrentDeployment.CurrentVersion.ToString()),

                    Application.ProductName, MessageBoxButtons.OK,

                    MessageBoxIcon.Information);

            if (doUpdate)

try

                    ad.Update();

                    MessageBox.Show(Properties.Settings.Default.CLICKONCE_UPDATE_SUCCESSFULLY,

                        Application.ProductName, MessageBoxButtons.OK,

                        MessageBoxIcon.Information);

                    Application.Restart();

                catch (DeploymentDownloadException dde)

                    MessageBox.Show(String.Format(

                        Properties.Settings.Default.CLICKONCE_CANT_INSTALL_UPDATE,

                        dde.Message, MessageBoxButtons.OK,

                        MessageBoxIcon.Exclamation));

                    return;

        else

            MessageBox.Show(Properties.Settings.Default.CLICKONCE_NO_UPDATES_AVAILABLES,

                Application.ProductName, MessageBoxButtons.OK,

                MessageBoxIcon.Information);

Basta acompañar este código con unas constantes definidas en los settings de nuestra aplicación y voilá!

A continuación os muestro un ejemplo del fichero de settings por si alguno se lo quiere personalizar:

<?xml version='1.0' encoding='utf-8'?>

<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings"

  CurrentProfile="(Default)" GeneratedClassNamespace="TestClickOnceDeployment.Properties" GeneratedClassName="Settings">

  <Profiles />

  <Settings>

    <Setting Name="CLICKONCE_CANT_DOWNLOAD_UPDATE" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      La nueva versión de la aplicación no puede ser descargada en estos momentos.\n\

      Por favor, revise la connexión de red o pruébelo un poco más tarde. Error: {0}</Value>

    </Setting>

    <Setting Name="CLICKONCE_CORRUPT_DEPLOYMENT" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      No se puede verificar la nueva versión de la aplicación. La publicación ClickOnce está corrupta.

      Por favor, redistribuya de nuevo la aplicación i pruébelo un poco más tarde. Error: {0}</Value>

    </Setting>

    <Setting Name="CLICKONCE_NO_CLICKONCE_DEPLOYMENT" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      La aplicación no se puede actualizar. Parece ser que la publicación no es una aplicación ClickOnce válida. Error: {0}</Value>

    </Setting>

    <Setting Name="CLICKONCE_UPDATE_AVAILABLE" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      Se ha encontrado disponible una actualización. Desea actualitzar la aplicación a la versión '{0}'?</Value>

    </Setting>

    <Setting Name="CLICKONCE_MANDATORY_UPDATE" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      Esta aplicación ha detectado que la versión mínima de l'aplicació es la versión '{0}',

      i actualmente se está utilizando la versión '{1}'.

      A continuación la aplicación se actualitzará y reiniciará.</Value>

    </Setting>

    <Setting Name="CLICKONCE_UPDATE_SUCCESSFULLY" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      La aplicación se ha actualitzado correctamente, y a continuación se reiniciará.</Value>

    </Setting>

    <Setting Name="CLICKONCE_CANT_INSTALL_UPDATE" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      La nueva versión de la aplicación no se puede instalar en estos momentos.\n\n

      Por favor, revise la connexión de red o pruébelo un poco más tarde. Error: {0}</Value>

    </Setting>

    <Setting Name="CLICKONCE_NO_UPDATES_AVAILABLES" Type="System.String" Scope="Application">

      <Value Profile="(Default)">No se han encontrado actualitzacions disponibles de la aplicación.</Value>

    </Setting>

  </Settings>

</SettingsFile>

Y eso es todo… Un saludo desde Andorra!

Folder size: Primer contacto

Lluis Franco — Fri, 08 Aug 2008 11:09:51 GMT

Harto de buscar dónde se iba el espacio de mi disco duro, y con la sensación de que estaba malgastando un porrón de bytes (y os aseguro que no es en peliXculas), me puse a diseñar una herramienta que me mostrase lo que ocupa cada una de las carpetas de mi ordenador. De esto hace un par de días, y la verdad es que me he liado la manta a la cabeza :-P y al final el resultado es este:

Está enteramente escrito en C# 3.0 y aunque el funcionamiento es más sencillo que el mecanismo de un botijo (al fin y al cabo sólo recorre una estructura de carpetas y va procesando archivos), el resultado me gusta. Para compensar su sencillez le he añadido una interfaz cool (al menos para mí :-P), multithreading en la búsqueda, que a su vez hace uso de llamadas al FindFirstFile y FindNextFile para mejorar la performance... Aunque seguro que mi amigo el rano, belmonte de pro, me dice que si quiero ver performance me deje de tonterías y vuelva al C++ duro. Y os juro y perjuro que ya no me acuerdo de cómo se cocinaba con punteros. Además el resultado puede imprimirse o también exportar a Excel o PDF, y también muestra una lista de posibles errores producidos durante el análisis de la(s) carpeta(s), que mayormente son de acceso a ciertos elementos de sistema (o ubicaciones de red con permisos NTFS).

Si a alguien le apetece probarlo os lo podéis instalar desde esta ubicación:

http://utilities.ordeeno.com/foldersize/

El único requisito es el Framework 3.5, y si no lo tenéis instalado el programa de instalación muy amablemente lo hará por vosotros (eso si, tarda un ratito).

La licencia es beerware, lo cual quiere decir que si te gusta y lo usas... deberás invitarme al menos a una cerveza. Y si es con papas, mejor que mejor!

Bye @ home,

PD - Lo he probado en XP y Vista Ultimate y de momento no le he encontrado ningún bug grave, pero si vosotros lo hacéis podéis contactar conmigo aquí.

Accediendo al directorio activo de la organización desde .NET (II)

Lluis Franco — Mon, 30 Jun 2008 12:53:07 GMT

En el post anterior vimos que en ocasiones nuestra aplicación deberá acceder a los datos que contiene el directorio activo de nuestra organización, ya sea para buscar elementos, validar credenciales, etc.

Hoy nos centraremos en los objetos del framework que nos permiten realizar esto, empezando por el objeto WindowsIdentity, que nos acompaña desde la versión 1.0 del framework, y que representa un usuario de Windows.

WindowsIdentity

Representa un usuario de Windows. Dispone de un método GetCurrent() que devuelve una referencia al usuario de Windows que está ejecutando la aplicación y que por defecto será el usuario actual de Windows.

En nuestro ejercicio vamos a utilizar este objeto para mostrar en la barra de estado algo de información sobre el usuario actual. El nombre y token, así como el contexto de suplantación y diversa información cómo si está autenticado, es de sistema, etc.

El código es muy sencillo y para usarlo sólo debemos tener en cuenta haber importado el espacio de nombres System.Security.Principal:

private void RefreshUserInformation()

    WindowsIdentity user = WindowsIdentity.GetCurrent();

    lblUser.Text = string.Format("User: {0}", user.Name);

    lblToken.Text = string.Format("Token: {0}", user.Token.ToString());

    lblImpersonating.Text = string.Format("Impersonating: {0}", user.ImpersonationLevel.ToString());

    lblIsAnonymous.Text = string.Format("Is Anonymous: {0}", user.IsAnonymous.ToString());

    lblIsAuthenticated.Text = string.Format("Is Authenticated: {0}", user.IsAuthenticated.ToString());

    lblIsGuest.Text = string.Format("Is Guest: {0}", user.IsGuest.ToString());

    lblIsSystem.Text = string.Format("Is System: {0}", user.IsSystem.ToString());

    if (sec.ImpersonationContext == null)

        cmdImpersonateApplicationAsUser.Enabled = true;

        lblUser.ForeColor = Color.Black;

        lblImpersonating.ForeColor = Color.Black;

    else

        cmdImpersonateApplicationAsUser.Enabled = false;

        lblUser.ForeColor = Color.Red;

        lblImpersonating.ForeColor = Color.Red;

    cmdUndoImpersonation.Enabled = !cmdImpersonateApplicationAsUser.Enabled;

Lo único a destacar es que en caso de que exista suplantación (ImpersonationContext distinto de nulo), mostraremos algunos campos en color rojo, para destacar que este usuario es distinto del que inició sesión en Windows.

LDAPServices

En este proyecto he creado una clase que proporciona una serie de funcionalidades comunes, su nombre es LDAPServices y encapsula una serie de métodos estáticos, para facilitar el trabajo con LDAP. En los próximos posts detallaremos el uso de estos métodos:

SecurityContext

También aparece la clase llamada SecurityContext que ya hemos visto en la serie de posts sobre acceder a la caché de IE, que encapsula toda la lógica necesaria para impersonar nuestra aplicación y que se ejecute con otras credenciales de usuario de Windows.

Esta clase expone una propiedad de tipo WindowsImpersonationContext que devuelve información sobre si está realizando suplantación, y que en caso afirmativo permite terminarla mediante el método Undo(). También expone dos métodos LogonUser y ImpersonateUser, que permiten respectivamente validar unas credenciales de usuario contra un dominio y empezar un contexto de suplantación.

En el próximo post veremos cómo realizar esta suplantación y cómo recabar más información del usuario actual (por ejemplo a que grupos de Windows pertenece el usuario actual).

Hasta entonces!

Acceder a la caché de Internet Explorer (V y final)

Lluis Franco — Tue, 10 Jun 2008 13:12:31 GMT

Éste es el último post de esta serie, en la cual se ha desarrollado un proyecto de ejemplo de cómo acceder a la caché de archivos temporales de Internet Explorer. De hecho, he aprovechado la excusa para montar un pequeño proyecto de ejemplo en el que poder enseñar varias cosas que tenía en mente y por falta de tiempo no podía postear.

ASí pues en éste ejercicio hemos mostrado entre otras cosas cómo:

Utilizar el API para acceder a los archivos temporales de Internet (post 1)
Persistir objetos .NET en ficheros XML mediante serialización (post 2)
Impersonar, para ejecutar temporalmente muestra aplicación con las credenciales de otro usuario (post 3)
Crear y distribuir nuestra aplicación como un servicio de Windows (post 4)

Y aquí os dejo el código completo del ejemplo:

Espero que os guste,

Acceder a la caché de Internet Explorer (IV)

Lluis Franco — Fri, 30 May 2008 15:22:53 GMT

En los dos primeros artículos pudimos ver los objetos del API de Windows que íbamos a usar para poder acceder a la caché de los archivos temporales de Internet, cómo persistir estos datos en formato XML, y finalmente cómo permitir que temporalmente nuestra aplicacación se ejecute con las credenciales de otro usuario, para poder realizar una serie de acciones que de otro modo no podría efectuar por falta de privilegios.

Siguiendo con el objetivo de este ejercicio hoy vamos a encapsular la lógica de negocio de nuestra aplicación en forma de servicio de Windows, y éste va a encargarse de realizar una consulta a la caché de Internet de nuestro ordenador cada X tiempo (configurable mediante un fichero XML).

Lo primero de todo va a ser construir la base de nuestro servicio mediante un proyecto de tipo Windows Service. Esta plantilla nos genera un proyecto con un componente de tipo ServiceBase, que servirá para ir construyendo nuestro pequeño juguetito.

A continuación vamos a cambiar el nombre al servicio, en nuestro caso lo llamaremos "IECacheQueryService". Y posteriormente estableceremos a True los valores de las propiedades CanPauseAndContinue y CanShutdown, para poder pausar y detener nuestro servicio en tiempo de ejecución.

Importante: Comprobar que el nombre sel servicio se ha cambiado correctamente en el punto de entrada de la aplicación (si no fuese así tendremos que modificarlo manualmente):

static class Program

        static void Main()

            ServiceBase[] ServicesToRun;

            ServicesToRun = new ServiceBase[]

                new IECacheQueryService()

};

            ServiceBase.Run(ServicesToRun);

Implementando funcionalidad al servicio:

De momento el servicio será capaz de iniciarse, pero no realizará nada. Ahora debemos dotarlo de funcionalidad, y para ello vamos a crear un temporizador que se encargue de realizar una tarea cada X tiempo (por defecto una hora). Éste lo crearemos como un miembro dentro de nuestra clase:

public partial class IECacheQueryService : ServiceBase

    private Timer clock = new Timer();

Y lo usaremos desde el constructor de la misma, así como en los eventos OnStart y OnStop. Observar que en el constructor lo inicializamos con un valor que proviene del fichero de configuración del proyecto (propiedades del proyecto/settings) llamado TimerInterval y se ha establecido a un valor de 3.600.000 (1 hora en milisegundos).

public IECacheQueryService()

    InitializeComponent();

    clock = new Timer(Properties.Settings.Default.TimerInterval);

    clock.Elapsed += new ElapsedEventHandler(clock_Elapsed);

    clock.Enabled = true;

    //...

protected override void OnStart(string[] args)

    ExecuteQuery();

    clock.Start();

    //...

protected override void OnStop()

    clock.Stop();

Del mismo modo también especificamos el manejador de evento asociado que se ejecutará cada vez que se cumpla este intervalo de tiempo (clock_Elapsed). Éste será el corazón de nuestro servicio y será el encargado de invocar la consulta a la caché de IE:

void clock_Elapsed(object sender, ElapsedEventArgs e)

try

            ExecuteQuery();

        catch (Exception ex)

            appEventLog.WriteEntry("Exception: " + ex.Message,

                EventLogEntryType.Error);

Simple verdad? Ahora vamos a construir este método ExecuteQuery a apartir de las piezas que vimos en anteriores entradas de la misma serie. No os preocupeis que en el último post estará un enlace al código completo del ejemplo (incluido el instalable).

Que hace exactamente este método?

Primero de todo crea un objeto de tipo StopWatch para medir con precisión el tiempo que transcurre en la ejecución del mismo.
Llama al método getResults que se encarga de efectuar la consulta y devolver un objeto que es una lista genérica de entradas de la caché.
Construye el nombre de fichero en el que guardaremos los resultados y llama al método saveResults, encargado de realizar la suplantación de identidad y serializar los resultados en el fichero antes mencionado.

private void ExecuteQuery()

try

        Stopwatch watch = new Stopwatch();

        watch.Start();

        List<IECacheEntry> results = getResults(

            Properties.Settings.Default.SearchPattern);

        string filename = string.Format("{0}{1}_{2}.xml",

            Properties.Settings.Default.TargetPathLocation,

            Environment.MachineName,

            DateTime.Now.ToString("ddMMyyyy_hhmm"));

        watch.Stop();

        TimeSpan ts = watch.Elapsed;

        saveResults(results, filename);

        appEventLog.WriteEntry(string.Format(

            "Query executed successfully at {0} in '{1}' by user '{2}'. Elapsed time (ms): {3}",

            DateTime.Now.ToString(), Environment.MachineName,

            WindowsIdentity.GetCurrent().Name,ts.Milliseconds));

    catch (Exception ex)

        appEventLog.WriteEntry("Exception: " + ex.Message,

            EventLogEntryType.Error);

Está el servicio terminado? Bueno, si asumimos que el código está completo y funciona sin errores, sí, lo está :-P

Y ahora cómo lo probamos? Pues... bueno, para probarlo antes tenemos que instalarlo.

Agregando los elementos necesarios para instalar el servicio:

No he encontrado demasiada documentación al respecto, de modo que intentaré mostrar los pasos a seguir mediante capturas de pantalla.

Vamos a agregar un elemento que nos permita distribuir el servicio:

Le agregaremos dos componentes serviceProcessInstaller y serviceInstaller (es posible que no aparezcan en la barra de herramientas, así que tendremos que agregarlos mediante la opción "Choose Items..."

A continuación los configuraremos del siguiente modo:

Control	Propiedad	Valor
serviceProcessInstaller1	Account	LocalSystem (*)
serviceProcessInstaller1	Parent	Installer1
serviceInstaller1	Description	Internet Explorer Query Cache
serviceInstaller1	Display Name	Internet Explorer Query Cache
serviceInstaller1	Parent	Installer1
serviceInstaller1	ServiceName	IEQueryCache
serviceInstaller1	StartType	Automatic

(*) Habitualmente se utilizará siempre la cuenta con menos nivel de privilegios (LocalService), pero en nuestro caso necesitamos acceder a la caché de IE, de modo que es posible que incluso tengamos que configurar la cuenta de un usuario de windows con suficientes permisos.

Cruzamos los dedos, compilamos el proyecto y vamos a agegar un proyecto de instalación a la solución.

Creando el proyecto de instalación:

Agregaremos un proyecto de tipo Setup and deployment, que será el encargado de instalar nuestro servicio en las estaciones Windows que deseamos monitorizar.

Agregamos la salida del proyecto anterior al nuevo proyecto de instalación:

Ahora mostraremos la ventana de "custom actions" para agregar como acción al instalador la salida de nuestro proyecto de servicio de Windows.

Una vez realizado esto ya podemos compilar el proyecto de instalación e instalarlo en las estaciones cliente. Si quereis instalarlo en vuestra estación para probarlo y configurarlo adecuadamente, la opción más sencilla es seleccionar la opción Install del menú contextual del proyecto de instalación, en el explorador de proyectos.

Una vez instalado, aparecerá en el administrador de servicios, para que podamos configurarlo del modo deseado. En este caso particular, si deseamos monitorizar la caché de un usuario en particular, deberemos usar las credenciales de éste usuario, ya que si no el S.O. no será capaz de montar el fichero Index.dat correspondiente a la caché de Internet Explorer.

Bueno, hasta aquí ha llegado este ejemplo. En el próximo post haremos un resumen de lo que se ha visto hasta ahora y publicaré un enlace con el código completo del proyecto para que sirva de ejemplo (o de mal ejemplo :-P).

Saludos desde andorra,

Acceder a la caché de Internet Explorer (III)

Lluis Franco — Mon, 26 May 2008 14:04:01 GMT

Impersonation => RunAs

En los dos primeros artículos pudimos ver los objetos del API de Windows que íbamos a usar para poder acceder a la caché de los archivos temporales de Internet, y como persistir estos datos en formato XML.

Hoy vamos a usar Impersonation para ejecutar nuestra aplicación con otras credenciales de usuario, de este modo nos conectaremos a una ubicación remota a la cual sólo tienen permisos para conectarse los administradores.

Supongamos que tenemos una ubicación similar a esta: \\RootDFS\Logs\IECacheQuery\ y que sólo los usuarios del grupo administradores pueden acceder a leer y modificar su contenido. Si nuestra aplicación se ejecuta con permisos del usuario o servicio local, no podremos guardar los archivos de registro. Sin embargo, en un momento dado nuestra aplicación puede elevar su nivel de privilegios usando las credenciales del administrador, ejecutar las tareas requeridas, y posteriormente volver a su nivel predeterminado para continuar con su ejecución como si tal cosa.

A este proceso se le llama impersonar o suplantar, aunque personalmente no me gusta demasiado la traducción por las posibles connotaciones negativas que conlleva. Y básicamente se trata de que durante un lapso de tiempo nuestra aplicación va a estar ejecutándose con un usuario distinto al usuario que ha iniciado la aplicación.

Artistas invitados: LogonUser y DuplicateToken

La primera de ellas verifica si las credenciales suministradas son correctas, validándolas contra un dominio (que puede ser la estación local) y devuelve un token, mientras que la segunda crea una copia de un token existente. Hay que mencionar un detalle importante y es que el token devuelto por DuplicateToken es lo que se llama un 'impersonation token', que no es válido para la función CreateProcessAsUser ya que ésta necesita un token primario. Si deseamos usar ésta función debemos usar como alternativa la función DuplicateTokenEx.

[DllImport("advapi32.dll", SetLastError = true)]

public static extern bool LogonUser(string pszUsername, string pszDomain, string pszPassword,

    int dwLogonType, int dwLogonProvider, ref IntPtr phToken);

[DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]

public extern static bool DuplicateToken(IntPtr ExistingTokenHandle,

    int SECURITY_IMPERSONATION_LEVEL, ref IntPtr DuplicateTokenHandle);

Más información aquí:

LogonUser Function:

http://msdn.microsoft.com/en-us/library/aa378184(VS.85).aspx

DuplicateToken Function:
http://msdn.microsoft.com/en-us/library/aa446616(VS.85).aspx

Bien, ahora que ya nos conocemos todos vamos a ver un fragmento del código de la aplicación, que usa estas funciones para impersonar un usuario y devolver un objeto de tipo WindowsImpersonationContext. Posteriormente podremos usar el método 'Undo' de este objeto para deshacer el contexto de suplantación y volver al contexto anterior, de forma que la aplicación seguirá ejecutándose con el usuario que la ha lanzado.

public WindowsImpersonationContext ImpersonateUser(

    string sUsername, string sDomain, string sPassword)

    IntPtr pExistingTokenHandle = new IntPtr(0);

    IntPtr pDuplicateTokenHandle = new IntPtr(0);

    pExistingTokenHandle = IntPtr.Zero;

    pDuplicateTokenHandle = IntPtr.Zero;

    if (sDomain == "") sDomain = System.Environment.MachineName;

try

        string sResult = null;

        const int LOGON32_PROVIDER_DEFAULT = 0;

        const int LOGON32_LOGON_INTERACTIVE = 2;

        bool bImpersonated = LogonUser(sUsername, sDomain, sPassword,

            LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT,

            ref pExistingTokenHandle);

        if (false == bImpersonated)

            int nErrorCode = Marshal.GetLastWin32Error();

            sResult = "LogonUser() failed with error code: " + nErrorCode + "\r\n";

            throw new Exception(sResult);

        sResult += "Before impersonation: " + WindowsIdentity.GetCurrent().Name + "\r\n";

        bool bRetVal = DuplicateToken(pExistingTokenHandle,

            (int)SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation,

            ref pDuplicateTokenHandle);

        if (false == bRetVal)

            int nErrorCode = Marshal.GetLastWin32Error();

            CloseHandle(pExistingTokenHandle);

            sResult += "DuplicateToken() failed with error code: " + nErrorCode + "\r\n";

            throw new Exception(sResult);

            return null;

        else

            WindowsIdentity newId = new WindowsIdentity(pDuplicateTokenHandle);

            WindowsImpersonationContext impersonatedUser = newId.Impersonate();

            sResult += "After impersonation: " +

                WindowsIdentity.GetCurrent().Name + "\r\n";

            this.ImpersonationContext = impersonatedUser;

            return impersonatedUser;

    catch (Exception ex)

        throw ex;

    finally

        if (pExistingTokenHandle != IntPtr.Zero)

            CloseHandle(pExistingTokenHandle);

        if (pDuplicateTokenHandle != IntPtr.Zero)

            CloseHandle(pDuplicateTokenHandle);

Vaya, esto es Impersionante...

Cabe destacar que en la llamada a LogonUser, se pasa un puntero al token de usuario 'pExistingTokenHandle' que posteriormente se usa en la llamada a DuplicateToken. Ésta devuelve el duplicado mediante 'pDuplicateTokenHandle', que posteriormente es usado para crear una nueva identidad y llamar a su método Impersonate, que es realmente la que se encarga de realizar la suplantación con el nuevo token.

(*) El siguiente código no funcionará en plataformas Windows 98 o Windows Me, ya que no poseen la posibilidad de trabajar con tokens de usuarios.

Una vez realizado el trabajo que requería de la suplantación de identidad, para volver al contexto predeterminado basta con invocar al método Undo del objeto WindowsImpersonationContext del siguiente modo:

Security.SecurityContext sec = new Security.SecurityContext();

if (Properties.Settings.Default.SaveResultsUsingImpersonation)

    sec.ImpersonateUser(

        Properties.Settings.Default.ImpersonateUser,

        Properties.Settings.Default.ImpersonateDomain,

        Properties.Settings.Default.ImpersonatePwd);

    appEventLog.WriteEntry(

        string.Format("Begin Impersonation, Current user as {0}",

        WindowsIdentity.GetCurrent().Name));

//

//Realizar acciones que requieren suplantación..

//

if (Properties.Settings.Default.SaveResultsUsingImpersonation)

    sec.ImpersonationContext.Undo();

    appEventLog.WriteEntry(

        string.Format("End Impersonation, Current user as {0}",

        WindowsIdentity.GetCurrent().Name));

Conclusión

Espero que este post haya clarificado cómo realizar este proceso. En el siguiente veremos cómo encapsular toda la aplicación para ejecutarse en forma de servicio. Ah! y antes que me lo diga alguno, ya se que no sería el mejor ejemplo para mostrar un servicio de Windows (porque corriendo con permisos de LOCALSYSTEM no se tiene permiso a la caché del usuario), pero tenía un post al respecto pendiente desde hace tiempo. Así que lo juntaremos todo en un mix o refrito o como queráis llamarlo, para que sirva de ejemplo.

También al final de la serie, postearé un recopilatorio de los pasos que hemos seguido y el código completo del ejemplo, por si alguien está tan loco como para querer probarlo :-P

Ahora, a impersonar todos. Pero si lo hacéis, por favor hacerlo bien... no de este modo:

Saludos desde Andorra

Acceder a la caché de Internet Explorer (II)

Lluis Franco — Tue, 20 May 2008 16:07:25 GMT

:-/
Hola de nuevo,

Siento haber tardado más de lo previsto en publicar este post, pero hemos tenido un fallecimiento en la familia este fin de semana y todavía andamos un poco descolocados. De todos modos, siguiendo con el hilo del primer post de esta serie, vamos a ver como leer los valores de los archivos temporales de Internet (imágenes que son almacenadas en caché, cookies, sitios visitados, etc.). Para acceder al contenido de esta caché vamos a usar un par de llamadas al API de windows y vamos a guardar el contenido de estas consultas en un medio persistente para su posterior análisis.

El objetivo de todo esto:

Nuestro objetivo va a consistir en recoger información de la caché cada X tiempo (supongamos cada hora), y mediante serialización persistirla en ficheros XML en una ubicación remota. Además, para complicarlo un poquito más vamos a hacer que esta ubicación no sea accesible desde el usuario actual, de modo que debamos impersonar otro inicio de sesión que si tenga permisos sobre esta ubicación. Todo esto, lo encapsularemos como un servicio de Windows y crearemos un proyecto de instalación que podremos distribuir en los clientes que deseamos inspeccionar.

Una vez terminado este ejercicio habremos mostrado varias cosas como:

Acceder a la caché de Internet Explorer
Serializar objetos a ficheros XML
Impersonar la ejecución de nuestra aplicación con otro usuario
Crear un servicio de Windows que ejecute un proceso cada X tiempo

De todos modos me gustaría dejar clara una cosa, para que nadie me malinterprete:

** El objetivo de todo esto no es ni mucho menos crear una herramienta para espiar a nadie, si no que lo he considerado más bien como un projecto que reune varias cosillas interesantes a explicar, un modo de reunirlas bajo un mismo ejercicio **

Preparando el terreno:

El primer paso va a ser declarar una clase que almacene la información de las entradas devueltas por las funciones FindFirstUrlCacheEntry y FindNextUrlCacheEntry.

[Serializable]

public class IECacheEntry

    public string url;

    public string size;

    public string lastAccessTime;

    public string lastModifiedTime;

    public string expireTime;

    public string filename;

    public IECacheEntry()

    public IECacheEntry(

        string _url,

        string _size,

        string _lastAccessTime,

        string _lastModifiedTime,

        string _expireTime,

        string _filename)

        url = _url;

        size = _size;

        lastAccessTime = _lastAccessTime;

        lastModifiedTime = _lastModifiedTime;

        expireTime = _expireTime;

        filename = _filename;

Esta clase la vamos a usar conjuntamente con esta clase, que identifica la consulta y recoge los datos que se guardarán cada vez que se ejecute la consulta a la caché. Esta clase también la decoraremos con el atributo serializable para posteriormante poder persistirla a un fichero XML:

[Serializable]

public class IECacheQuery

    public IECacheQuery() { }

    public string hostname = string.Empty;

    public string username = string.Empty;

    public DateTime date = DateTime.Now;

    public List<IECacheEntry> results;

Empezando a ensamblar las piezas:

EL corazón de este ejercicio consiste en esta pequeña función "getResults", que a partir de una cadena que contiene el patrón de búsqueda devuelve todas las instancias de la caché que coinciden con ésta. Este patrón de búsqueda puede contener el valor "cookies", "visited", una URL en concreto o bien NULL (que devuelve todos los valores de la caché). A continuación estos resultados se almacenan en una lista genérica que se devuelve como valor de retorno de la función.

Nota 1: Este código se ha realizado con compatibilidad con estaciones Windows 2000 que admiten versiones del Framework hasta la 2.0, de modo lamentablemente que no se han podido utilizar las bondades del Framework 3.5 (en particular he echado mucho de menos a LINQ to objects).

Nota 2 : En el código pueden observarse llamadas a funciones que no han sido descritas en el artículo (como el método ToStringFromFileTime en el código siguiente). Sin embargo estas funciones si pueden encontrarse en el código completo del ejemplo que se podrá descargar al final de la serie.

private List<IECacheEntry> getResults(string patternText)

    List<IECacheEntry> listresults = new List<IECacheEntry>();

    List<IECacheAPI.INTERNET_CACHE_ENTRY_INFO> results =

        IECacheAPI.FindUrlCacheEntries(patternText);

    foreach (IECacheAPI.INTERNET_CACHE_ENTRY_INFO result in results)

        IECacheEntry entry = new IECacheEntry();

        listresults.Add(

            new IECacheEntry

                    result.lpszSourceUrlName,

                    ((((Int64)result.dwSizeHigh) << 32) + result.dwSizeLow).ToString(),

                    Win32API.ToStringFromFileTime(result.LastAccessTime),

                    Win32API.ToStringFromFileTime(result.LastModifiedTime),

                    Win32API.ToStringFromFileTime(result.ExpireTime),

                    result.lpszLocalFileName

);

    return listresults;

Bien, de momento ya tenemos la función encargada de devolver los resultados de la caché, ahora ¿que hacemos con ellos?

Persistir objetos, que facil es con .NET!

Serializar objetos a XML es muy pero que muy sencillo. De hecho en nuestro caso ni siquiera vamos a aplicar un formateador SOAP ni binario, y tampoco vamos a aplicar atributos para serializar miembros de clases como nodos o atributos. En este caso vamos a usar la serialización del siguiente modo:

public sealed class Manager

        public static void Save(IECacheQuery query, string pfilename)

try

                XmlSerializer xmlDoc = new XmlSerializer(typeof(IECacheQuery));

                StreamWriter sw = new StreamWriter(pfilename);

                xmlDoc.Serialize(sw, query);

                sw.Close();

            catch (Exception ex)

                throw ex;

A esta función se le pasan dos argumentos, el objeto que deseamos persistir i el nombre del archivo XML en el que se quiere persistir. En ella se crea un objeto XmlSerializer preparado para el tipo de objeto IECacheQuery, a continuación se crea un Stream al fichero XML para serializar el objeto. A continuación se cierra el Stream y se acabó lo que se daba.

Qué? Facil verdad? Esta es una de las maravillas que me cautivaron cuando empecé con .NET (y es que con anterioridad había que hacer maravillas para poder realizar este tipo de cosas).

Próximos pasos:

De momento ya tenemos la función que devuelve resultados de la caché y tenemos un modo de persistir un objeto en un fichero XML. A continuación, después de la publicidad (o más bien en el próximo post), mostraremos como Impersonar nuestra aplicación para que se ejecute como otro usuario, a fin de tener acceso a una supuesta ubicación de red en la que gusrdar los ficheros de resultados.

Hasta el próximo post.

Acceder a la caché de Internet Explorer (I)

Lluis Franco — Thu, 15 May 2008 15:59:45 GMT

En algunos casos puede ser interesante acceder a la caché de navegación de Internet Explorer. Por ejemplo, para poder guardar un registro de los sitios que visitan los usuarios de nuestra organización sin tener que montar un ISA server o similar.

Para ello, y como todavía no he encontrado nada implementado en el propio Framework, vamos a hacer uso de algunos elementos del API de Windows. Ese gran amigo que todavía nos sigue sacando las castañas del fuego algunas veces... :-D

El punto de partida:

Cuando accedemos a la carpeta de archivos temporales de Internet, podemos eliminar el contenido o cambiar la ubicación de la carpeta que utilizamos para almacenar este información:

Incluso si pulsamos la opción de ver archivos, el explorador nos muestra una vista similar a esto:

Sin embargo, esta vista se genera automáticamente a partir del contenido de un fichero llamado Index.dat, que se encuentra en la carpeta "Archivos temporales de Internet\Content.IEX", siendo X la versión de IE del sistema. De modo que, para poder acceder a la información contenida en este fichero no nos queda más remedio que utilizar algunas funciones del API de Windows.

Presentando a los protagonistas:

Como os decía anteriormente, a falta de poder usar código manejado vamos a utilizar los ladrillos del propio S.O.

Esta estructura representa un elemento dentro de la caché de Internet.

[StructLayout(LayoutKind.Sequential)]

public struct INTERNET_CACHE_ENTRY_INFO

    public UInt32 dwStructSize;

    public string lpszSourceUrlName;

    public string lpszLocalFileName;

    public UInt32 CacheEntryType;

    public UInt32 dwUseCount;

    public UInt32 dwHitRate;

    public UInt32 dwSizeLow;

    public UInt32 dwSizeHigh;

    public Win32API.FILETIME LastModifiedTime;

    public Win32API.FILETIME ExpireTime;

    public Win32API.FILETIME LastAccessTime;

    public Win32API.FILETIME LastSyncTime;

    public IntPtr lpHeaderInfo;

    public UInt32 dwHeaderInfoSize;

    public string lpszFileExtension;

    public UInt32 dwExemptDelta;

};

Más información acerca de esta estructura en:

INTERNET_CACHE_ENTRY_INFO Structure

http://msdn.microsoft.com/en-us/library/aa385134(VS.85).aspx

También nos basaremos en estas dos funciones, encargadas de devolver un puntero a un elemento del tipo INTERNET_CACHE_ENTRY_INFO dentro de la caché. La primera de ellas devuelve el primer valor encontrado en la caché, a partir de un puntero a una cadena que representa el patrón a buscar. Mientras que la segunda recibe el manejador devuelto por la primera llamada a FindFirstUrlCacheEntry.

[DllImport("wininet.dll", SetLastError=true)]

private static extern IntPtr FindFirstUrlCacheEntry(

  string lpszUrlSearchPattern, IntPtr lpFirstCacheEntryInfo,

  out UInt32 lpdwFirstCacheEntryInfoBufferSize );

[DllImport("wininet.dll", SetLastError=true)]

private static extern long FindNextUrlCacheEntry(

  IntPtr hEnumHandle, IntPtr lpNextCacheEntryInfo,

  out UInt32 lpdwNextCacheEntryInfoBufferSize );

Podéis encontrar más información acerca de ellas en:

FindNextUrlCacheEntry Function
http://msdn.microsoft.com/en-us/library/aa384049(VS.85).aspx

FindFirstUrlCacheEntry Function
http://msdn.microsoft.com/en-us/library/aa384026(VS.85).aspx

Y ahora que?

Pues ahora nada, que me he quedado sin tiempo... hasta aquí este primer post. Mañana continuaremos con la construcción de un pequeño proyecto de ejemplo que utiliza estas funciones para acceder a la caché de Internet y muestre el contenido en pantalla. Y si da tiempo, sería interesante crear una aplicación o servicio que vaya monitorizando y guardando este contenido en algún medio persistente (tal vez XML o una base de datos).

Hasta mañana!