DelVol: cambia fácilmente letra de unidades en Windows

Lo pensé mucho para publicar este artículo, pues no me parece que la herramienta que voy a describir llegue a ser de utilidad para mucha gente; sin embargo, decidí hacerlo por algunas razones: primero, haré mención de su uso en un artículo que escribiré para Implementa Windows. Segundo, es una buena oportunidad para documentar su funcionamiento, y tercero, quizá a otras personas les pueda solucionar el mismo problema que yo tuve.

El problema

Parte de mi rol en el trabajo es realizar ingeniería de imágenes en las empresas, tratando siempre de automatizar todo lo que más pueda en el proceso de instalación de Windows. Como es de esperarse, todas las empresas son muy diferentes, así que siempre me encuentro con nuevos requerimientos, unos más sencillos que otros.

En este caso, necesitaba una forma de automatizar el proceso para quitarle la letra de unidad a una partición; más específicamente, necesitaba liberar la letra D y cambiarla por cualquier otra letra en tiempo de implementación desde MDT.

Las opciones

La primera opción, como suele ser normal, es ver una forma soportada para hacer el cambio de unidad con alguna herramienta integrada de Windows, así que opté por Diskpart. Lo único que debemos saber es el número de volumen que tiene asignada la partición con la letra a cambiar y la nueva letra que vamos a asignarle.

En mi caso, para cambiar de la D a la Z, suponiendo que el volumen es el 0, tendría que utilizar los siguientes comandos:

> Diskpart
> List Volume
> Select Volume 0
> Assign Letter=Z

image

Lo malo con Diskpart es que siempre debía saber el número de volumen y la nueva letra de unidad; si me equivocaba en alguno de los dos o la letra de unidad estaba tomada, no tenía como manejarlo.

La segunda opción era, por supuesto, PowerShell. Soy un entusiasta, pero aún muy malo para construir scripts profesionales, así que traté de encontrar la mejor opción para hacer el cambio de forma automatizada. El script que manejé durante algunas pruebas era así:

$drive = Get-WmiObject -Class win32_volume -Filter “DriveLetter = ‘D:'”

Set-WmiInstance
-input $drive -Arguments @{DriveLetter=”Q:”}

A diferencia de Diskpart, PowerShell utilizaba el módulo de WMI para consultar el volumen que estaba montado con la letra D y luego le asignaba la letra Q.

Aunque me liberé del primer problema, saber el volumen, aún estaba condicionado por la disponibilidad de la letra que le iba a asignar; no obstante, es probable que haya podido encontrar la forma de buscar con PowerShell qué unidades estaban tomadas, pero eso le habría dado más duración al script, además de subir la probabilidad de error. Por otro lado, la ejecución de scripts de PowerShell desde MDT me parece algo lenta y propensa a fallar, pues hay dependencias de que se habilite correctamente la ejecución y de versiones de PowerShell para soportar los módulos.

Podía dejar cualquiera de las dos, pero, como última opción, opté por tratar de entender un poco más cómo funciona la asignación de particiones con la API de Windows y construir mi propia herramienta: DelVol.

Un poco de teoría

Normalmente nosotros reconocemos los volúmenes que tenemos activos en el equipo por su etiqueta (Datos, Windows, Backup, OSDisk, etc.) o por la letra que les fueron asignados, sea por Windows o por nosotros (D:\, E:\, J:\, etc.); pero Windows no puede utilizar la misma estrategia porque, por ejemplo, un volumen puede tener asignado una letra y una etiqueta, solo la letra, solo la etiqueta o ninguna de las dos. Otro ejemplo claro es que la letra puede variar cada que se desconecta y reconecta, puesto que Windows asigna por disponibilidad.

El sistema operativo, entonces, reconoce cada volumen con algo llamado Volume GUID Path, que está compuesto por un prefijo, «\\?\», la palabra «Volume» y un identificador único asignado por Windows. Por ejemplo, el volume GUID path  de la unidad Z:\ en mi equipo quedaría así:

