BlackPlague

A static rust encryption/decryption dumper. Just load gameassembly and metadata and hit load metadata and then dump button or advanced users can search and dump only what you want. dumper.zip

Updated. This time should be work :D

Thanks for share.

You need to be compile project. #include <windows.h> #include <tlhelp32.h> #include <psapi.h> #include <winsvc.h> #include <iostream> #include <vector> #include <string> #include <sstream> #include <algorithm> #include <io.h> #include <fcntl.h> #include <conio.h> #include <cmath> #include <ctime> #include <windows.h> #include <tlhelp32.h> #include <iostream> #include <thread> #include <chrono> #include <tchar.h> #include <windows.h> #include <tlhelp32.h> #include <psapi.h> #include <winsvc.h> #include <iostream> #include <vector> #include <string> #include <sstream> #include <algorithm> #include <io.h> #include <fcntl.h> #include <conio.h> #include <cmath> #include <ctime> using namespace std; void Center(const std::string& text) { CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi); int consoleWidth = csbi.srWindow.Right - csbi.srWindow.Left + 1; int padding = (consoleWidth - text.size()) / 2; if (padding < 0) padding = 0; cout << string(padding, ' ') << text << endl; } bool IsElevated() { BOOL isAdmin = FALSE; HANDLE token = NULL; if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token)) { TOKEN_ELEVATION elevation; DWORD size = sizeof(TOKEN_ELEVATION); if (GetTokenInformation(token, TokenElevation, &elevation, sizeof(elevation), &size)) { isAdmin = elevation.TokenIsElevated; } CloseHandle(token); } return isAdmin != FALSE; } void CHECK_ADMIN() { if (IsElevated()) { // Already admin → do nothing return; } // Not admin → relaunch self as admin wchar_t szPath[MAX_PATH]; GetModuleFileNameW(NULL, szPath, MAX_PATH); SHELLEXECUTEINFOW sei = { sizeof(sei) }; sei.lpVerb = L"runas"; sei.lpFile = szPath; sei.hwnd = NULL; sei.nShow = SW_NORMAL; if (ShellExecuteExW(&sei)) { // Success → child process started with admin rights exit(0); // kill the non-elevated instance } else { // User clicked "No" on UAC or error Center("[!] Failed to elevate to administrator."); Center("[!] Run the program as administrator manually."); Sleep(4000); exit(1); } } bool IsVgcRunning() { SC_HANDLE scManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); if (scManager == NULL) { std::cerr << "OpenSCManager failed: " << GetLastError() << std::endl; return false; } SC_HANDLE service = OpenService(scManager, L"vgc", SERVICE_QUERY_STATUS); if (service == NULL) { std::cerr << "OpenService failed: " << GetLastError() << std::endl; CloseServiceHandle(scManager); return false; } SERVICE_STATUS_PROCESS ssStatus; DWORD bytesNeeded; if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssStatus, sizeof(SERVICE_STATUS_PROCESS), &bytesNeeded)) { std::cerr << "QueryServiceStatusEx failed: " << GetLastError() << std::endl; CloseServiceHandle(service); CloseServiceHandle(scManager); return false; } CloseServiceHandle(service); CloseServiceHandle(scManager); return ssStatus.dwCurrentState == SERVICE_RUNNING; } bool StartVgc() { SC_HANDLE scManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS); if (scManager == NULL) { std::cerr << "OpenSCManager failed: " << GetLastError() << std::endl; return false; } SC_HANDLE service = OpenService(scManager, L"vgc", SERVICE_START); if (service == NULL) { std::cerr << "OpenService failed: " << GetLastError() << std::endl; CloseServiceHandle(scManager); return false; } if (!StartService(service, 0, NULL)) { std::cerr << "StartService failed: " << GetLastError() << std::endl; CloseServiceHandle(service); CloseServiceHandle(scManager); return false; } CloseServiceHandle(service); CloseServiceHandle(scManager); return true; } bool IsProcessRunning(const TCHAR* executableName) { PROCESSENTRY32 entry; entry.dwSize = sizeof(PROCESSENTRY32); HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); if (snapshot == INVALID_HANDLE_VALUE) return false; if (!Process32First(snapshot, &entry)) { CloseHandle(snapshot); return false; } do { if (!_tcsicmp(entry.szExeFile, executableName)) { CloseHandle(snapshot); return true; } } while (Process32Next(snapshot, &entry)); CloseHandle(snapshot); return false; } #define PURPLE 13 #define GREEN 10 #define RED 12 #define YELLOW 14 void SetColor(int c) { SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), c); } void LOGO() { SetColor(PURPLE); cout << R"( ____________________________________________________________ | ___ ___ __ ___ _______ ___ ___ | | |" \ /" |/""\ |" | /" "||" \/" | | | \ \ // // \ || | (: ______) \ \ / | | \\ \/. .//' /\ \ |: | \/ | \\ \/ | | \. //// __' \ \ |___ // ___)_ /\. \ | | \\ // / \\ \( \_|: \(: "| / \ \ | | \__/(___/ \___)\_______)\_______)|___/\___| | | | ____________________________________________________________ )" << endl; } void WaitForProcessToOpen(const TCHAR* processName) { SetColor(YELLOW); Center("==================================================================="); Center("[+] Waiting for VALORANT to start..."); Center("==================================================================="); // Get console width CONSOLE_SCREEN_BUFFER_INFO csbi; HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); GetConsoleScreenBufferInfo(hConsole, &csbi); int consoleWidth = csbi.srWindow.Right - csbi.srWindow.Left + 1; string base = "[+] Waiting"; int dots = 0; // Print a blank centered line where animation will be int animPad = (consoleWidth - (int)base.size() - 3) / 2; cout << endl; cout << string(animPad, ' ') << base << " " << endl; // Save cursor position (this is where animation will update) CONSOLE_SCREEN_BUFFER_INFO posInfo; GetConsoleScreenBufferInfo(hConsole, &posInfo); int animX = animPad; int animY = posInfo.dwCursorPosition.Y - 1; // line we just printed while (!IsProcessRunning(processName)) { // Move cursor to animation position COORD pos; pos.X = animX; pos.Y = animY; SetConsoleCursorPosition(hConsole, pos); // Print animation cout << base << string(dots, '.') << " "; dots = (dots + 1) % 4; cout.flush(); std::this_thread::sleep_for(std::chrono::milliseconds(400)); } // When found, move cursor down and print message COORD endPos; endPos.X = 0; endPos.Y = animY + 2; SetConsoleCursorPosition(hConsole, endPos); SetColor(GREEN); Center("[+] VALORANT FOUND!"); cout << endl; } void PrintASCIIArt(); void PrintColoredText(const std::wstring& text, bool animated); class PopupBypass { private: std::vector<DWORD> dnsCacheThreadler; std::vector<DWORD> svchostThreadler; std::vector<DWORD> askiyaAlinanThreadler; HANDLE hDnsCacheProcess; DWORD vgcPID; DWORD svchostPID; bool bypassAktif; bool dnsFreezeYapildi; struct ProcessCpuInfo { DWORD pid; ULONGLONG lastKernelTime; ULONGLONG lastUserTime; }; ProcessCpuInfo vgcCpuInfo; bool HataAyiklamaHaklariniEtkinlestir() { HANDLE hToken; TOKEN_PRIVILEGES tp; LUID luid; if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) return false; if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid)) { CloseHandle(hToken); return false; } tp.PrivilegeCount = 1; tp.Privileges[0].Luid = luid; tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), NULL, NULL); CloseHandle(hToken); return true; } DWORD ProsesBul(const std::wstring& prosesIsmi) { HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); if (hSnapshot == INVALID_HANDLE_VALUE) return 0; PROCESSENTRY32W pe; pe.dwSize = sizeof(pe); if (!Process32FirstW(hSnapshot, &pe)) { CloseHandle(hSnapshot); return 0; } do { std::wstring mevcutProses(pe.szExeFile); std::transform(mevcutProses.begin(), mevcutProses.end(), mevcutProses.begin(), ::towlower); std::wstring hedefProses(prosesIsmi); std::transform(hedefProses.begin(), hedefProses.end(), hedefProses.begin(), ::towlower); if (mevcutProses == hedefProses) { CloseHandle(hSnapshot); return pe.th32ProcessID; } } while (Process32NextW(hSnapshot, &pe)); CloseHandle(hSnapshot); return 0; } void ValorantKapat() { DWORD valorantPID = ProsesBul(L"VALORANT-Win64-Shipping.exe"); if (valorantPID != 0) { HANDLE hValorant = OpenProcess(PROCESS_TERMINATE, FALSE, valorantPID); if (hValorant) { TerminateProcess(hValorant, 0); CloseHandle(hValorant); } } } void KillProcessByName(const wchar_t* processName) { HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); if (hSnapshot == INVALID_HANDLE_VALUE) return; PROCESSENTRY32W pe; pe.dwSize = sizeof(pe); if (Process32FirstW(hSnapshot, &pe)) { do { std::wstring currentProcess(pe.szExeFile); std::transform(currentProcess.begin(), currentProcess.end(), currentProcess.begin(), ::towlower); std::wstring targetProcess(processName); std::transform(targetProcess.begin(), targetProcess.end(), targetProcess.begin(), ::towlower); if (currentProcess == targetProcess) { HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pe.th32ProcessID); if (hProcess) { TerminateProcess(hProcess, 0); CloseHandle(hProcess); } } } while (Process32NextW(hSnapshot, &pe)); } CloseHandle(hSnapshot); } bool ServisDurdur(const wchar_t* serviceName) { SC_HANDLE hSCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT); if (!hSCManager) return false; SC_HANDLE hService = OpenServiceW(hSCManager, serviceName, SERVICE_STOP | SERVICE_QUERY_STATUS); if (!hService) { CloseServiceHandle(hSCManager); return false; } SERVICE_STATUS_PROCESS ssp; DWORD dwBytesNeeded; if (QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp, sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded)) { if (ssp.dwCurrentState != SERVICE_STOPPED) { ControlService(hService, SERVICE_CONTROL_STOP, (LPSERVICE_STATUS)&ssp); for (int i = 0; i < 50; i++) { Sleep(100); if (QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp, sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded)) { if (ssp.dwCurrentState == SERVICE_STOPPED) break; } } } } CloseServiceHandle(hService); CloseServiceHandle(hSCManager); return true; } bool ServisBaslat(const wchar_t* serviceName) { SC_HANDLE hSCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT); if (!hSCManager) return false; SC_HANDLE hService = OpenServiceW(hSCManager, serviceName, SERVICE_START | SERVICE_QUERY_STATUS); if (!hService) { CloseServiceHandle(hSCManager); return false; } SERVICE_STATUS_PROCESS ssp; DWORD dwBytesNeeded; if (QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp, sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded)) { if (ssp.dwCurrentState == SERVICE_STOPPED) { StartServiceW(hService, 0, NULL); for (int i = 0; i < 50; i++) { Sleep(100); if (QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp, sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded)) { if (ssp.dwCurrentState == SERVICE_RUNNING) break; } } } } CloseServiceHandle(hService); CloseServiceHandle(hSCManager); return true; } void NetshKomutu(const std::wstring& komut) { STARTUPINFOW si = { sizeof(STARTUPINFOW) }; PROCESS_INFORMATION pi = {}; si.dwFlags = STARTF_USESHOWWINDOW; si.wShowWindow = SW_HIDE; std::wstring cmdLine = L"netsh.exe " + komut; std::vector<wchar_t> cmdBuffer(cmdLine.begin(), cmdLine.end()); cmdBuffer.push_back(L'\0'); CreateProcessW(nullptr, cmdBuffer.data(), nullptr, nullptr, FALSE, CREATE_NO_WINDOW | CREATE_NEW_CONSOLE, nullptr, nullptr, &si, &pi); if (pi.hProcess) { WaitForSingleObject(pi.hProcess, 2000); CloseHandle(pi.hProcess); CloseHandle(pi.hThread); } } void GuvenlikDuvariKuraliEkle(const std::wstring& kuralIsmi, const std::wstring& programYolu, bool giden) { std::wstringstream ss; ss << L"advfirewall firewall add rule name=\"" << kuralIsmi << L"\" dir=" << (giden ? L"out" : L"in") << L" action=block program=\"" << programYolu << L"\" enable=yes profile=any"; NetshKomutu(ss.str()); } void GuvenlikDuvariKuraliSil(const std::wstring& kuralIsmi) { std::wstringstream ss; ss << L"advfirewall firewall delete rule name=\"" << kuralIsmi << L"\""; NetshKomutu(ss.str()); } void GuvenlikDuvariEngellemeleri() { std::wstring vgcYolu = L"C:\\Program Files\\Riot Vanguard\\vgc.exe"; std::wstring vgmYolu = L"C:\\Program Files\\Riot Vanguard\\vgm.exe"; GuvenlikDuvariKuraliEkle(L"Block vgc.exe Outbound", vgcYolu, true); GuvenlikDuvariKuraliEkle(L"Block vgm.exe Outbound", vgmYolu, true); } void GuvenlikDuvariKurallariniTemizle() { GuvenlikDuvariKuraliSil(L"Block vgc.exe Outbound"); GuvenlikDuvariKuraliSil(L"Block vgc.exe Inbound"); GuvenlikDuvariKuraliSil(L"Block vgm.exe Outbound"); } DWORD GetServicePID(const wchar_t* serviceName) { SC_HANDLE hSCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE); if (!hSCManager) return 0; SC_HANDLE hService = OpenServiceW(hSCManager, serviceName, SERVICE_QUERY_STATUS); if (!hService) { CloseServiceHandle(hSCManager); return 0; } SERVICE_STATUS_PROCESS ssp; DWORD dwBytesNeeded; if (!QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp, sizeof(SERVICE_STATUS_PROCESS), &dwBytesNeeded)) { CloseServiceHandle(hService); CloseServiceHandle(hSCManager); return 0; } DWORD pid = ssp.dwProcessId; CloseServiceHandle(hService); CloseServiceHandle(hSCManager); return pid; } bool DnsCacheFreeze() { ServisDurdur(L"Dnscache"); Sleep(300); ServisBaslat(L"Dnscache"); Sleep(500); DWORD dnsPid = GetServicePID(L"Dnscache"); if (dnsPid == 0) return false; hDnsCacheProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dnsPid); if (!hDnsCacheProcess) return false; HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0); if (hSnapshot == INVALID_HANDLE_VALUE) return false; THREADENTRY32 te; te.dwSize = sizeof(THREADENTRY32); dnsCacheThreadler.clear(); if (Thread32First(hSnapshot, &te)) { do { if (te.th32OwnerProcessID == dnsPid) { HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, te.th32ThreadID); if (hThread) { SuspendThread(hThread); dnsCacheThreadler.push_back(te.th32ThreadID); CloseHandle(hThread); } } } while (Thread32Next(hSnapshot, &te)); } CloseHandle(hSnapshot); dnsFreezeYapildi = !dnsCacheThreadler.empty(); return dnsFreezeYapildi; } void DnsCacheUnfreeze() { for (DWORD threadID : dnsCacheThreadler) { HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, threadID); if (hThread) { ResumeThread(hThread); CloseHandle(hThread); } } dnsCacheThreadler.clear(); if (hDnsCacheProcess) { CloseHandle(hDnsCacheProcess); hDnsCacheProcess = NULL; } dnsFreezeYapildi = false; } bool SvchostSuspend() { DWORD dnsServicePID = GetServicePID(L"Dnscache"); if (dnsServicePID == 0) return false; svchostThreadler.clear(); bool basarili = false; HANDLE hSnapshotThread = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0); if (hSnapshotThread != INVALID_HANDLE_VALUE) { THREADENTRY32 te; te.dwSize = sizeof(THREADENTRY32); if (Thread32First(hSnapshotThread, &te)) { do { if (te.th32OwnerProcessID == dnsServicePID) { HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, te.th32ThreadID); if (hThread) { SuspendThread(hThread); svchostThreadler.push_back(te.th32ThreadID); basarili = true; CloseHandle(hThread); } } } while (Thread32Next(hSnapshotThread, &te)); } CloseHandle(hSnapshotThread); } if (basarili) { svchostPID = dnsServicePID; } return basarili; } void SvchostResume() { for (DWORD threadID : svchostThreadler) { HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, threadID); if (hThread) { ResumeThread(hThread); CloseHandle(hThread); } } svchostThreadler.clear(); svchostPID = 0; } double GetVgcCpuUsage() { if (vgcPID == 0) return 0.0; HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, vgcPID); if (!hProcess) return 0.0; FILETIME ftCreation, ftExit, ftKernel, ftUser; if (!GetProcessTimes(hProcess, &ftCreation, &ftExit, &ftKernel, &ftUser)) { CloseHandle(hProcess); return 0.0; } ULARGE_INTEGER kernel, user; kernel.LowPart = ftKernel.dwLowDateTime; kernel.HighPart = ftKernel.dwHighDateTime; user.LowPart = ftUser.dwLowDateTime; user.HighPart = ftUser.dwHighDateTime; ULONGLONG currentTime = kernel.QuadPart + user.QuadPart; double cpuUsage = 0.0; if (vgcCpuInfo.lastKernelTime != 0) { ULONGLONG timeDiff = currentTime - (vgcCpuInfo.lastKernelTime + vgcCpuInfo.lastUserTime); if (timeDiff > 0) { cpuUsage = (double)timeDiff / 100000.0; } } vgcCpuInfo.lastKernelTime = kernel.QuadPart; vgcCpuInfo.lastUserTime = user.QuadPart; CloseHandle(hProcess); return cpuUsage; } void VgcThreadleriniAskiyaAl() { if (vgcPID == 0) { vgcPID = ProsesBul(L"vgc.exe"); if (vgcPID == 0) return; } HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0); if (hSnapshot == INVALID_HANDLE_VALUE) return; THREADENTRY32 te; te.dwSize = sizeof(THREADENTRY32); std::vector<DWORD> yeniThreadler; if (Thread32First(hSnapshot, &te)) { do { if (te.th32OwnerProcessID == vgcPID) { bool zatenVar = false; for (DWORD tid : askiyaAlinanThreadler) { if (tid == te.th32ThreadID) { zatenVar = true; break; } } if (!zatenVar) { HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, te.th32ThreadID); if (hThread) { SuspendThread(hThread); yeniThreadler.push_back(te.th32ThreadID); CloseHandle(hThread); } } } } while (Thread32Next(hSnapshot, &te)); } CloseHandle(hSnapshot); if (!yeniThreadler.empty()) { askiyaAlinanThreadler.insert(askiyaAlinanThreadler.end(), yeniThreadler.begin(), yeniThreadler.end()); } } void VgcThreadleriniDevamEttir() { for (DWORD threadID : askiyaAlinanThreadler) { HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME | THREAD_SET_INFORMATION, FALSE, threadID); if (hThread) { SetThreadPriority(hThread, THREAD_PRIORITY_NORMAL); ResumeThread(hThread); CloseHandle(hThread); } } askiyaAlinanThreadler.clear(); if (vgcPID != 0) { HANDLE hVgc = OpenProcess(PROCESS_SET_INFORMATION | PROCESS_QUERY_INFORMATION, FALSE, vgcPID); if (hVgc) { SetPriorityClass(hVgc, NORMAL_PRIORITY_CLASS); DWORD_PTR processAffinityMask; DWORD_PTR systemAffinityMask; if (GetProcessAffinityMask(hVgc, &processAffinityMask, &systemAffinityMask)) { SetProcessAffinityMask(hVgc, systemAffinityMask); } SIZE_T minWorkingSet = -1; SIZE_T maxWorkingSet = -1; SetProcessWorkingSetSize(hVgc, minWorkingSet, maxWorkingSet); CloseHandle(hVgc); } } } static DWORD WINAPI PopupBypassThread(LPVOID lpParam) { PopupBypass* self = (PopupBypass*)lpParam; self->PopupBypassRutini(); return 0; } void PopupBypassRutini() { system("cls"); PrintASCIIArt(); std::wcout << L"\n"; std::wcout << L"1. Popup Bypass\n"; std::wcout << L"2. Safe Exit\n"; std::wcout << L"3. STOP BYPASS\n\n"; std::wcout << L"Enter your choice : \n\n"; PrintColoredText(L"[*] Bypass started.\n", true); PrintColoredText(L"[*] Please open the game…\n", true); while (ProsesBul(L"VALORANT-Win64-Shipping.exe") == 0) { if (!bypassAktif) return; Sleep(500); } PrintColoredText(L"[+] Game detected!\n", true); PrintColoredText(L"[*] Waiting 8 seconds…\n", true); for (int i = 0; i < 80 && bypassAktif; i++) { Sleep(100); } if (!bypassAktif) return; vgcPID = ProsesBul(L"vgc.exe"); if (vgcPID == 0) { PrintColoredText(L"[*] Waiting for VGC..\n", true); for (int i = 0; i < 10 && vgcPID == 0 && bypassAktif; i++) { Sleep(1000); vgcPID = ProsesBul(L"vgc.exe"); } } if (!bypassAktif || vgcPID == 0) { PrintColoredText(L"[-] VGC not found!\n", true); return; } vgcCpuInfo.lastKernelTime = 0; vgcCpuInfo.lastUserTime = 0; PrintColoredText(L"[*] VGC CPU usage is being monitored…\n", true); bool cpuSpikeDetected = false; while (!cpuSpikeDetected && bypassAktif) { double cpu = GetVgcCpuUsage(); if (cpu >= 0.1) { cpuSpikeDetected = true; PrintColoredText(L"[+] CPU spike detected! Applying DNS freeze…\n", true); break; } Sleep(10); } if (!bypassAktif) return; if (!cpuSpikeDetected) { PrintColoredText(L"[-] CPU spike tespit edilemedi!\n", true); return; } if (DnsCacheFreeze()) { PrintColoredText(L"[+]DNS freeze applied!\n", true); } else { PrintColoredText(L"[-] DNS freeze failed!\n", true); return; } PrintColoredText(L"[+] Bypass active! (press F8 to terminate)\n\n", true); std::wcout << L" Press any key to continue…\n\n"; } void SafeExitIslemleri() { system("cls"); PrintASCIIArt(); std::wcout << L"\n"; std::wcout << L"1. Popup Bypass\n"; std::wcout << L"2. Safe Exit\n"; std::wcout << L"3. Cikis\n\n"; std::wcout << L"Seciminiz: 2\n\n"; PrintColoredText(L"[*] Closing Valorant…\n", true); ValorantKapat(); Sleep(2000); PrintColoredText(L"[*] Stopping bypass…\n", true); bypassAktif = false; Sleep(500); PrintColoredText(L"[*] Performing DNS unfreeze…\n", true); DnsCacheUnfreeze(); ServisDurdur(L"Dnscache"); Sleep(1000); ServisBaslat(L"Dnscache"); Sleep(1000); dnsFreezeYapildi = false; vgcPID = 0; svchostPID = 0; dnsCacheThreadler.clear(); PrintColoredText(L"[+] Safe exit completed!\n\n", true); std::wcout << L"[*] Safe exit completed! \n\n"; } void F8Unfreeze() { PrintColoredText(L"\n[*] F8 pressed – Performing unfreeze…\n", true); DnsCacheUnfreeze(); PrintColoredText(L"[+] Unfreeze completed!\n", true); } public: PopupBypass() : hDnsCacheProcess(NULL), vgcPID(0), svchostPID(0), bypassAktif(false), dnsFreezeYapildi(false) { vgcCpuInfo.pid = 0; vgcCpuInfo.lastKernelTime = 0; vgcCpuInfo.lastUserTime = 0; } ~PopupBypass() { bypassAktif = false; if (hDnsCacheProcess) { CloseHandle(hDnsCacheProcess); } } void BypassBaslat() { if (bypassAktif) { PrintColoredText(L"[-] Bypass is already active!\n", true); return; } HataAyiklamaHaklariniEtkinlestir(); bypassAktif = true; CreateThread(NULL, 0, PopupBypassThread, this, 0, NULL); Sleep(100); } void SafeExit() { SafeExitIslemleri(); } void Unfreeze() { F8Unfreeze(); } bool IsBypassActive() const { return bypassAktif; } }; HANDLE g_hBypass = NULL; PopupBypass* g_bypass = NULL; void SetConsoleColor(int r, int g, int b) { std::wcout << L"\033[38;2;" << r << L";" << g << L";" << b << L"m"; } void ResetConsoleColor() { std::wcout << L"\033[0m"; } void PrintColoredText(const std::wstring& text, bool animated = false) { if (animated) { static int hue = 0; hue = (hue + 30) % 360; double h = hue; double s = 1.0; double v = 1.0; double c = v * s; double x = c * (1 - abs(fmod(h / 60.0, 2) - 1)); double m = v - c; int r, g, b; if (h < 60) { r = (int)((c + m) * 255); g = (int)((x + m) * 255); b = (int)(m * 255); } else if (h < 120) { r = (int)((x + m) * 255); g = (int)((c + m) * 255); b = (int)(m * 255); } else if (h < 180) { r = (int)(m * 255); g = (int)((c + m) * 255); b = (int)((x + m) * 255); } else if (h < 240) { r = (int)(m * 255); g = (int)((x + m) * 255); b = (int)((c + m) * 255); } else if (h < 300) { r = (int)((x + m) * 255); g = (int)(m * 255); b = (int)((c + m) * 255); } else { r = (int)((c + m) * 255); g = (int)(m * 255); b = (int)((x + m) * 255); } SetConsoleColor(r, g, b); std::wcout << text; ResetConsoleColor(); } else { std::wcout << text; } } void PrintASCIIArt() { SetConsoleColor(255, 0, 0); std::wcout << L"\n"; std::wcout << L" ░██ ░██ ░███ ░██ ░██████████ ░██ ░██ \n"; std::wcout << L" ░██ ░██ ░██░██ ░██ ░██ ░██ ░██ \n"; std::wcout << L" ░██ ░██ ░██ ░██ ░██ ░██ ░██░██ \n"; std::wcout << L" ░██ ░██ ░█████████ ░██ ░█████████ ░███ \n"; std::wcout << L" ░██ ░██ ░██ ░██ ░██ ░██ ░██░██ \n"; std::wcout << L" ░██░██ ░██ ░██ ░██ ░██ ░██ ░██ \n"; std::wcout << L" ░███ ░██ ░██ ░██████████ ░██████████ ░██ ░██ \n"; '\n'; '\n'; wcout << L"===============================================================================================================================\n"; std::wcout << L"\n"; ResetConsoleColor(); } DWORD WINAPI HotkeyThread(LPVOID lpParam) { bool f8Pressed = false; while (true) { if (GetAsyncKeyState(VK_F8) & 0x8000) { if (!f8Pressed) { f8Pressed = true; if (g_bypass) { g_bypass->Unfreeze(); } } } else { f8Pressed = false; } Sleep(100); } return 0; } DWORD WINAPI WindowSizeMonitor(LPVOID lpParam) { HWND hwnd = GetConsoleWindow(); if (!hwnd) return 0; RECT targetRect; GetWindowRect(hwnd, &targetRect); int targetWidth = targetRect.right - targetRect.left; int targetHeight = targetRect.bottom - targetRect.top; while (true) { RECT currentRect; GetWindowRect(hwnd, &currentRect); int currentWidth = currentRect.right - currentRect.left; int currentHeight = currentRect.bottom - currentRect.top; if (currentWidth != targetWidth || currentHeight != targetHeight) { MoveWindow(hwnd, currentRect.left, currentRect.top, targetWidth, targetHeight, TRUE); } Sleep(100); } return 0; } int main() { HWND hwnd = GetConsoleWindow(); if (hwnd) { LONG_PTR style = GetWindowLongPtr(hwnd, GWL_STYLE); style &= ~WS_THICKFRAME; style &= ~WS_MAXIMIZEBOX; SetWindowLongPtr(hwnd, GWL_STYLE, style); RECT rect; GetWindowRect(hwnd, &rect); int width = 1250; int height = 300; MoveWindow(hwnd, rect.left, rect.top, width, height, TRUE); HMENU hMenu = GetSystemMenu(hwnd, FALSE); if (hMenu) { EnableMenuItem(hMenu, SC_SIZE, MF_BYCOMMAND | MF_GRAYED); EnableMenuItem(hMenu, SC_MAXIMIZE, MF_BYCOMMAND | MF_GRAYED); } } HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(hOut, &csbi); COORD bufferSize; bufferSize.X = 100; bufferSize.Y = 50; SetConsoleScreenBufferSize(hOut, bufferSize); SMALL_RECT windowSize; windowSize.Left = 0; windowSize.Top = 0; windowSize.Right = 125; windowSize.Bottom = 30; SetConsoleWindowInfo(hOut, TRUE, &windowSize); DWORD dwMode = 0; GetConsoleMode(hOut, &dwMode); dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING; SetConsoleMode(hOut, dwMode); _setmode(_fileno(stdout), _O_U16TEXT); _setmode(_fileno(stdin), _O_U16TEXT); PopupBypass bypass; g_bypass = &bypass; CreateThread(NULL, 0, HotkeyThread, NULL, 0, NULL); CreateThread(NULL, 0, WindowSizeMonitor, NULL, 0, NULL); int secim = 0; CHECK_ADMIN(); while (true) { system("cls"); PrintASCIIArt(); std::wcout << L"\n"; std::wcout << L"1. Popup Bypass\n"; std::wcout << L"2. Safe Exit\n"; std::wcout << L"3. STOP BYPASS\n\n"; std::wcout << L"Enter your choice : "; std::wcin >> secim; if (secim == 1) { bypass.BypassBaslat(); _getch(); } else if (secim == 2) { bypass.SafeExit(); std::wcout << L"Press any key to continue..." << std::endl; _getch(); } else if (secim == 3) { bypass.SafeExit(); break; } else { std::wcout << L"\n[-] Invalid choice!" << std::endl; Sleep(1000); } } return 0; }

Hello, link updated. Try download now.

What it has: - A win32 window with DirectX11 and ImGui implemented - Topmost (renders above everything even above task manager with "always on top" enabled) - Ready for use (for an external cheat for example) What you need: - CMake to compile the source (or you could copy the files to VS and use it there) - DirectX11 - Run the overlay as administrator Also this was written in C23 if you use something like C99 you probably would have to do some minor changes. Rar Pass: crackfrm link.txt

Good sale mate.

Thanks for share mate!

It's an Offset Dumper for Valorant. link.txt

link.txt

Features: Enemy outline. Enemy skeleton. Ultimate charge display. Trigger bot. Flick bot. (in progress) Tracking bot. (planned) link.txt

Eline sağlık çiçeğim

Rica gençler

By completing the database and file installations, you can start using the keyauth enterprise version under your own management. Keyauth Enterprise version supports 1.0 - 1.1 - 1.2 APIs. link.txt