Lesen und Schreiben der Windows-Registrierung mit WinAPI

Lesen und Schreiben der Windows-Registrierung mit WinAPI

Wenn Sie der Windows-Anwendungs- oder Treiberentwickler sind, müssen Sie möglicherweise auf die Windows-Registrierung zugreifen. In diesem Artikel werde ich beschreiben, wie Sie den Schlüssel in der Windows-Registrierung erstellen und darauf zugreifen. Hier gehe ich davon aus, dass Sie mit Windows-Interna und API vertraut sind. Wenn Sie mit Windows Internal und API nicht vertraut sind,sehen Sie sich diesen beliebten Kurs an:Windows Internals

Unten finden Sie die Liste einiger WinAPIs, die ich verwende, um den Windows-Registrierungsschlüssel zu erstellen und darauf zuzugreifen:

RegOpenKeyEx
RegCreateKeyEx
RegSetValueEx
RegQueryValueEx
RegCloseKey

Hier finden Sie eine vollständige Liste der Registrierungsfunktionen – MSDN.

Hinweis: Um auf die Windows-Registrierung zuzugreifen, sollten Sie über Administratorrechte verfügen.

Bevor wir den Schlüssel erstellen, müssen wir die Windows-Registrierungsstrukturen verstehen. Die Hives sind die Gruppe von Registrierungsschlüsseln, Unterschlüsseln und Registrierungswerten.

Sie können die Registrierungsstrukturen im Registrierungseditor auf der linken Seite des Bildschirms sehen. Sie können den Registrierungseditor öffnen, um den Befehl regedit auszuführen im Suchfeld oder im Ausführungsfenster.

Hier ist eine Liste einiger gängiger Registrierungsstrukturen in Windows:

HKEY_CLASSES_ROOT
HKEY_CURRENT_USER
HKEY_LOCAL_MACHINE
HKEY_USERS
HKEY_CURRENT_CONFIG

Ich denke jetzt mal den Beispielcode zu sehen. In diesem Beispielcode erstelle ich einen Schlüssel und lese/schreibe den Wert.

So erstellen Sie einen Schlüssel unter den Bienenstöcken:

In diesem Code müssen Sie nur die Registrierungsstrukturen und den Schlüsselnamen übergeben, die Sie erstellen möchten. Wenn alles in Ordnung ist, erstellt diese Funktion den Schlüssel unter den angegebenen Bienenstöcken.

BOOL CreateRegistryKey(HKEY hKeyParent,PWCHAR subkey)
{
    DWORD dwDisposition; //It verify new key is created or open existing key
    HKEY  hKey;
    DWORD Ret;


    Ret =
        RegCreateKeyEx(
            hKeyParent,
            subkey,
            0,
            NULL,
            REG_OPTION_NON_VOLATILE,
            KEY_ALL_ACCESS,
            NULL,
            &hKey,
            &dwDisposition);

    if (Ret != ERROR_SUCCESS)
    {
        printf("Error opening or creating new key\n");
        return FALSE;
    }

    RegCloseKey(hKey); //close the key
    return TRUE;
}

Schreiben Sie einen DWORD-Wert in den erstellten Schlüssel:

In dieser Funktion müssen Sie den Hives-Namen, den Schlüsselnamen, den Wertnamen und den DWORD-Wert übergeben, die Sie im Schlüssel speichern möchten. In dieser Funktion öffne ich den Schlüssel und schreibe nur den Wert. Wenn alles in Ordnung ist, wird der Wert in der Registrierung gespeichert.

BOOL WriteInRegistry(HKEY hKeyParent, PWCHAR subkey, PWCHAR valueName,DWORD data)
{
    DWORD Ret; //use to check status
    HKEY hKey; //key


    //Open the key
    Ret = RegOpenKeyEx(
              hKeyParent,
              subkey,
              0,
              KEY_WRITE,
              &hKey
          );

    if (Ret == ERROR_SUCCESS)
    {

        //Set the value in key
        if (ERROR_SUCCESS !=
                RegSetValueEx(
                    hKey,
                    valueName,
                    0,
                    REG_DWORD,
                    reinterpret_cast<BYTE *>(&data),
                    sizeof(data)))
        {
            RegCloseKey(hKey);
            return FALSE;
        }

        //close the key
        RegCloseKey(hKey);

        return TRUE;
    }

    return FALSE;
}

