Escrevendo drivers para diferentes versões do Windows

Ao criar um projeto de driver, você especifica o sistema operacional de destino mínimo, que é a versão mínima do Windows em que o driver será executado. Por exemplo, você pode especificar que o Windows 7 é o sistema operacional de destino mínimo. Nesse caso, o driver seria executado no Windows 7 e versões posteriores do Windows.

Escrevendo um driver de várias versões usando apenas recursos comuns

Quando você projeta um driver que será executado em várias versões do Windows, a abordagem mais simples é permitir que o driver use apenas funções e estruturas DDI que são comuns a todas as versões do Windows em que o driver será executado. Nessa situação, você define o sistema operacional de destino mínimo para a versão mais antiga do Windows que o driver suportará.

Por exemplo, para suportar todas as versões do Windows, começando com o Windows 7, deve:

1. Projete e implemente o driver para que ele use apenas os recursos presentes no Windows 7.

2. Ao criar o driver, especifique o Windows 7 como o sistema operacional de destino mínimo.

Embora esse processo seja simples, ele pode restringir o driver para usar apenas um subconjunto da funcionalidade que está disponível em versões posteriores do Windows. Em muitos casos, você desejará fazer uso de funcionalidades mais recentes do sistema operacional quando estiverem disponíveis para melhorar a segurança, melhorar a confiabilidade ou habilitar recursos mais recentes.

Escrevendo um driver de várias versões que usa recursos dependentes da versão

Um driver de modo kernel pode determinar dinamicamente se uma API fornecida pelo sistema operacional está disponível ou em qual versão do Windows o driver está sendo executado e optar por usar recursos que estão disponíveis nesse ambiente de tempo de execução. Por exemplo, um driver que deve suportar todas as versões do Windows, começando com o Windows 7, pode determinar, em tempo de execução, a versão do Windows em que ele está sendo executado. Se o driver estiver sendo executado no Windows 7, ele deve usar apenas as funções DDI que o Windows 7 suporta. No entanto, o mesmo driver pode usar funções DDI adicionais que são exclusivas do Windows 8, por exemplo, quando sua verificação em tempo de execução determina que essas APIs estão presentes no momento ou determina que ele está sendo executado no Windows 8.

Chamando condicionalmente funções dependentes da versão do Windows

Um driver de modo kernel pode usar o MmGetSystemRoutineAddress ou funções de MmGetSystemRoutineAddressEx para verificar dinamicamente se uma API específica que deseja usar está disponível no ambiente de tempo de execução atual e para obter um ponteiro de função para usar para chamar essa API.

Exemplo: Determinar a disponibilidade da API e chamar condicionalmente a API

typedef
NTSTATUS
(*PFN_IoOpenDriverRegistryKey)(
    PDRIVER_OBJECT     DriverObject,
    DRIVER_REGKEY_TYPE RegKeyType,
    ACCESS_MASK        DesiredAccess,
    ULONG              Flags,
    PHANDLE            DriverRegKey
    );

VOID ExampleFunction(VOID) {
    NTSTATUS status = STATUS_UNSUCCESSFUL;
    HANDLE persistentStateKey = NULL;
    PFN_IoOpenDriverRegistryKey pfnIoOpenDriverRegistryKey = NULL;
    UNICODE_STRING functionName = {0};

    RtlInitUnicodeString(&functionName, L"IoOpenDriverRegistryKey");
    pfnIoOpenDriverRegistryKey = (PFN_IoOpenDriverRegistryKey)MmGetSystemRoutineAddress(&functionName);

    if (pfnIoOpenDriverRegistryKey != NULL) {
        // Open a key to where state can be stored under the driver service
        status = pfnIoOpenDriverRegistryKey(g_GlobalStructure.DriverObject,
                                            DriverRegKeyPersistentState,
                                            KEY_WRITE,
                                            0,
                                            &persistentStateKey);
    } else {
        // Fall back to opening up a different location to store state in
    }

    // Use the opened registry key
}

Determinando a versão do Windows

Um driver de modo kernel pode usar a função RtlVerifyVersionInfo para verificar dinamicamente em qual versão do Windows ele está sendo executado no momento.

Exemplo: Determinar a versão do Windows

O exemplo a seguir deteta se a versão do sistema operacional atualmente em execução é maior ou igual à versão 10.0 e deteta se o número de compilação é maior ou igual à compilação 22000 (Windows 11, versão 21H2).

...

NTSTATUS Status = STATUS_SUCCESS;
RTL_OSVERSIONINFOEXW VersionInfo = {0};
ULONG TypeMask = 0;
ULONGLONG ConditionMask = 0;

VersionInfo.dwOSVersionInfoSize = sizeof(VersionInfo);
VersionInfo.dwMajorVersion = 10;
VersionInfo.dwMinorVersion = 0;
VersionInfo.dwBuildNumber = 22000;

TypeMask = VER_MAJORVERSION | VER_MINORVERSION | VER_BUILDNUMBER;
VER_SET_CONDITION(ConditionMask, VER_MAJORVERSION, VER_GREATER_EQUAL);
VER_SET_CONDITION(ConditionMask, VER_MINORVERSION, VER_GREATER_EQUAL);
VER_SET_CONDITION(ConditionMask, VER_BUILDNUMBER, VER_GREATER_EQUAL);

Status = RtlVerifyVersionInfo(&VersionInfo,
                              TypeMask,
                              ConditionMask);

if (NT_SUCCESS(Status)) {

    //
    // The call to RtlVerifyVersionInfo succeeded, so the running OS
    // version and build number is greater than or equal to the value
    // specified. Do appropriate action for newer OS versions.
    //

} else if (Status == STATUS_REVISION_MISMATCH) {

    //
    // The running OS version is less than the value specified. Do
    // appropriate action for older OS versions.
    //

} else {

    //
    // There was an error comparing to the running OS version. Do
    // appropriate action for when the OS version is not known.
    //

}
...