\\?\Volume{45c09333-0000-0000-0000-100000000000}\

Si están interesados en saber el volume GUID path de sus particiones, Windows tiene una herramienta integrada llamada MountVol:

image

Windows Sysinternals también ofrece una herramienta un poco mejor llamada DiskExt que muestra, además del GUID, otros detalles relevantes como la unidad y disco al que pertenece:

image

Yo también hice un pequeño ejecutable que utiliza las funciones GetVolumeInformation y GetVolumeNameForVolumeMountPoint para obtener el volume GUID path, letra de unidad, tipo de sistema de archivos y serial asignado por Windows. El uso es muy sencillo, si yo quiero saber el detalle para la letra Z, solo debo indicársela como argumento agregando los dos puntos y el backslash, así:

VolInfo.exe Z:\

image

Pueden descargar los archivos fuente desde el repositorio de GitHub. El ejecutable está en la carpeta de Exefile: https://github.com/SergioCalderonR/VolInfo 

La solución: DelVol

DelVol es una sencilla herramienta de línea de comandos que me permite especificar la letra de unidad a la que le quiero cambiar la letra y ella se encargará de buscar internamente cuál es la siguiente letra disponible para asignársela, liberando la anterior para nuevo uso. La herramienta utiliza varias funciones de la API de Windows, de esta forma elimino la necesidad de versiones de framework y proporciono compatibilidad desde Windows 7 en adelante.

Gracias a que la herramienta se encarga de buscar la siguiente letra disponible, también elimino la preocupación de que la letra esté ocupada, tal cual me sucedía con Diskpart y PowerShell.

¿Cómo funciona?

Solo es necesario indicarle como argumento la letra de unidad y la herramienta hará el resto. Por ejemplo, si deseo liberar la letra Z, el comando sería:

DelVol.exe Z:\

image

Es necesario indicar la letra de unidad con los dos puntos y el backslash, de lo contrario la herramienta devolverá un error, esto es porque las funciones requieren este formato para funcionar, aunque espero hacer esto más fácil en el futuro.

En caso de equivocación o de lanzar solo el ejecutable sin argumentos, la aplicación mostrará una pequeña ayuda con ejemplo:

image

Como pueden ver, la ventaja de interactuar directamente con la API de Windows es el rendimiento al ejecutar, además de tener un poco más de control sobre lo que estoy haciendo.

¿Dónde descargar?

La solución está disponible también en mi repositorio de Github, por si alguien está interesado en conocer el código y, por qué no, aportar:

https://github.com/SergioCalderonR/DelVol 

Si solo desean el ejecutable, pueden obtenerlo al descargar la solución, en la carpeta Exefile.

SNAGHTML87a094[5]

image

Espero sea de utilidad.

Saludos,

<

p align=”justify”>—Checho

SetWall: cambia el fondo de pantalla aplicado por directivas de grupo

El mes pasado escribí un artículo sobre cómo cambiar el fondo de pantalla establecido a través de directivas de grupo, además de mostrar algunos detalles técnicos sobre las operaciones en registro que se llevan a cabo en el proceso. Como mencioné en ese momento, realizo este cambio manualmente cada que mi equipo actualiza las directivas de grupo, así que decidí construir una pequeña aplicación que realizará este procedimiento cada que lo necesitara y la compartiré por aquí.

SetWall

SetWall es una aplicación de consola que utiliza varias funciones de la API de Windows para modificar el fondo de pantalla y notificarle al sistema operativo para que lo pueda visualizar. No hice modificaciones de seguridad, así que el cambio de fondo durará lo que demoren las directivas de grupo para volverse a forzar en el equipo, pero igual siempre puede volverse a ejecutar la aplicación.

¿Cómo funciona?

Para ejecutar SetWall, basta con abrir un símbolo del sistema con privilegios elevados y lanzar como parámetro la ruta del JPG o PNG:

