packet injecting source v.137.2

Roogix demiş ki:Packet.h:

Kod:

#include <Windows.h>
#include <vector>
#include <cassert>
#include <random>
#include <boost/tokenizer.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/smart_ptr.hpp>

#pragma pack(push, 1)

struct COutPacket
{
    BOOL fLoopback;
    PVOID pData;
    DWORD dwSize;
    UINT uOffset;
    BOOL fEncryptedByRoogix;
};

struct CInPacket
{
    BOOL fLoopback;
    int iState;
    PVOID pData;
    DWORD dwTotalLength;
    DWORD dwUnknown;
    DWORD dwValidLength;
    UINT uOffset;
};

#pragma pack(pop)

void ParsePacket(std::string &strPacket, std::vector<BYTE> &vData);

bool SendPacket(std::string &strPacket, std::string &strError);
bool SendPacket(std::vector<BYTE> vData);

bool RecvPacket(std::string &strPacket, std::string &strError);
bool RecvPacket(std::vector<BYTE> vData);

void InjectPacket(COutPacket *pPacket);
void InjectPacket(CInPacket *pPacket);

Packet.cpp:

Kod:

#include "Packet.h"

typedef void (__fastcall *pfnSendPacket)(PVOID pCClientSocket, PVOID pEDX, COutPacket *pPacket);
typedef void (__fastcall *pfnRecvPacket)(PVOID pCClientSocket, PVOID pEDX, CInPacket *pPacket);

typedef void (__fastcall *pfnFreePacket)(PVOID pPacket);
typedef DWORD (__fastcall *pfnDecryptData)(PVOID pData);


const PVOID *ppCClientSocket = reinterpret_cast<const PVOID*>(0x0169734C);

const pfnFreePacket FreePacket = reinterpret_cast<pfnFreePacket>(0x0043C820);

static const pfnSendPacket MSSendPacket = reinterpret_cast<pfnSendPacket>(0x0051AD20);
static const PVOID pReturnAddress = reinterpret_cast<const PVOID>(0x0040C398);

static const pfnDecryptData DecryptData = reinterpret_cast<pfnDecryptData>(0x0049EE00);
static const PVOID pLastThreadId = reinterpret_cast<const PVOID>(0x0169C848); 

static const pfnRecvPacket MSRecvPacket = reinterpret_cast<pfnRecvPacket>(0x0051C0B0);

template <typename T>
struct HexTo
{
    T value;

    operator T() const
    {
        return value;
    }

    friend std::istream& operator>>(std::istream &in, HexTo &out)
    {
        in >> std::hex >> out.value;
        return in;
    }
};

void ParsePacket(std::string &strPacket, std::vector<BYTE> &vData)
{
    typedef boost::tokenizer<boost::char_separator<char>> Tokenizer;

    vData.clear();

    boost::trim(strPacket);

    static std::tr1::uniform_int<BYTE> gen(0, 15);
    static std::tr1::mt19937 engine;

    static const char szDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

    for (std::size_t index = 0; index < strPacket.length(); ++index)
    {
        if (strPacket[index] == '*')
        {
            strPacket[index] = szDigits[gen(engine)];
        }
    }

    Tokenizer Tokens(strPacket);

    for (Tokenizer::const_iterator iterate = Tokens.begin(), end = Tokens.end(); iterate != end; ++iterate)
    {
        vData.push_back(static_cast<BYTE>(boost::lexical_cast<HexTo<UINT>>(*iterate)));
    }
}

bool SendPacket(std::string &strPacket, std::string &strError)
{
    strError.clear();
    boost::trim(strPacket);

    if (strPacket.empty())
    {
        strError = "Please enter a packet.";
        return false;
    }
    std::vector<BYTE> vData;
    try
    {
        ParsePacket(strPacket, vData);
    }
    catch (std::exception &exc)
    {
        strError = exc.what();
        return false;
    }
    catch (...)
    {
        strError = "[SEND] Unknown error!";
        return false;
    }

    COutPacket *pPacket = new COutPacket();
    SecureZeroMemory(pPacket, sizeof(COutPacket));
    pPacket->dwSize = vData.size();
    pPacket->pData = vData.data();

    try
    {
        InjectPacket(pPacket);
    }
    catch (...)
    {
        strError = "[SEND] Internal error!";
        return false;
    }
    return true;
}

bool SendPacket(std::vector<BYTE> vData)
{
    COutPacket *pPacket = new COutPacket();
    SecureZeroMemory(pPacket, sizeof(COutPacket));
    
    pPacket->dwSize = vData.size();
    pPacket->pData = vData.data();

    try
    {
        InjectPacket(pPacket);
    }
    catch (...)
    {
        return false;
    }
    return true;
}

bool RecvPacket(std::string &strPacket, std::string &strError)
{
    strError.clear();
    boost::trim(strPacket);

    if (strPacket.empty())
    {
        strError = "Please enter a packet.";
        return false;
    }
    std::vector<BYTE> vData;
    try
    {
        ParsePacket(strPacket, vData);
    }
    catch (std::exception &exc)
    {
        strError = exc.what();
        return false;
    }
    catch (...)
    {
        strError = "[RECV] Unknown error!";
        return false;
    }

    static std::tr1::uniform_int<DWORD> gen;
    static std::tr1::mt19937 engine;

    DWORD dwHeader = gen(engine);

    for (int i = 0; i < sizeof(DWORD); ++i)
    {
        vData.insert(vData.begin(), static_cast<BYTE>(dwHeader >> (i * 8)));
    }

    CInPacket *pPacket = new CInPacket();
    pPacket->fLoopback = 0;
    pPacket->iState = 2;
    pPacket->pData = vData.data();
    pPacket->dwTotalLength = vData.size();
    pPacket->dwUnknown = 0;
    pPacket->dwValidLength = pPacket->dwValidLength - 4;
    pPacket->uOffset = 4;

    try
    {
        InjectPacket(pPacket);
    }
    catch (...)
    {
        strError = "[RECV] Internal error!";
        return false;
    }
    return true;
} 

bool RecvPacket(std::vector<BYTE> vData)
{
    static std::tr1::uniform_int<DWORD> gen;
    static std::tr1::mt19937 engine;

    DWORD dwHeader = gen(engine);

    for (int i = 0; i < sizeof(DWORD); ++i)
    {
        vData.insert(vData.begin(), static_cast<BYTE>(dwHeader >> (i * 8)));
    }

    CInPacket *pPacket = new CInPacket();
    pPacket->fLoopback = 0;
    pPacket->iState = 2;
    pPacket->pData = vData.data();
    pPacket->dwTotalLength = vData.size();
    pPacket->dwUnknown = 0;
    pPacket->dwValidLength = pPacket->dwValidLength - 4;
    pPacket->uOffset = 4;

    try
    {
        InjectPacket(pPacket);
    }
    catch (...)
    {
        return false;
    }
    return true;
}

void InjectPacket(COutPacket *pPacket)
{
    __writefsdword(0x06B8, DecryptData(pLastThreadId));
    __asm
    {
        push Next
        push ecx
        mov ecx, dword ptr [ppCClientSocket]
        mov ecx, dword ptr [ecx]
        push dword ptr [pPacket]
        push dword ptr [pReturnAddress]
        jmp dword ptr [MSSendPacket]
        Next:
    }
    FreePacket(reinterpret_cast<PVOID>(pPacket));
}

void InjectPacket(CInPacket *pPacket)
{
    {
        MSRecvPacket(*ppCClientSocket, NULL, pPacket);
    }
    FreePacket(reinterpret_cast<PVOID>(pPacket));
}