vgc bypass

ezcerez' Alıntı:

yokmudur bilen eden

Genişletmek için tıkla ...

ezcerez' Alıntı:

su forumda da olan mac basında oyunu kapatıp calıstırılan tek maclık vgc bypass source kodunu nerden bulabılırım bılen varsa atabılırmı

Genişletmek için tıkla ...

Swezyy' Alıntı:

bir saniye hocam göndereyim


#include <windows.h>
#include <winbase.h>
#include <winuser.h>
#include <string>
#include <thread>
#include <atomic>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <psapi.h>
#pragma comment(lib, "psapi.lib")
#include <TlHelp32.h>

#define NOMINMAX

std::atomic_bool shutdown_event(false);
std::mutex log_mutex;

void log_message(const std::wstring& message) {
std::lock_guard<std::mutex> lock(log_mutex);
std::wcout << message << std::endl;
}

void adjust_privileges() {
HANDLE hToken;
TOKEN_PRIVILEGES tp;

try {
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {
throw std::runtime_error("Failed to open process token.");
}

LUID luid;
if (!LookupPrivilegeValueW(nullptr, L"SeDebugPrivilege", &luid)) {
throw std::runtime_error("Failed to look up privilege value.");
}

tp.PrivilegeCount = 1;
tp.Privileges[0].Luid = luid;
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

if (!AdjustTokenPrivileges(hToken, FALSE, &tp, 0, nullptr, nullptr)) {
throw std::runtime_error("Failed to adjust token privileges.");
}

log_message(L"Privileges adjusted successfully.");
CloseHandle(hToken);
}
catch (const std::exception& e) {
std::wstring error_message = L"Failed to adjust privileges: " +
std::wstring(e.what(), e.what() + strlen(e.what()));
log_message(error_message);
if (hToken != INVALID_HANDLE_VALUE) CloseHandle(hToken);
}
}

void handle_client(HANDLE pipe) {
DWORD bytesRead;
char buffer[4096];

try {
while (!shutdown_event.load()) {
DWORD bytesAvailable = 0;
if (!PeekNamedPipe(pipe, nullptr, 0, nullptr, &bytesAvailable, nullptr)) {
throw std::runtime_error("Failed to peek pipe");
}

if (bytesAvailable > 0) {
BOOL result = ReadFile(pipe, buffer, sizeof(buffer), &bytesRead, nullptr);
if (result && bytesRead > 0) {
std::wstring data;
int len = MultiByteToWideChar(CP_UTF8, 0, buffer, bytesRead, nullptr, 0);
if (len > 0) {
data.resize(len);
MultiByteToWideChar(CP_UTF8, 0, buffer, bytesRead, &data[0], len);
}

log_message(L"Received data: " + data);
WriteFile(pipe, buffer, bytesRead, &bytesRead, nullptr);
log_message(L"Sent data back: " + data);
}
}
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
catch (const std::exception& e) {
log_message(L"Communication error: " +
std::wstring(e.what(), e.what() + strlen(e.what())));
}

CloseHandle(pipe);
log_message(L"Pipe connection closed.");
}

void create_named_pipe(const std::wstring& pipe_name) {
std::wstring pipe_path = L"\\\\.\\pipe\\" + pipe_name;

try {
while (!shutdown_event.load()) {
HANDLE pipe = CreateNamedPipeW(
pipe_path.c_str(),
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_MESSAGE | PIPE_WAIT,
PIPE_UNLIMITED_INSTANCES,
104857600,
104857600,
500,
nullptr
);

if (pipe == INVALID_HANDLE_VALUE) {
throw std::runtime_error("Failed to create pipe.");
}

log_message(L"Pipe created. Waiting for connections...");
BOOL connected = ConnectNamedPipe(pipe, nullptr);
if (connected) {
log_message(L"Client connected. Assigning to thread pool.");
std::thread(handle_client, pipe).detach();
}
else {
CloseHandle(pipe);
log_message(L"Error connecting to pipe.");
}
}
}
catch (const std::exception& e) {
std::wstring error_message = L"Pipe creation error: " +
std::wstring(e.what(), e.what() + strlen(e.what()));
log_message(error_message);
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}

void override_vgc_pipe(const std::wstring& pipe_name) {
std::wstring pipe_path = L"\\\\.\\pipe\\" + pipe_name;

try {
HANDLE pipeHandle = CreateFileW(
pipe_path.c_str(),
GENERIC_READ | GENERIC_WRITE,
0,
nullptr,
OPEN_EXISTING,
0,
nullptr
);

if (pipeHandle == INVALID_HANDLE_VALUE) {
throw std::runtime_error("Failed to connect to original pipe.");
}

log_message(L"Connected to the original vgc.exe pipe at " + pipe_path);
CloseHandle(pipeHandle);
log_message(L"Original vgc.exe pipe closed and replaced by emulated pipe.");

create_named_pipe(pipe_name);
}
catch (const std::exception& e) {
std::wstring error_message = L"Error connecting to the original pipe: " +
std::wstring(e.what(), e.what() + strlen(e.what()));
log_message(error_message);
}
}

void start_vgc_service() {
SC_HANDLE scManager = OpenSCManagerW(nullptr, nullptr, SC_MANAGER_CONNECT);
if (scManager == nullptr) {
log_message(L"Failed to open Service Control Manager.");
return;
}

SC_HANDLE vgcService = OpenServiceW(scManager, L"vgc", SERVICE_START);
if (vgcService == nullptr) {
log_message(L"Failed to open vgc service.");
CloseServiceHandle(scManager);
return;
}

if (StartServiceW(vgcService, 0, nullptr)) {
log_message(L"Successfully started the vgc service.");
}
else {
log_message(L"Failed to start vgc service.");
}

CloseServiceHandle(vgcService);
CloseServiceHandle(scManager);
}

int main() {
std::wstring pipe_name = L"933823D3-C77B-4BAE-89D7-A92B567236BC";

system("sc stop vgk");
system("sc stop vgc");
Sleep(200);
system("sc start vgk");
system("sc start vgc");
system("cls");
Sleep(500);

adjust_privileges();
override_vgc_pipe(pipe_name);

// Keep main thread alive
while (!shutdown_event.load()) {
std::this_thread::sleep_for(std::chrono::seconds(1));
}

return 0;
}

Genişletmek için tıkla ...