OldSchoolHack

Register / Login English

Cheat Engine SigMaker v1.0

  • Category: Tools
  • Developer:
  • Uploaded by: System
  • Uploaded at:
  • System: Windows
Download (150.00 KB)

VirusTotal Result: 0/56

virustotal

Description

How to install:
Download anywhere, open cheat engine -> settings -> plugins -> add new

Notes:
Made for Cheat Engine Version 6.3 x64 bit.
Will only work on x64 bit CE.
Will only work on x32 bit processes.
Disassembler is incomplete and inaccurate.
Signature must be unique.
I forgot to free the malloc but I don't want to bother recompiling


CPP Code:
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <string>
  4. #include <Windows.h>
  5. #include <tlhelp32.h>
  6. #include <vector>
  7. #include <sstream>
  8. #include <iomanip>
  9.  
  10. #include "ADE32.h"
  11. #include "cepluginsdk.h"
  12.  
  13.  
  14. using namespace std;
  15.  
  16.  
  17. DWORD dwTargetAddress;
  18.  
  19. ExportedFunctions Exported;
  20.  
  21.  
  22.  
  23. DWORD FindPattern(DWORD base, DWORD size, char pattern[], char mask[] )
  24. {
  25.    for( DWORD retAddress = base; retAddress < (base + size - strlen(mask)); retAddress++ )
  26.    {
  27.        if( *(BYTE*)retAddress == (pattern[0]&0xff) || mask[0] == '?' )
  28.        {
  29.            DWORD startSearch = retAddress;
  30.            for( int i = 0; mask[i] != '\0' ; i++, startSearch++ )
  31.            {
  32.                if( (pattern[i]&0xff) != *(BYTE*)startSearch && mask[i] != '?')
  33.                    break;
  34.                
  35.                if( ((pattern[i]&0xff) == *(BYTE*)startSearch || mask[i] == '?') && mask[i+1] == '\0' )
  36.                    return retAddress;
  37.            }        
  38.        }
  39.    }
  40.  
  41.    return NULL;
  42. }
  43.  
  44. DWORD GetSizeOfAllocation(HANDLE hProcess, DWORD* pAddress)
  45. {
  46.    DWORD dwSize,
  47.          dwTemp;
  48.    
  49.    MEMORY_BASIC_INFORMATION info;
  50.    
  51.  
  52.    dwSize = 0;
  53.    dwTemp = (DWORD)pAddress;
  54.    ZeroMemory(&info, sizeof(info));
  55.  
  56.    while(true)
  57.    {
  58.        VirtualQueryEx(hProcess, (LPCVOID)dwTemp, &info, sizeof(info));
  59.  
  60.        if((DWORD)info.AllocationBase == (DWORD)pAddress)
  61.        {
  62.            dwSize += info.RegionSize;
  63.            dwTemp += info.RegionSize;
  64.        }
  65.        else
  66.            break;
  67.    }
  68.  
  69.    return dwSize;
  70. }
  71.  
  72. DWORD GetAllocationBase(HANDLE hProcess, DWORD* pAddress)
  73. {
  74.    MEMORY_BASIC_INFORMATION info;
  75.    
  76.  
  77.    ZeroMemory(&info, sizeof(info));
  78.    VirtualQueryEx(hProcess, (LPCVOID)pAddress, &info, sizeof(info));
  79.  
  80.    return (DWORD)info.AllocationBase;
  81. }
  82.  
  83. void ReadProcessMemorySafe(HANDLE hProcess, LPCVOID lpAddress, LPVOID lpBuffer, SIZE_T size)
  84. {
  85.    SIZE_T tempSize,
  86.           bytesRead;
  87.    
  88.    do
  89.    {
  90.        // lazy shitty way to read a module with invalid pages
  91.  
  92.        tempSize = min(size, 0x1000);
  93.  
  94.        ReadProcessMemory(hProcess, lpAddress, lpBuffer, tempSize, &bytesRead);
  95.  
  96.        size -= tempSize;
  97.        lpAddress = (LPCVOID)((DWORD)lpAddress + tempSize);
  98.        lpBuffer = (LPVOID)((DWORD)lpBuffer + tempSize);
  99.  
  100.    }while(size != 0);
  101. }
  102.  
  103. void SetClipboardText(string content)
  104. {
  105.    LPVOID pSpace;
  106.  
  107.    HGLOBAL hMemory;
  108.  
  109.    size_t length;
  110.  
  111.  
  112.    length = content.length() + 1;
  113.  
  114.    hMemory = GlobalAlloc(GMEM_MOVEABLE, length);
  115.  
  116.    if(hMemory != NULL)
  117.    {
  118.        pSpace = GlobalLock(hMemory);
  119.  
  120.        if(pSpace != NULL)
  121.        {
  122.            memcpy(pSpace, content.c_str(), length);
  123.  
  124.            if(OpenClipboard(NULL) != FALSE)
  125.            {
  126.                if(EmptyClipboard() != FALSE)
  127.                {
  128.                    SetClipboardData(CF_TEXT, hMemory);
  129.                    CloseClipboard();
  130.                }
  131.            }
  132.            
  133.            GlobalUnlock(hMemory);
  134.        }
  135.    }
  136. }
  137.    
  138.  
  139.  
  140. BOOL WINAPI SignatureCallback(ULONG *selectedAddress)
  141. {
  142.    // for some reason, the selected address in the popup
  143.    // callback isn't the selected address so its cached here
  144.    dwTargetAddress = (DWORD)selectedAddress;
  145.  
  146.    return TRUE;
  147. }
  148.  
  149. BOOL WINAPI SignaturePopupCallback(ULONG selectedAddress, char **addressofname)
  150. {
  151.    DWORD dwStartAddress,
  152.          dwSectionSize,
  153.          dwAddress,
  154.          dwTest,
  155.          dwCount,
  156.          dwTestOffset,
  157.          dwIndex,
  158.          dwDataSize;
  159.  
  160.    HANDLE hProcess;
  161.    
  162.    stringstream pattern;
  163.  
  164.    BYTE* pTargetMemory;
  165.    
  166.    disasm_struct ins;
  167.        
  168.    vector<BYTE> tempSig;
  169.  
  170.    string tempMask;
  171.  
  172.    int iMethod;
  173.  
  174.  
  175.    if(Exported.OpenedProcessID != NULL && *Exported.OpenedProcessID != NULL)
  176.    {
  177.        // Open the process
  178.        hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, *Exported.OpenedProcessID);
  179.  
  180.        if(hProcess != NULL)
  181.        {
  182.            // Otherwise get the section base and size
  183.            dwStartAddress = GetAllocationBase(hProcess, (DWORD*)dwTargetAddress);
  184.  
  185.            if(dwStartAddress != NULL)
  186.                dwSectionSize = GetSizeOfAllocation(hProcess, (DWORD*)dwStartAddress);
  187.  
  188.            if(dwStartAddress != NULL && dwSectionSize != NULL)
  189.            {
  190.                pTargetMemory = (BYTE*)malloc(dwSectionSize);
  191.  
  192.                if(pTargetMemory != NULL)
  193.                {
  194.                    // Copy the section for local testing
  195.                    ReadProcessMemorySafe(hProcess, (LPCVOID)dwStartAddress, pTargetMemory, dwSectionSize);
  196.                    
  197.                    tempMask = "";
  198.                    dwAddress = dwTargetAddress - dwStartAddress;
  199.  
  200.                    while(true)
  201.                    {
  202.                        if(pTargetMemory + dwAddress < pTargetMemory + dwSectionSize - tempSig.size())
  203.                        {
  204.                            disasm(pTargetMemory + dwAddress, &ins);
  205.  
  206.                            dwDataSize = ins.disasm_datasize;
  207.  
  208.  
  209.                            // guess if unsupported
  210.  
  211.                            if(dwDataSize == 0)
  212.                                dwDataSize = ins.disasm_len - ((ins.disasm_flag & C_MODRM) == C_MODRM ? 2 : 1);
  213.                                
  214.                            if(ins.disasm_len > 0)
  215.                            {
  216.                                for(int i = 0; i < ins.disasm_len; i++)
  217.                                {
  218.                                    if(i < ins.disasm_len - dwDataSize)
  219.                                    {
  220.                                        tempSig.push_back(*(BYTE*)(pTargetMemory + dwAddress + i));
  221.                                        tempMask += "x";
  222.                                    }
  223.                                    else
  224.                                    {
  225.                                        tempSig.push_back(0);
  226.                                        tempMask += "?";
  227.                                    }
  228.                                }
  229.  
  230.                                dwAddress += ins.disasm_len;
  231.                            }
  232.                            else
  233.                            {
  234.                                Exported.ShowMessage("Unable to disassemble instruction.");
  235.                                break;
  236.                            }
  237.  
  238.                                
  239.                            // Test if its unique
  240.  
  241.                            dwCount = 0;
  242.                            dwTest = (DWORD)pTargetMemory - 1;
  243.                            DWORD foo= 0;
  244.  
  245.                            do
  246.                            {
  247.                                foo = dwTest - (DWORD)pTargetMemory;
  248.                                    
  249.                                // what the fuck am I doing here
  250.                                if(dwTest - (DWORD)pTargetMemory < dwSectionSize || foo == 0xFFFFFFFF)
  251.                                {
  252.                                    dwTest = FindPattern(dwTest + 1, dwSectionSize - (dwTest - (DWORD)pTargetMemory), (char*)&tempSig[0], (char*)tempMask.c_str());
  253.  
  254.                                    if(dwTest != NULL)
  255.                                        dwCount++;
  256.                                }
  257.                                else
  258.                                    break;
  259.  
  260.                            }while(dwTest != NULL && dwCount < 2);
  261.  
  262.  
  263.                            // If its unique
  264.  
  265.                            if(dwCount == 1)
  266.                            {
  267.                                // trim excess
  268.  
  269.                                do
  270.                                {
  271.                                    if(tempMask.length() > 0 && tempMask[tempMask.length() - 1] == '?')
  272.                                        tempMask.erase(tempMask.begin() + tempMask.length() - 1);
  273.                                    else
  274.                                        break;
  275.  
  276.                                }while(true);
  277.  
  278.  
  279.                                iMethod = MessageBox(NULL, "Click \"Yes\" for Code Style\r\nClick \"No\" for IDA Style\r\nThe signature is copied to your clipboard", "SEGnosis Sig Maker", MB_YESNOCANCEL | MB_ICONQUESTION | MB_TOPMOST);
  280.  
  281.                                if(iMethod == IDYES)
  282.                                {
  283.                                    for(int i = 0; i < tempMask.length(); i++)
  284.                                        pattern << "\\x" << setfill('0') << setw(2) << hex << (DWORD)tempSig[i];
  285.  
  286.                                    pattern << " " << tempMask;
  287.                                        
  288.                                    SetClipboardText(pattern.str());
  289.                                }
  290.                                else if(iMethod == IDNO)
  291.                                {
  292.                                    for(int i = 0; i < tempMask.length(); i++)
  293.                                    {
  294.                                        if(tempMask[i] == 'x')
  295.                                            pattern << setfill('0') << setw(2) << hex << (DWORD)tempSig[i];
  296.                                        else
  297.                                            pattern << "?";
  298.  
  299.                                        if(i != tempMask.length() - 1)
  300.                                            pattern << " ";
  301.                                    }
  302.                                        
  303.                                    SetClipboardText(pattern.str());
  304.                                }
  305.                                    
  306.                                break;
  307.                            }
  308.                        }
  309.                        else
  310.                        {
  311.                            Exported.ShowMessage("Unable to find a unique signature.");
  312.                            break;
  313.                        }
  314.                    }
  315.                }
  316.                else
  317.                    Exported.ShowMessage("Unable to allocate memory.");
  318.            }
  319.            else
  320.                Exported.ShowMessage("Selected address does not belong to a valid range of memory");
  321.            
  322.            CloseHandle(hProcess);
  323.        }
  324.        else
  325.            Exported.ShowMessage("Unable to open a handle to process.");
  326.    }
  327.    else
  328.        Exported.ShowMessage("No process selected.");
  329.  
  330.    return TRUE;
  331. }
  332.  
  333.  
  334. BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
  335. {
  336.    return TRUE;
  337. }
  338.  
  339.  
  340. #pragma comment(linker, "/EXPORT:CEPlugin_GetVersion=?CEPlugin_GetVersion@@YAHPEAU_PluginVersion@@H@Z")
  341. __declspec(dllexport) BOOL __stdcall CEPlugin_GetVersion(PPluginVersion pv, int sizeofpluginversion)
  342. {
  343.    pv->version = CESDK_VERSION;
  344.    pv->pluginname = "CE SigMaker v1.0 (SDK version 4: 6.0+)";
  345.  
  346.    return TRUE;
  347. }
  348.  
  349. #pragma comment(linker, "/EXPORT:CEPlugin_InitializePlugin=?CEPlugin_InitializePlugin@@YAHPEAU_ExportedFunctions@@H@Z")
  350. __declspec(dllexport) BOOL __stdcall CEPlugin_InitializePlugin(PExportedFunctions ef, int pluginid)
  351. {
  352.    BOOL bResult;
  353.  
  354.    int ContextPluginID;
  355.  
  356.    DISASSEMBLERCONTEXT_INIT init6;
  357.  
  358.  
  359.    Exported = *ef;
  360.    bResult = TRUE;
  361.  
  362.    if(Exported.sizeofExportedFunctions == sizeof(Exported))
  363.    {
  364.        init6.name = "Generate Signature";
  365.        init6.shortcut = NULL;
  366.        init6.shortcut = "Ctrl+Z";
  367.        init6.callbackroutine = SignatureCallback;
  368.        init6.callbackroutineOnPopup = SignaturePopupCallback;
  369.  
  370.        ContextPluginID = Exported.RegisterFunction(pluginid, ptDisassemblerContext, &init6);
  371.  
  372.        if (ContextPluginID != -1)
  373.        {
  374.            // do anything else here
  375.        }
  376.        else
  377.        {
  378.            Exported.ShowMessage("Unable to hook context menu");
  379.            bResult = FALSE;
  380.        }
  381.    }
  382.    else
  383.    {
  384.        Exported.ShowMessage("Version does not match");
  385.        bResult = FALSE;
  386.    }
  387.  
  388.    return bResult;
  389. }
  390.  
  391. #pragma comment(linker, "/EXPORT:CEPlugin_DisablePlugin=?CEPlugin_DisablePlugin@@YAHXZ")
  392. __declspec(dllexport) BOOL __stdcall CEPlugin_DisablePlugin()
  393. {
  394.    return TRUE;
  395. }

http://i.imgur.com/HqQGBmU.gif

Download Cheat Engine SigMaker v1.0
post
was kann dieses tool ?