Wenn Sie Online-Kurse lieben, dann ist hier ein guter C-Sprachkurs von Pluralsight für Sie, die 10-tägige Testversion ist kostenlos.

Schreiben Sie eine Zeichenfolge in den erstellten Schlüssel:

In dieser Funktion müssen Sie den Hives-Namen, den Schlüsselnamen, den Wertnamen und die Zeichenfolge übergeben, die Sie im Schlüssel speichern möchten. Hier müssen Sie daran denken, dass die Größe von Wide Char 16 Bit beträgt, also müssen Sie vorsichtig sein, bevor Sie die Zeichenfolge in die Windows-Registrierung schreiben.

BOOL writeStringInRegistry(HKEY hKeyParent, PWCHAR subkey, PWCHAR valueName, PWCHAR strData)
{
    DWORD Ret;
    HKEY hKey;

    //Check if the registry exists
    Ret = RegOpenKeyEx(
              hKeyParent,
              subkey,
              0,
              KEY_WRITE,
              &hKey
          );

    if (Ret == ERROR_SUCCESS)
    {
        if (ERROR_SUCCESS !=
                RegSetValueEx(
                    hKey,
                    valueName,
                    0,
                    REG_SZ,
                    (LPBYTE)(strData),
                    ((((DWORD)lstrlen(strData) + 1)) * 2)))
        {
            RegCloseKey(hKey);
            return FALSE;
        }

        RegCloseKey(hKey);
        return TRUE;
    }

    return FALSE;
}

Lesen Sie einen DWORD-Wert aus dem erstellten Schlüssel:

Bevor Sie den Wert aus einem Schlüssel lesen, sollten Sie ihn zuerst öffnen. Sie benötigen Hives-Name, Schlüsselname und Wertname, um das DWORD zu lesen.