SetWall.exe [RutaImagen]

Donde [RutaImage] debe contener la extensión del archivo, por ejemplo:

SetWall.exe C:\Imagen.jpg

La aplicación verificará que el archivo exista en la ruta utilizando la función GetFileAttributes y si no hay problemas, procederá a aplicar el fondo de forma local para luego abrir la subclave en donde se almacena la directiva y escribir el nuevo contenido con la ruta de la imagen. Finalmente, llama a la función SystemParametersInfo para notificarle al sistema operativo del cambio y que se pueda ver inmediatamente.

Así es como se ve mi equipo con el fondo corporativo:

image

Para cambiar el fondo por una imagen ubicada en D:\WALL, basta con ejecutar SetWall con el nombre de archivo completo:

SetWall.exe “D:\WALL\img10.jpg”

La aplicación debe notificar el cambio en local y dominio:

SNAGHTML6087a79

En caso de intentar establecer algún TXT u otro tipo de archivo diferente a JPG y PNG, la aplicación nos dará un error:

SNAGHTML6099afc

El resultado final será el fondo de pantalla que queríamos, en vez del corporativo:

image

Descarga

Para los que estén interesados, la aplicación se puede descargar desde aquí:

https://1fichier.com/?mvw7d6fqgp

Si en algún momento logro que el cambio sea permanente, actualizaré la aplicación en el mismo servidor.

Saludos,

—Checho

Monitorear la creación de archivos en Windows utilizando Sysmon

Hace unos días recibí, por fin, mi copia del libro Troubleshooting with the Windows Sysinternals tools de Mark Russinovich y Aaron Margosis, copia que estaba esperando desde principios de año, pero que había tenido retrasos de publicación. Mi pensado es pasar por todas las herramientas lo más detallado posible; sin embargo, después del capítulo introductorio, me concentré en la aplicación más nueva de todas, System Monitor (Sysmon), pues quiero aprovechar este espacio para describir un escenario en el que puede ser de mucha ayuda y aprender por ahí derecho.

Sysmon es una herramienta escrita por Mark Russinovich y Thomas Garnier, basada en los mismos mecanismos que Process Monitor, pero enfocada completamente a rastrear actividad maliciosa en los equipos de la red. Sysmon, a diferencia de casi todas las herramientas de Sysinternals, debe ser instalada para empezar a monitorear, solo se concentra en una serie de eventos y puede utilizarse un archivo XML de configuración para realizar filtros específicos sobre estos eventos. Por otra parte, toda la actividad que Sysmon rastrea queda escrita en el Visor de eventos de Windows para un posterior análisis.

Aunque podría escribir un artículo de uso general de la herramienta, quiero enfocar esta entrada explícitamente a uno de los eventos: creación de archivos. Describiré cómo podemos instalar y configurar Sysmon para que podamos ver en el Visor de eventos todos los archivos que se crean, además de datos importantes como el proceso implicado en la creación, hora exacta, etc.

 

Instalación y configuración de Sysmon

Lo primero que debemos hacer es descargar, instalar y configurar Sysmon en el sistema operativo. A continuación, pasaré a describir cómo realizar todos estos procedimientos.

  1. Descargamos el paquete de Sysmon desde la web de Sysinternals: https://technet.microsoft.com/en-us/sysinternals/sysmon
  2. Creamos una carpeta llamada Sysmon en la unidad de Windows y guardamos el instalador, descomprimido, ahí:

    image

  3. Ejecutamos el símbolo del sistema con privilegios elevados y navegamos hasta la carpeta C:\Sysmon
  4. Creamos y configuramos el archivo de configuración de Sysmon:

Creación del archivo de configuración

El archivo de configuración consiste en un XML que contiene un elemento root, Sysmon,  y varios elementos hijos, con sus respectivos filtros para estos eventos que Sysmon leerá y aplicará. Es necesario indicarle explícitamente qué excluirá y qué incluirá porque si no, Sysmon empezará a escribir en el visor de evento todos los eventos.

