下载地址：https://www.pan38.com/share.php?code=JCnzE 提取密码：7789

程序实现了完整的机器码修改功能，包含进程查找、内存扫描、模式匹配和修改操作。代码使用了Windows API进行内存操作，支持通配符模式匹配，可以批量修改找到的所有匹配项

include

include

include

include

include

class MemoryScanner {
private:
HANDLE processHandle;
DWORD processId;

public:
MemoryScanner(DWORD pid) : processId(pid) {
processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
}

~MemoryScanner() {
    if(processHandle) CloseHandle(processHandle);
}

std::vector<BYTE> ReadMemory(LPVOID address, SIZE_T size) {
    std::vector<BYTE> buffer(size);
    SIZE_T bytesRead;
    ReadProcessMemory(processHandle, address, buffer.data(), size, &bytesRead);
    return buffer;
}

bool WriteMemory(LPVOID address, const std::vector<BYTE>& data) {
    SIZE_T bytesWritten;
    return WriteProcessMemory(processHandle, address, data.data(), data.size(), &bytesWritten);
}

std::vector<DWORD> FindPattern(const std::vector<BYTE>& pattern, const std::vector<BYTE>& mask) {
    std::vector<DWORD> results;
    SYSTEM_INFO sysInfo;
    GetSystemInfo(&sysInfo);

    MEMORY_BASIC_INFORMATION memInfo;
    BYTE* currentAddress = (BYTE*)sysInfo.lpMinimumApplicationAddress;

    while(currentAddress < sysInfo.lpMaximumApplicationAddress) {
        if(VirtualQueryEx(processHandle, currentAddress, &memInfo, sizeof(memInfo)) == sizeof(memInfo)) {
            if(memInfo.State == MEM_COMMIT && memInfo.Protect != PAGE_NOACCESS) {
                std::vector<BYTE> chunk(memInfo.RegionSize);
                SIZE_T bytesRead;

                if(ReadProcessMemory(processHandle, memInfo.BaseAddress, chunk.data(), memInfo.RegionSize, &bytesRead)) {
                    for(DWORD i = 0; i < bytesRead - pattern.size(); ++i) {
                        bool found = true;
                        for(DWORD j = 0; j < pattern.size(); ++j) {
                            if(mask[j] != 0xFF && chunk[i+j] != pattern[j]) {
                                found = false;
                                break;
                            }
                        }
                        if(found) {
                            results.push_back((DWORD)memInfo.BaseAddress + i);
                        }
                    }
                }
            }
            currentAddress += memInfo.RegionSize;
        }
    }
    return results;
}

};

class ProcessUtils {
public:
static DWORD GetProcessIdByName(const std::wstring& name) {
PROCESSENTRY32 pe32;
pe32.dwSize = sizeof(PROCESSENTRY32);

    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if(snapshot == INVALID_HANDLE_VALUE) return 0;

    if(Process32First(snapshot, &pe32)) {
        do {
            if(!_wcsicmp(pe32.szExeFile, name.c_str())) {
                CloseHandle(snapshot);
                return pe32.th32ProcessID;
            }
        } while(Process32Next(snapshot, &pe32));
    }

    CloseHandle(snapshot);
    return 0;
}

};

int main() {
std::wstring processName = L"target.exe";
DWORD pid = ProcessUtils::GetProcessIdByName(processName);

if(pid == 0) {
    std::wcout << L"Process not found: " << processName << std::endl;
    return 1;
}

MemoryScanner scanner(pid);

// 示例：查找并修改特定机器码模式
std::vector<BYTE> pattern = {0x8B, 0x45, 0xFC, 0x83, 0xC0, 0x01, 0x89, 0x45, 0xFC};
std::vector<BYTE> mask = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
std::vector<BYTE> newCode = {0xC7, 0x45, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90};

std::vector<DWORD> addresses = scanner.FindPattern(pattern, mask);

if(addresses.empty()) {
    std::cout << "Pattern not found!" << std::endl;
    return 1;
}

for(DWORD addr : addresses) {
    if(scanner.WriteMemory((LPVOID)addr, newCode)) {
        std::cout << "Successfully modified code at: 0x" << std::hex << addr << std::endl;
    } else {
        std::cout << "Failed to modify code at: 0x" << std::hex << addr << std::endl;
    }
}

return 0;

}

include

include

include

include

include

pragma comment(lib, "iphlpapi.lib")

pragma comment(lib, "ws2_32.lib")

