Manuel Map İnjectör Source

Charismax

Copyright @ Charismax
Katılım
3 yıl 7 ay 8 gün
Mesajlar
25,232
Tepkime puanı
8,697
Yaş
35
Konum
Memed' Home
İsim
CHRS
Memleket
Neresi?
Meslek
IzdırapÇI
Cinsiyet
vtEvVy
Medeni Hal
C++:
#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>
#include <string>
#include <string.h>
#include <tchar.h>
#include <urlmon.h>
#include <tchar.h>


#pragma comment(lib, "urlmon.lib")
#pragma comment(lib,"wininet.lib")

using namespace std;
  





typedef HMODULE(__stdcall* pLoadLibraryA)(LPCSTR);
typedef FARPROC(__stdcall* pGetProcAddress)(HMODULE, LPCSTR);

typedef INT(__stdcall* dllmain)(HMODULE, DWORD, LPVOID);


struct loaderdata
{
    LPVOID ImageBase;

    PIMAGE_NT_HEADERS NtHeaders;
    PIMAGE_BASE_RELOCATION BaseReloc;
    PIMAGE_IMPORT_DESCRIPTOR ImportDirectory;

    pLoadLibraryA fnLoadLibraryA;
    pGetProcAddress fnGetProcAddress;

};

DWORD FindProcessId(string processName)
{
    PROCESSENTRY32 processInfo;
    processInfo.dwSize = sizeof(processInfo);

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

    Process32First(processSnapshot, &processInfo);
    if (!processName.compare(processInfo.szExeFile))
    {
        CloseHandle(processSnapshot);
        return processInfo.th32ProcessID;
    }

    while (Process32Next(processSnapshot, &processInfo))
    {
        if (!processName.compare(processInfo.szExeFile))
        {
            CloseHandle(processSnapshot);
            return processInfo.th32ProcessID;
        }
    }

    CloseHandle(processSnapshot);
    return 0;
}