Antes de construir el XML, debemos consultar la versión del schema ejecutando el siguiente comando:

sysmon –? config

Veremos, entre bastante información, un formato XML en la consola con la versión del schema.

image

Para el momento de escribir este artículo, la versión es 3.20, pero podría variar cuando lo ejecuten, así que más vale verificar antes de crear el archivo de configuración.

El secreto del archivo de configuración consiste en saber indicarle los filtros para todo lo que deseamos. Para este caso, es necesario deshabilitar todos los eventos adicionales y solo dejar el de FileCreate, correspondiente a la creación de archivos. Así quedaría el archivo:


<Sysmon schemaversion=”3.20″>
<!–Captures only FileCreate events–>
    <EventFiltering>
    <!–Let’s disable all events but FileCreate–>
        <FileCreate onmatch=”exclude”/>
        <ProcessCreate onmatch=”include”/>
        <FileCreateTime onmatch=”include”/>
        <NetworkConnect onmatch=”include”/>
        <ProcessTerminate onmatch=”include”/>
        <DriverLoad onmatch=”include”/>
        <ImageLoad onmatch=”include”/>
        <CreateRemoteThread onmatch=”include”/>
        <RawAccessRead onmatch=”include”/>
        <ProcessAccess onmatch=”include”/>
        <RegistryEvent onmatch=”include”/>               
        <FileCreateStreamHash onmatch=”include”/>   
    </EventFiltering>
</Sysmon>


Noten que el único evento que tiene el atributo onmatch como exclude es el de FileCreate; esto indica que Sysmon va a monitorear toda la actividad que tengan los eventos de creación de archivos. Todos los demás eventos, al estar con el atributo de include y sin ninguna regla de condición, quedarán deshabilitados.

Nota:

Aquí hay que tener cuidado, pues como veremos más adelante, al empezar a jugar con las reglas de condición los atributos varían.

Debemos guardar este archivo con cualquier nombre y extensión .XML. Preferiblemente, almacenarlo en la misma ruta que el ejecutable de Sysmon para que sea fácil referenciarlo. En mi caso le puse el nombre de Config.xml.

image

 

Para proceder, finalmente, con la instalación, ejecutamos desde el símbolo del sistema:

Sysmon.exe –accepteula -i C:\Sysmon\Config.xml

Debemos tener un resultado similar al siguiente:

image

Para verificar cuáles reglas quedaron aplicadas para los filtros, ejecutamos Sysmon –c

image

Revisión del los logs creados por Sysmon

De aquí en adelante basta con abrir el Visor de eventos y navegar hasta Applications and Services logs\Microsoft\Windows\Sysmon\Operational para poder ver todos los eventos que se están generando con respecto a la creación de archivos en nuestro sistema:

image

El evento 11 corresponderá siempre a la creación de archivos, aunque en la categoría lo describe también. Cada fila de información (Information) nos entregará los detalles precisos sobre el evento:

image

Cada evento tiene unos nombres de etiquetas que entregan diferente información. Por ejemplo, en la creación de archivo podemos ver el proceso que lo hizo con la etiqueta de Image; el archivo creado con la etiqueta de TargetFilename y la hora exacta con la etiqueta de CreationUtcTime.

Como está la configuración, vamos a ver todos los eventos de creación de archivos, independiente de que en unos confiemos y en otros no. Esta información es perfecta para auditoría o análisis forense, pero llegará un punto en el que deseemos concentrarnos en uno o más archivos específicamente y ahí Sysmon también nos puede ayudar.

Ahora, supongamos que entre todos los eventos encontramos uno que parece ser malicioso:

image 

Opciones avanzadas

Para poder concentrarnos específicamente en la creación del archivo MalwareFile.txt creado en la unidad de Windows, podemos indicarle fácilmente a Sysmon que solo monitoree las ocurrencias de ese nombre, sin importar en dónde lo escriba.

