Gravando drivers para versões diferentes do Windows

Ao criar um projeto de driver, especifique 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, seu driver seria executado no Windows 7 e versões posteriores do Windows.

Escrever 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 DDI e estruturas comuns a todas as versões do Windows em que o driver será executado. Nessa situação, você definirá o sistema operacional de destino mínimo para a versão mais antiga do Windows à qual o driver dará suporte.

Por exemplo, para dar suporte a todas as versões do Windows, começando pelo Windows 7, você deve:

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

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

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

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

Um driver no 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á em execução e optar por usar recursos disponíveis nesse ambiente de tempo de execução. Por exemplo, um driver que deve dar suporte a 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 em execução no Windows 7, ele deverá usar apenas as funções DDI compatíveis com o Windows 7. 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 ela está em execução no Windows 8.

Chamar condicionalmente funções dependentes de versão do Windows

Um driver de modo kernel pode usar as funções MmGetSystemRoutineAddress ou 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 a ser usado para chamar essa API.

Exemplo: determinando a disponibilidade da API e chamando 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 no modo kernel pode usar a função RtlVerifyVersionInfo para verificar dinamicamente em qual versão do Windows ele está sendo executado no momento.

Exemplo: determinando a versão do Windows

O exemplo a seguir detecta se a versão do sistema operacional atualmente em execução é maior ou igual à versão 10.0 e detecta se o número de build é maior ou igual ao build 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.
    //

}
...