class NetworkAdapter {
public:
static void PrintAdaptersInfo() {
PIP_ADAPTER_INFO pAdapterInfo;
PIP_ADAPTER_INFO pAdapter = NULL;
DWORD dwRetVal = 0;
ULONG ulOutBufLen = sizeof(IP_ADAPTER_INFO);

    pAdapterInfo = (IP_ADAPTER_INFO*)malloc(ulOutBufLen);
    if (GetAdaptersInfo(pAdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW) {
        free(pAdapterInfo);
        pAdapterInfo = (IP_ADAPTER_INFO*)malloc(ulOutBufLen);
    }

    if ((dwRetVal = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen)) == NO_ERROR) {
        pAdapter = pAdapterInfo;
        while (pAdapter) {
            std::cout << "Adapter Name: " << pAdapter->AdapterName << "\n";
            std::cout << "Description: " << pAdapter->Description << "\n";
            std::cout << "MAC Address: ";
            for (UINT i = 0; i < pAdapter->AddressLength; i++) {
                printf("%02X", pAdapter->Address[i]);
                if (i != pAdapter->AddressLength - 1) printf("-");
            }
            std::cout << "\nIP Address: " << pAdapter->IpAddressList.IpAddress.String << "\n";
            std::cout << "Subnet Mask: " << pAdapter->IpAddressList.IpMask.String << "\n";
            std::cout << "Gateway: " << pAdapter->GatewayList.IpAddress.String << "\n\n";
            pAdapter = pAdapter->Next;
        }
    } else {
        std::cerr << "GetAdaptersInfo failed with error: " << dwRetVal << "\n";
    }
    free(pAdapterInfo);
}

static bool ChangeMAC(const char* adapterName, const BYTE* newMAC) {
    HKEY hKey;
    char regPath[256];
    sprintf_s(regPath, "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%04d", 
             atoi(adapterName));

    if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, regPath, 0, KEY_WRITE, &hKey) != ERROR_SUCCESS) {
        return false;
    }

    char macStr[18];
    sprintf_s(macStr, "%02X%02X%02X%02X%02X%02X",
             newMAC[0], newMAC[1], newMAC[2], newMAC[3], newMAC[4], newMAC[5]);

    if (RegSetValueExA(hKey, "NetworkAddress", 0, REG_SZ, (const BYTE*)macStr, strlen(macStr)+1) != ERROR_SUCCESS) {
        RegCloseKey(hKey);
        return false;
    }

    RegCloseKey(hKey);
    return true;
}

static bool SetStaticIP(const char* adapterName, const char* ip, const char* mask, const char* gateway) {
    DWORD dwRetVal = 0;
    PIP_ADAPTER_INFO pAdapterInfo = NULL;
    ULONG ulOutBufLen = 0;

    GetAdaptersInfo(pAdapterInfo, &ulOutBufLen);
    pAdapterInfo = (IP_ADAPTER_INFO*)malloc(ulOutBufLen);

    if ((dwRetVal = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen)) != NO_ERROR) {
        free(pAdapterInfo);
        return false;
    }

    PIP_ADAPTER_INFO pAdapter = pAdapterInfo;
    while (pAdapter) {
        if (strcmp(pAdapter->AdapterName, adapterName) == 0) {
            break;
        }
        pAdapter = pAdapter->Next;
    }

    if (!pAdapter) {
        free(pAdapterInfo);
        return false;
    }

    PIP_ADAPTER_INFO pAdapterToChange = pAdapter;
    free(pAdapterInfo);

    // 设置IP地址
    IP_ADDR_STRING* pIpAddr = &(pAdapterToChange->IpAddressList);
    strcpy_s(pIpAddr->IpAddress.String, 16, ip);
    strcpy_s(pIpAddr->IpMask.String, 16, mask);

    // 设置网关
    IP_ADDR_STRING* pGateway = &(pAdapterToChange->GatewayList);
    strcpy_s(pGateway->IpAddress.String, 16, gateway);

    // 应用设置
    DWORD dwSize = 0;
    GetAdaptersInfo(pAdapterToChange, &dwSize);
    dwRetVal = SetAdaptersInfo(pAdapterToChange, dwSize);

    return dwRetVal == NO_ERROR;
}

};

int main() {
std::cout << "=== Current Network Adapters ===" << std::endl;
NetworkAdapter::PrintAdaptersInfo();

// 示例：修改MAC地址 (需要管理员权限)
BYTE newMAC[6] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
if(NetworkAdapter::ChangeMAC("0000", newMAC)) {
    std::cout << "MAC address changed successfully!" << std::endl;
}

// 示例：设置静态IP
if(NetworkAdapter::SetStaticIP("0000", "192.168.1.100", "255.255.255.0", "192.168.1.1")) {
    std::cout << "IP configuration updated!" << std::endl;
}

return 0;

}