Nosotros podemos crear unas reglas de condiciones incluyentes o excluyentes con los elementos hijos, es decir, los nombres de etiqueta que aparecen en el evento, para poder suplir diferentes necesidades. Cuando el atributo del elemento es include, todo lo que esté dentro de la etiqueta FileCreate es lo que se escribirá en el Visor de eventos, dependiendo de la condición con la etiqueta.

En el siguiente ejemplo, estoy utilizando la etiqueta TargetFilename para decirle que me muestre siempre los resultados que contengan el nombre de MalwareFile.txt; para conseguir este filtro, utilizo la condición “contains” dentro del nombre de etiqueta, así:

image

De esta forma, no importa en qué unidad se cree el archivo, voy a poder verlo en el Visor de eventos.

La modificación en la configuración de Sysmon no requiere reinicio y se aplica inmeditamente; basta con ejecutar desde el símbolo del sistema con privilegios elevados:

Sysmon –c C:\Sysmon\Config

image

Si utilizamos nuevamente Sysmon –c, veremos que el filtro está aplicado:

image

 

Ahora supongamos que deseamos tener registro de todos los archivos creados que contengan la palabra «Malware» y se copien en la partición del sistema operativo. La regla de condición, teniendo en cuenta las etiquetas de Image y de TargetFilename quedarían expresadas en el XML así:

<FileCreate onmatch=”include”>
            <TargetFilename condition=”image”>C:\</TargetFilename>
            <TargetFilename condition=”contains”>Malware</TargetFilename>
</FileCreate>

Aquí estoy utilizando la etiqueta TargetFilename, que contiene el nombre completo, incluyendo la ruta, para establecer dos reglas de condición:

1. La imagen debe ser el la unidad del sistema operativo, C
2. El archivo debe contener el nombre de «Malware» para que lo escriba en el Visor de eventos

Siempre se debe correr el comando de Sysmon –c con el XML de configuración para que los filtros queden aplicados; es decir:

Sysmon –c C:\Sysmon\Config.xml

De esta forma podríamos ver toda ocurrencia de la palabra «Malware» en los archivos creados en la unidad de Windows:

image

Como pueden ver en el ejemplo, el archivo contiene la palabra clave en la mitad.

Entre mejor implementemos los filtros en Sysmon, más fructífero será nuestro análisis. Es una herramienta sorprendente.

Limitaciones

Si el código de la aplicación tiene como disposición CREATE_ALWAYS, es decir, que el archivo se escriba si no estaba o se sobreescriba si ya estaba, Sysmon solo registrará en el Visor de eventos la primera vez que se escribió, no cuando se haya sobreescrito. Dicho esto, una aplicación podría sobreescribir datos maliciosos sobre un archivo ya creado y no quedaría nada en el Visor de eventos.

Pude contactar a Mark Russinovich sobre esto y él me dijo que estaban considerando agregar la sobreescritura también para una futura actualización.

Espero escribir más adelante sobre el monitoreo de operaciones en registro también.

Saludos,

—Checho

Explorando el «Registry Redirector» en Windows

Antes de empezar

Si no estoy mal, este es el primer artículo en el que escribiré sobre una característica interna del sistema operativo; así que pido disculpas de antemano por cualquier equivocación que tenga y por si el código que aquí expondré no es el más profesional. Dicho esto, ¡empecemos!

Windows de 32 bit en Windows de 64 bit (WOW64)

Debido a que el trabajo de «Registry Redirector» hace parte de WOW64 , es necesario dar una introducción, mas no voy a profundizar porque de esto no se trata el artículo y, a decir verdad, no tengo aún el conocimiento para exponerlo.

