Untitled

#include <iostream>
#include <windows.h>
#include <iphlpapi.h>
#include <string>
#include <comdef.h>
#include <Wbemidl.h>

#pragma comment(lib, "iphlpapi.lib")
#pragma comment(lib, "wbemuuid.lib")

// Funktion zur Änderung der MAC-Adresse
bool SetMACAddress(const std::string& adapterName, const std::string& newMAC) {
    HKEY hKey;
    std::string regPath = "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}";
    DWORD index = 0;

    while (true) {
        char subKey[256];
        snprintf(subKey, sizeof(subKey), "%s\\%04d", regPath.c_str(), index);
        if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, subKey, 0, KEY_READ | KEY_WRITE, &hKey) != ERROR_SUCCESS) {
            break; // Keine weiteren Subkeys
        }

        char value[256];
        DWORD valueSize = sizeof(value);
        if (RegQueryValueEx(hKey, "DriverDesc", NULL, NULL, (LPBYTE)value, &valueSize) == ERROR_SUCCESS) {
            if (adapterName == value) {
                // MAC-Adresse setzen
                RegSetValueEx(hKey, "NetworkAddress", 0, REG_SZ, (const BYTE*)newMAC.c_str(), newMAC.length());
                RegCloseKey(hKey);
                return true;
            }
        }
        RegCloseKey(hKey);
        ++index;
    }
    return false; // Adapter nicht gefunden
}

// Funktion zur Änderung der Volume Serial Number
bool SetVolumeSerialNumber(const std::string& drive, DWORD newSerial) {
    HANDLE hDevice = CreateFile(
        (drive + "\\").c_str(),
        GENERIC_READ | GENERIC_WRITE,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        NULL,
        OPEN_EXISTING,
        0,
        NULL
    );

    if (hDevice == INVALID_HANDLE_VALUE) {
        std::cerr << "Fehler: Zugriff auf Laufwerk " << drive << " fehlgeschlagen." << std::endl;
        return false;
    }

    struct {
        DWORD SerialNumber;
        DWORD Reserved;
    } inputBuffer;

    inputBuffer.SerialNumber = newSerial;
    inputBuffer.Reserved = 0;

    DWORD bytesReturned;
    BOOL result = DeviceIoControl(
        hDevice,
        IOCTL_DISK_SET_DRIVE_LAYOUT_EX,
        &inputBuffer,
        sizeof(inputBuffer),
        NULL,
        0,
        &bytesReturned,
        NULL
    );

    CloseHandle(hDevice);

    if (!result) {
        std::cerr << "Fehler: Volume Serial Number konnte nicht geändert werden." << std::endl;
        return false;
    }

    std::cout << "Volume Serial Number erfolgreich geändert!" << std::endl;
    return true;
}

// Funktion zur Änderung der CPU-Informationen (Placeholder)
void SpoofCPU() {
    std::cout << "CPU-Informationen können nur durch Virtualisierung oder spezielle Treiber gespooft werden." << std::endl;
    // Beispiel: Verwendung von Virtualisierung (z.B. QEMU)
}

// Funktion zur Änderung der GPU-Informationen (Placeholder)
void SpoofGPU() {
    std::cout << "GPU-Informationen können durch Treiberänderungen oder WMI-Schnittstellen geändert werden." << std::endl;
}

// Funktion zur Änderung der Mainboard-ID (Registry)
void SpoofMainboard() {
    HKEY hKey;
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\BIOS", 0, KEY_SET_VALUE, &hKey) == ERROR_SUCCESS) {
        std::string spoofedID = "1234-5678-ABCD-EFGH";
        RegSetValueEx(hKey, "SystemSerialNumber", 0, REG_SZ, (const BYTE*)spoofedID.c_str(), spoofedID.size() + 1);
        RegCloseKey(hKey);
        std::cout << "Mainboard-ID erfolgreich geändert!" << std::endl;
    } else {
        std::cerr << "Fehler beim Zugriff auf die Registry!" << std::endl;
    }
}

// Funktion zur Änderung der Betriebssystem-Version
void SpoofOS() {
    HKEY hKey;
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", 0, KEY_SET_VALUE, &hKey) == ERROR_SUCCESS) {
        std::string spoofedVersion = "10.0.19045";
        RegSetValueEx(hKey, "CurrentBuild", 0, REG_SZ, (const BYTE*)spoofedVersion.c_str(), spoofedVersion.size() + 1);
        RegCloseKey(hKey);
        std::cout << "Betriebssystem-Version erfolgreich geändert!" << std::endl;
    } else {
        std::cerr << "Fehler beim Zugriff auf die Registry!" << std::endl;
    }
}

int main() {
    int choice;
    std::cout << "Wählen Sie eine Option zum Spoofen:\n";
    std::cout << "1. MAC-Adresse\n";
    std::cout << "2. Volume Serial Number\n";
    std::cout << "3. CPU-Informationen\n";
    std::cout << "4. GPU-Informationen\n";
    std::cout << "5. Mainboard-ID\n";
    std::cout << "6. Betriebssystem-Version\n";
    std::cout << "Ihre Wahl: ";
    std::cin >> choice;

    switch (choice) {
        case 1: {
            std::string adapterName, newMAC;
            std::cout << "Netzwerkadaptername eingeben: ";
            std::cin >> adapterName;
            std::cout << "Neue MAC-Adresse eingeben: ";
            std::cin >> newMAC;
            if (SetMACAddress(adapterName, newMAC)) {
                std::cout << "MAC-Adresse erfolgreich geändert auf " << newMAC << std::endl;
            } else {
                std::cerr << "Fehler beim Ändern der MAC-Adresse." << std::endl;
            }
            break;
        }
        case 2: {
            std::string drive;
            DWORD newSerial;
            std::cout << "Laufwerksbuchstaben eingeben (z.B. C): ";
            std::cin >> drive;
            std::cout << "Neue Volume Serial Number eingeben (hexadezimal, z.B. 0x12345678): ";
            std::cin >> std::hex >> newSerial;
            if (SetVolumeSerialNumber(drive, newSerial)) {
                std::cout << "Volume Serial Number erfolgreich geändert!" << std::endl;
            } else {
                std::cerr << "Fehler beim Ändern der Volume Serial Number." << std::endl;
            }
            break;
        }
        case 3:
            SpoofCPU();
            break;
        case 4:
            SpoofGPU();
            break;
        case 5:
            SpoofMainboard();
            break;
        case 6:
            SpoofOS();
            break;
        default:
            std::cout << "Ungültige Auswahl!" << std::endl;
    }

    return 0;
}