BOOL readDwordValueRegistry(HKEY hKeyParent, PWCHAR subkey, PWCHAR valueName, DWORD *readData)
{

    HKEY hKey;
    DWORD Ret;

    //Check if the registry exists
    Ret = RegOpenKeyEx(
              hKeyParent,
              subkey,
              0,
              KEY_READ,
              &hKey
          );

    if (Ret == ERROR_SUCCESS)
    {

        DWORD data;
        DWORD len = sizeof(DWORD);//size of data

        Ret = RegQueryValueEx(
                  hKey,
                  valueName,
                  NULL,
                  NULL,
                  (LPBYTE)(&data),
                  &len
              );

        if (Ret == ERROR_SUCCESS)
        {
            RegCloseKey(hKey);
            (*readData) = data;
            return TRUE;
        }

        RegCloseKey(hKey);
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

Lesen Sie eine Zeichenfolge aus dem erstellten Schlüssel:

Ähnlich der obigen Methode. Sie benötigen Hives-Name, Schlüsselname und Wertname, um die Zeichenfolge aus dem Schlüssel zu lesen. Bevor Sie die Zeichenfolge lesen, müssen Sie die richtige Länge der Zeichenfolge angeben, sonst erhalten Sie eine Fehlermeldung.

BOOL readStringFromRegistry(HKEY hKeyParent, PWCHAR subkey, PWCHAR valueName, PWCHAR *readData)
{
    HKEY hKey;
    DWORD len = TOTAL_BYTES_READ;

    DWORD readDataLen = len;

    PWCHAR readBuffer = (PWCHAR )malloc(sizeof(PWCHAR)* len);
    if (readBuffer == NULL)
        return FALSE;

    //Check if the registry exists
    DWORD Ret = RegOpenKeyEx(
                    hKeyParent,
                    subkey,
                    0,
                    KEY_READ,
                    &hKey
                );

    if (Ret == ERROR_SUCCESS)
    {

        Ret = RegQueryValueEx(
                  hKey,
                  valueName,
                  NULL,
                  NULL,
                  (BYTE*)readBuffer,
                  &readDataLen
              );

        while (Ret == ERROR_MORE_DATA)
        {
            // Get a buffer that is big enough.

            len += OFFSET_BYTES;
            readBuffer = (PWCHAR)realloc(readBuffer, len);
            readDataLen = len;

            Ret = RegQueryValueEx(
                      hKey,
                      valueName,
                      NULL,
                      NULL,
                      (BYTE*)readBuffer,
                      &readDataLen
                  );
        }

        if (Ret != ERROR_SUCCESS)
        {
            RegCloseKey(hKey);
            return false;;
        }

        *readData = readBuffer;

        RegCloseKey(hKey);
        return true;
    }
    else
    {
        return false;
    }
}

Um die obigen Methoden zu verstehen, sehen Sie sich einen Beispielcode an. Im folgenden Beispiel habe ich einen Schlüssel „Artikelwelt“ und zwei Werte „Datum“ und „Nachricht“ erstellt. Ich werde den gespeicherten Wert des Schlüssels mit den oben beschriebenen Methoden speichern und auslesen.

#include "stdafx.h"
#include <windows.h>
#include <stdio.h>

#define TOTAL_BYTES_READ    1024
#define OFFSET_BYTES 1024


//Create key in registry
BOOL CreateRegistryKey(HKEY hKeyParent,PWCHAR subkey)
{
    DWORD dwDisposition; //It verify new key is created or open existing key
    HKEY  hKey;
    DWORD Ret;


    Ret =
        RegCreateKeyEx(
            hKeyParent,
            subkey,
            0,
            NULL,
            REG_OPTION_NON_VOLATILE,
            KEY_ALL_ACCESS,
            NULL,
            &hKey,
            &dwDisposition);

    if (Ret != ERROR_SUCCESS)
    {
        printf("Error opening or creating key.\n");
        return FALSE;
    }

    RegCloseKey(hKey);
    return TRUE;
}


//Write data in registry
BOOL WriteDwordInRegistry(HKEY hKeyParent, PWCHAR subkey, PWCHAR valueName,DWORD data)
{
    DWORD Ret;
    HKEY hKey;


    //Open the key
    Ret = RegOpenKeyEx(
              hKeyParent,
              subkey,
              0,
              KEY_WRITE,
              &hKey
          );

    if (Ret == ERROR_SUCCESS)
    {

        //Set the value in key
        if (ERROR_SUCCESS !=
                RegSetValueEx(
                    hKey,
                    valueName,
                    0,
                    REG_DWORD,
                    reinterpret_cast<BYTE *>(&data),
                    sizeof(data)))
        {
            RegCloseKey(hKey);
            return FALSE;
        }

        //close the key
        RegCloseKey(hKey);

        return TRUE;
    }

    return FALSE;
}


//Read data from registry
BOOL readDwordValueRegistry(HKEY hKeyParent, PWCHAR subkey, PWCHAR valueName, DWORD *readData)
{

    HKEY hKey;
    DWORD Ret;

    //Check if the registry exists
    Ret = RegOpenKeyEx(
              hKeyParent,
              subkey,
              0,
              KEY_READ,
              &hKey
          );

    if (Ret == ERROR_SUCCESS)
    {

        DWORD data;
        DWORD len = sizeof(DWORD);//size of data

        Ret = RegQueryValueEx(
                  hKey,
                  valueName,
                  NULL,
                  NULL,
                  (LPBYTE)(&data),
                  &len
              );

        if (Ret == ERROR_SUCCESS)
        {
            RegCloseKey(hKey);
            (*readData) = data;
            return TRUE;
        }

        RegCloseKey(hKey);
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}



//Write range and type into the registry
BOOL writeStringInRegistry(HKEY hKeyParent, PWCHAR subkey, PWCHAR valueName, PWCHAR strData)
{
    DWORD Ret;
    HKEY hKey;

    //Check if the registry exists
    Ret = RegOpenKeyEx(
              hKeyParent,
              subkey,
              0,
              KEY_WRITE,
              &hKey
          );

    if (Ret == ERROR_SUCCESS)
    {
        if (ERROR_SUCCESS !=
                RegSetValueEx(
                    hKey,
                    valueName,
                    0,
                    REG_SZ,
                    (LPBYTE)(strData),
                    ((((DWORD)lstrlen(strData) + 1)) * 2)))
        {
            RegCloseKey(hKey);
            return FALSE;
        }

        RegCloseKey(hKey);
        return TRUE;
    }

    return FALSE;
}

//read customer infromation from the registry
BOOL readUserInfoFromRegistry(HKEY hKeyParent, PWCHAR subkey, PWCHAR valueName, PWCHAR *readData)
{
    HKEY hKey;
    DWORD len = TOTAL_BYTES_READ;

    DWORD readDataLen = len;

    PWCHAR readBuffer = (PWCHAR )malloc(sizeof(PWCHAR)* len);
    if (readBuffer == NULL)
        return FALSE;

    //Check if the registry exists
    DWORD Ret = RegOpenKeyEx(
                    hKeyParent,
                    subkey,
                    0,
                    KEY_READ,
                    &hKey
                );

    if (Ret == ERROR_SUCCESS)
    {

        Ret = RegQueryValueEx(
                  hKey,
                  valueName,
                  NULL,
                  NULL,
                  (BYTE*)readBuffer,
                  &readDataLen
              );

        while (Ret == ERROR_MORE_DATA)
        {
            // Get a buffer that is big enough.

            len += OFFSET_BYTES;
            readBuffer = (PWCHAR)realloc(readBuffer, len);
            readDataLen = len;

            Ret = RegQueryValueEx(
                      hKey,
                      valueName,
                      NULL,
                      NULL,
                      (BYTE*)readBuffer,
                      &readDataLen
                  );
        }

        if (Ret != ERROR_SUCCESS)
        {
            RegCloseKey(hKey);
            return false;;
        }

        *readData = readBuffer;

        RegCloseKey(hKey);
        return true;
    }
    else
    {
        return false;
    }
}

//main function
int _tmain(int argc, _TCHAR* argv[])
{
    BOOL status;
    DWORD readData;
    PWCHAR readMessage = nullptr;

    status = CreateRegistryKey(HKEY_CURRENT_USER, L"Aticleworld"); //create key
    if (status != TRUE)
        return FALSE;

    status = WriteDwordInRegistry(HKEY_CURRENT_USER, L"Aticleworld",L"date",12082016); //write dword
    if (status != TRUE)
        return FALSE;

    status = readDwordValueRegistry(HKEY_CURRENT_USER, L"Aticleworld", L"date", &readData); //read dword
    if (status != TRUE)
        return FALSE;

    printf("%ld", readData);

    status = writeStringInRegistry(HKEY_CURRENT_USER, L"Aticleworld", L"Message", L"Happy"); //write string
    if (status != TRUE)
        return FALSE;

    status = readUserInfoFromRegistry(HKEY_CURRENT_USER, L"Aticleworld", L"Message", &readMessage); //read string
    if (status != TRUE)
        return FALSE;

    if (readMessage != nullptr)
    {
        printf(" Message = %S\n", readMessage);
        free(readMessage);
        readMessage = nullptr;
    }

    return 0;
}

Die 5 besten C-Bücher.
Ermitteln Sie den COM-PORT des seriellen USB-Geräts mithilfe von VID und PID.
Serielle Port-Programmierung mit Win32-API.
Installieren Sie den Port-Monitor im Hintergrund ohne Benutzereingriff.
C++-Interviewfragen mit Antworten.
C-Sharp-Interviewfragen.
Python-Interviewfragen mit Antwort.
Speicherlayout in C.
100-C-Interviewfragen, die Ihr Interviewer stellen könnte.
C Interviewfragen für die Erfahrung.
10 Fragen zur dynamischen Speicherzuweisung
Dateiverwaltung in C in wenigen Stunden.