«Windows 32 –bit On Windows 64-bit (WOW64)» es una capa de emulación que permite ejecutar aplicaciones basadas en 32 bits en un sistema operativo de 64 bits sin que la aplicación lo llegue a percibir. WOW64 tiene una colección de DLLs en modo usuario (existe modo usuario y modo kernel) que interceptan llamadas desde y hacia un proceso de 32 bits y hace la respectiva traducción para que todo funcione en el ambiente de 64 bits.

Registry Redirector

Lo primero que hay que decir es que este es que el mecanismo que voy a pasar a describir no es nuevo, pues existe desde Windows Vista, pero aún tiene influencia en problemas relacionados a la compatibilidad de aplicaciones.

El trabajo del «Registry Redirector» es aislar las aplicaciones de 32 y de 64 bits de ciertas partes del registro con diferentes nodos  para almacenar la información. Básicamente, intercepta la llamada que hace la aplicación, sea de 32 o de 64 bits, a su respectiva ubicación lógica y la dirige a una ubicación física. Este proceso es completamente transparente para la aplicación (y para nosotros), así que las aplicaciones de 32 bits, por ejemplo, pueden seguir accediendo a sus datos como si estuvieran en un sistema base de 32 bits. Esto es para que puedan correr y convivir sin problemas.

Las subclaves que son dirigidas se guardan en la subclave de Wow6432Node; por ejemplo, todo lo que una aplicación de 32 bits intente escribir en HKEY_LOCAL_MACHINE\Software es dirigido a la subclave HKEY_LOCAL_MACHINE\Wow6432Node.

Nota: de aquí en adelante utilizaré las siglas de HKLM y HKCU para poder referirme a las claves de HKEY_LOCAL_MACHINE y HKEY_CURRENT_USER, respectivamente.

¿Cómo lo vemos en acción?

Para poder ver y entender este mecanismo, decidí escribir, con mi pobre conocimiento en C, una aplicación propuesta por la documentación oficial de Microsoft y mostrarla en este artículo, con la ayuda adicional de Process Monitor.

La aplicación

La aplicación que escribí se llama DemoApp.exe y lo que hace es tratar de abrir la subclave WinSide, ubicada en la subclave HKEY_LOCAL_MACHINE\Software. Si la subclave existe, consulta el contenido del valor predeterminado, Default, y lo muestra en consola; si no, la aplicación crea la subclave de WinSide , escribe el contenido del valor predeterminado y procede a mostrarlo en consola. 

Nota: en cada subclave que se crea siempre existe el valor de Default, que puede o no tener un contenido.

A continuación, muestro una imagen en donde trato de ilustrar las operaciones que hace la aplicación.

SNAGHTML1cd7165

La imagen anterior, aunque resume el comportamiento general de la aplicación, es fiel a la gráfica cuando el ejectuable es de la misma arquitectura que el sistema operativo instalado; sin embargo, cuando la aplicación es de 32 bit y se ejecuta en un sistema de 64, el Registry Redirector actuará sobre la subclave de HKLM\WinSide y la ubicación física cambiará, así:

SNAGHTML36a031

Esta dirección al nodo físico, como ya lo dije, es completamente transparente para la aplicación, así que el desarrollador no tiene que preocuparse realmente por este mecanismo.

El código (para los interesados)

Importante: insisto en que soy un programador novato de C, así que seguramente encontrarán errores o mejoras prácticas en mi código. ¡Cualquier aporte es bienvenido!

Lo primero que hice fue crear una serie de macros para remplazar el mensaje según esté compilada la aplicación; es decir, si ejecuto la versión compilada a 64 bits, el mensaje será «64-bit app on WINx64», de lo contrario, «32-bit app on WINx64».

#ifdef _M_AMD64

#define MSG L”64-bit app on WINx64.\n”

#else

#define MSG L”32-bit app on WINx64.\n”

#endif

Luego creé una función llamada showValue que utiliza la función RegGetValue de la API de Windows para consultar el contenido del valor Default y luego mostrarlo. La función personalizada quedó así:

/*This function receives some variables to show a registry value’s –
content, but only REG_SZ is working by now.*/
void showValue(HKEY openKeyResult, LPCWSTR regValueName, DWORD flags)
{
    //Buffer that receives the value’s data.
    WCHAR valuesData[255];
    PVOID pValuesData = valuesData; //A.K.A. pvData
    DWORD sizeOfBuffer = sizeof(valuesData); //A.K.A. pcbData
    DWORD typeOfData;

    LONG getValue = RegGetValue(openKeyResult, NULL, regValueName,
                                flags, &typeOfData, pValuesData,  &sizeOfBuffer);

    if (getValue != ERROR_SUCCESS)
    {
        wprintf(L”Error getting the value. Code: %li\n”, getValue);
    }
    else
    {
        switch (typeOfData)
        {
        case REG_SZ:
            wprintf(L”Value’s data: %s\n”, (PWCHAR)pValuesData);
            break;

        default:
            wprintf(L”No other types are allowed.\n”);
            break;
        }
    }

}

Nota: RegGetValue está documentada en la página oficial de MSDN:
https://msdn.microsoft.com/en-us/library/windows/desktop/ms724868(v=vs.85).aspx

La función recibe una variable openKeyResult, que es el handle a la subclave abiera previamente con RegOpenkeyEx (en wmain la utilizo); regValueName, que es el nombre del valor a consultar y flags, que me indica el tipo de datos que voy a utilizar.

Finalmente está el código de la función principal wmain. Aquí lo que hice fue declarar las variables necesarias para usar la función RegCreateKeyEx que abre o crea la subclave, luego las que requiere RegSetValueEx para escribir el contenido del valor Default y las de RegGetValue para consultar e imprimir el contenido del valor Default.

La siguiente porción de código se puede resumir así en esta secuencia:

¿Existe la subclave HKEY_LOCAL_MACHINE\Software\WinSide?

  • : consultar e imprimir el contenido del valor Default.
  • No: crear la subclave WinSide, escribir el contenido del valor Default e imprimirlo.

Así se ve todo esto usando C y la API de Windows:

int wmain()
{

    void showValue(HKEY openKeyResult, LPCWSTR regValueName, DWORD flags);
   

    //RegCreateKeyEx
    HKEY hKey = HKEY_LOCAL_MACHINE;
    LPCWSTR subKey = L”Software\\WinSide”;
    DWORD reserved = 0;
    LPWSTR classTypeOfKey = NULL;
    DWORD options = REG_OPTION_NON_VOLATILE;
    REGSAM samDesired = KEY_READ | KEY_WRITE;
    LPSECURITY_ATTRIBUTES securityAttributes = NULL;
    //Handle to the opened or created key.
    HKEY openKeyResult;
    DWORD disposition;

    //RegSetValueEx
    LPCWSTR valueName = NULL; //To set the default value’s content.
    DWORD typeOfData = REG_SZ;
    const BYTE *pData = (const BYTE*)MSG;
    DWORD size = sizeof(MSG);

    //RegGetValue
    LPCWSTR valueNameDefault = NULL; //To get the default value’s data.

    //Restrict the data type of value queried.
    DWORD flags = RRF_RT_ANY;
       

    LONG createKey = RegCreateKeyEx(hKey, subKey, reserved, classTypeOfKey,
                                    options, samDesired, securityAttributes,
                                    &openKeyResult, &disposition);

    if (createKey != ERROR_SUCCESS)
    {
        wprintf(L”Error opening or creating the key. Code: %li\n”, createKey);

    }
    else
    {
        LONG setValue;
       
        switch (disposition)
        {
        case REG_CREATED_NEW_KEY:

            //Let’s create the value!
            setValue = RegSetValueEx(openKeyResult, valueName, reserved,
                typeOfData, pData, size);

            if (setValue != ERROR_SUCCESS)
            {
                wprintf(L”Registry value could not be set.\n”);
            }
            else
            {
                wprintf(L”Registry value set.\n”);
            }

            //Let’s query it!
            showValue(openKeyResult, valueNameDefault, flags);
            break;

        case REG_OPENED_EXISTING_KEY:

            //Let’s query the value!
            showValue(openKeyResult, valueNameDefault, flags);
            break;

        }

        //Closing the key.
        RegCloseKey(openKeyResult);

       
    }

    return 0;

}