DWORD __stdcall LibraryLoader(LPVOID Memory)
{

    loaderdata* LoaderParams = (loaderdata*)Memory;

    PIMAGE_BASE_RELOCATION pIBR = LoaderParams->BaseReloc;

    DWORD delta = (DWORD)((LPBYTE)LoaderParams->ImageBase - LoaderParams->NtHeaders->OptionalHeader.ImageBase);

    while (pIBR->VirtualAddress)
    {
        if (pIBR->SizeOfBlock >= sizeof(IMAGE_BASE_RELOCATION))
        {
            int count = (pIBR->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
            PWORD list = (PWORD)(pIBR + 1);

            for (int i = 0; i < count; i++)
            {
                if (list[i])
                {
                    PDWORD ptr = (PDWORD)((LPBYTE)LoaderParams->ImageBase + (pIBR->VirtualAddress + (list[i] & 0xFFF)));
                    *ptr += delta;
                }
            }
        }

        pIBR = (PIMAGE_BASE_RELOCATION)((LPBYTE)pIBR + pIBR->SizeOfBlock);
    }

    PIMAGE_IMPORT_DESCRIPTOR pIID = LoaderParams->ImportDirectory;

    while (pIID->Characteristics)
    {
        PIMAGE_THUNK_DATA OrigFirstThunk = (PIMAGE_THUNK_DATA)((LPBYTE)LoaderParams->ImageBase + pIID->OriginalFirstThunk);
        PIMAGE_THUNK_DATA FirstThunk = (PIMAGE_THUNK_DATA)((LPBYTE)LoaderParams->ImageBase + pIID->FirstThunk);

        HMODULE hModule = LoaderParams->fnLoadLibraryA((LPCSTR)LoaderParams->ImageBase + pIID->Name);

        if (!hModule)
            return FALSE;

        while (OrigFirstThunk->u1.AddressOfData)
        {
            if (OrigFirstThunk->u1.Ordinal & IMAGE_ORDINAL_FLAG)
            {
              
                DWORD Function = (DWORD)LoaderParams->fnGetProcAddress(hModule,
                    (LPCSTR)(OrigFirstThunk->u1.Ordinal & 0xFFFF));

                if (!Function)
                    return FALSE;

                FirstThunk->u1.Function = Function;
            }
            else
            {
              
                PIMAGE_IMPORT_BY_NAME pIBN = (PIMAGE_IMPORT_BY_NAME)((LPBYTE)LoaderParams->ImageBase + OrigFirstThunk->u1.AddressOfData);
                DWORD Function = (DWORD)LoaderParams->fnGetProcAddress(hModule, (LPCSTR)pIBN->Name);
                if (!Function)
                    return FALSE;

                FirstThunk->u1.Function = Function;
            }
            OrigFirstThunk++;
            FirstThunk++;
        }
        pIID++;
    }

    if (LoaderParams->NtHeaders->OptionalHeader.AddressOfEntryPoint)
    {
        dllmain EntryPoint = (dllmain)((LPBYTE)LoaderParams->ImageBase + LoaderParams->NtHeaders->OptionalHeader.AddressOfEntryPoint);

        return EntryPoint((HMODULE)LoaderParams->ImageBase, DLL_PROCESS_ATTACH, NULL);
    }
    return TRUE;
}


DWORD __stdcall stub()
{
    return 0;
}



int main()
{


  
  
    SetConsoleTitle(_T("[+] [Hackin Guide İnjectör]"));//Konsol Adı.
    system("color 2");//Renk Seçimi.
    cout << "[+] [Developed:SelexBy]\n";
    Sleep(500)//Bekleme Süresi


    MessageBox(NULL, "Lobide Tamama Basın!", "Bilgi!!", MB_OK);//MessageBox Bunu Kaldırabilirsiniz Oyun Bekleniyor Yapamadığımdan Dolayı Böyle Bir Şey Yaptım.
  

    string dwnld_URL = "Link";//DLL indiriyorum
    string savepath = "C:\\Temp\\hile.dll";//Buraya Kaydediyorum
    URLDownloadToFile(NULL, dwnld_URL.c_str(), savepath.c_str(), 0, NULL);

    LPCSTR Dll = "C:\\Temp\\hile.dll";//Dll İndirdiğim Yerin Konumunu Veriyorum.

  

    DWORD ProcessId = FindProcessId("csgo.exe");//Hangi Prgorama İnjectlenicekse Onu Yazıyorum.

    loaderdata LoaderParams;

    HANDLE hFile = CreateFileA(Dll, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
        OPEN_EXISTING, 0, NULL);

    DWORD FileSize = GetFileSize(hFile, NULL);
    PVOID FileBuffer = VirtualAlloc(NULL, FileSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);

    ReadFile(hFile, FileBuffer, FileSize, NULL, NULL);


    PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)FileBuffer;
  
    PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)((LPBYTE)FileBuffer + pDosHeader->e_lfanew);


    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessId);
  
    PVOID ExecutableImage = VirtualAllocEx(hProcess, NULL, pNtHeaders->OptionalHeader.SizeOfImage,
        MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);

  
    WriteProcessMemory(hProcess, ExecutableImage, FileBuffer,
        pNtHeaders->OptionalHeader.SizeOfHeaders, NULL);

  
    PIMAGE_SECTION_HEADER pSectHeader = (PIMAGE_SECTION_HEADER)(pNtHeaders + 1);

    for (int i = 0; i < pNtHeaders->FileHeader.NumberOfSections; i++)
    {
        WriteProcessMemory(hProcess, (PVOID)((LPBYTE)ExecutableImage + pSectHeader[i].VirtualAddress),
            (PVOID)((LPBYTE)FileBuffer + pSectHeader[i].PointerToRawData), pSectHeader[i].SizeOfRawData, NULL);
    }

    PVOID LoaderMemory = VirtualAllocEx(hProcess, NULL, 4096, MEM_COMMIT | MEM_RESERVE,
        PAGE_EXECUTE_READWRITE);

    LoaderParams.ImageBase = ExecutableImage;
    LoaderParams.NtHeaders = (PIMAGE_NT_HEADERS)((LPBYTE)ExecutableImage + pDosHeader->e_lfanew);

    LoaderParams.BaseReloc = (PIMAGE_BASE_RELOCATION)((LPBYTE)ExecutableImage
        + pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
    LoaderParams.ImportDirectory = (PIMAGE_IMPORT_DESCRIPTOR)((LPBYTE)ExecutableImage
        + pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);

    LoaderParams.fnLoadLibraryA = LoadLibraryA;
    LoaderParams.fnGetProcAddress = GetProcAddress;
  
    WriteProcessMemory(hProcess, LoaderMemory, &LoaderParams, sizeof(loaderdata),        NULL);
  
    WriteProcessMemory(hProcess, (PVOID)((loaderdata*)LoaderMemory + 1), LibraryLoader,
        (DWORD)stub - (DWORD)LibraryLoader, NULL);
  
    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)((loaderdata*)LoaderMemory + 1),
        LoaderMemory, 0, NULL);
    system("color 1");
    cout << "[+] [Inject Basarili]";
    Beep(700, 600);//Beep Sesi Veriyorum.
    std::cout << "";
    Sleep(2000);
    system("cls");//Konsolu Temizliyorum.
    system("color 6");
    std::cout << "[+] [Developed:SelexBy]\n";
    Sleep(500);
    std::cout << "[+] [Hile Aktif Edilmistir Iyi Oyunlar]\n";
    Sleep(3000);
    exit(3);//Çıkış Veriyorum.
  

  


    WaitForSingleObject(hThread, INFINITE);

    std::cin.get();
  
    VirtualFreeEx(hProcess, LoaderMemory, 0, MEM_RELEASE);

    return 0;
}
 
Geri
Üst Alt