Lo más interesante de todo esto es que en las variables hKey y subKey estoy apuntando HKLM como clave y Software\WinSide como subclave, así que en teoría siempre debería escribir ahí; sin embargo, el Registry Redirector se encargará de dirigir la escritura a la ubicación física de acuerdo a la arquitectura del proceso, es decir, HKLM\Software\WinSide para x64 y WKLM\Software\Wow6432Node\WinSide para x86.

El resultado

Afortunadamente, Visual Studio me permite cambiar la arquitectura en la que la aplicación compila sin mucho esfuerzo, así que puedo mostrar el resultado fácilmente.

image

Ejecución de la aplicación a 32 bits en Windows de 64 bits

Cuando lanzo DemoApp.exe compilada a 32 bits, recibo este mensaje:

image

Como lo mencioné en la gráfica de la aplicación y en el código, estoy consultando el contenido del valor Default y mostrándolo. Si analizamos la traza con Process Monitor, veremos lo que ocurrió:

SNAGHTMLb91b44

Primero se muestra la operación de RegCreateKey, la cual intenta abrir la clave y si no existe, la crea; luego RegSetValue para crear el contenido del valor Default y finalmente RegQueryValue, operación que remplaza al RegGetValue en el código que expuse anteriormente para obtener el contenido del valor Default y poder imprimirlo después. Noten que todas las operaciones se hacen sobre la ruta HKLM\Software\WOW6432Node\WinSide, puesto que el proceso es de 32 bits.

Al ingresar a las propiedades de la entrada RegCreateKey, pestaña de Stack, puedo ver todas las ocurrencias de las DLLs, encargadas de interceptar las llamadas y realizar la traducción:

image

La aplicación cree que escribe en la ubicación física nativa, pero en cada operación que haga siempre será dirigida a WOW6432Node\WinSide.

Nota: existe una excepción en donde una aplicación puede leer y escribir en la subclave nativa, así el mecanismo del Registry Redirector esté funcionando; solo es necesario ingresar en la máscara de acceso, samDesired, el derecho de acceso KEY_WOW64_64KEY para usarla luego con RegCreateKeyEx, así:

REGSAM samDesired = KEY_READ | KEY_WRITE | KEY_WOW64_64KEY;

Si al ejecutar la aplicación los descriptores de seguridad (los que me dicen si puedo) no me lo deniega, la aplicación escribirá en HKLM\Software, sin hacer dirección a Wow6432Node.

Nota: no tengo idea de cómo se puede establecer esto en desarrollos con .Net, pero me imagino que existe la forma.

Ejecución de la aplicación a 64 bits en Windows de 64 bits

Esto es lo que pasa cuando lanzo la aplicación, compilada a 64 bits, en Windows de la misma arquitectura:

image

Observen que el mensaje ahora es «64-bit app on WINx64», pero es la misma aplicación.

Así se ve en Process Monitor:

image

Al estar la aplicación a 64 bits, no es necesario que actúe la capa de emulación de WOW64, por ende, el mecanismo del Registry Redirector tampoco se activa y la aplicación escribe en la ubicación nativa: HKLM\Software\WinSide.

Lo mismo a nivel de Stack, la comunicación es directa:

image

Eso es todo lo que tengo para escribir sobre el Registry Redirector. Agradezco mucho cualquier corrección, pues me ayudarán a aprender.

Espero escribir próximamente sobre Registry Reflection para ampliar un poco más WOW64.

Saludos,

—Checho