Temas

[¿Alguien sabe qué Cliente se utiliza para conectarse a un host en la deep web?He utilizado el Filezilla, he probado de todo pero no se me conecta.Si alguien sabe por qué, por favor que me lo diga.]

¿Alguien sabe qué Cliente se utiliza para conectarse  a un host en la deep web?

He utilizado el Filezilla, he probado de todo pero no se me conecta.

Si alguien sabe por qué, por favor que me lo diga.

A ver si alguien me puede echar una mano.
Yo suelo usar muchos hacks/bots/trainers/... para casi todos los juegos. Yo no soy muy entendido para usar programas como el Visual Basic y por eso suelo buscar hackers que simplemente tenga que inyectarlos dandole a "ejecutar" o mediante un inyector y un DLL. También suelo usar el Cheat Engine para cosas muy básicas que a veces ni entiendo cómo lo hago.
Ahora bien, yo suelo sacar estos hackers de una web. El creador parece ser que no ha creado el programa en forma de un trainer  sino simplemente ha dado el código cpp que es este :

Código [Seleccionar] Expandir

#ifndef ENGINE_H
#define ENGINE_H

// Globals
#define CAMERA_MAX_ZOOM 0xB85178
#define CAMERA_CUR_ZOOM 0xB88968

// Classes
#define CLIENT_PTR 0x2EF30D4 // gPTR_Client VMT
#define TARGET_CLASS 0x2EF6C98
#define MATRIX_DATA 0xE3A00C

// Entities
#define OBJECT_ARRAY 0xE3A564
#define OBJECT_LOCAL 0xE39F6C

template<typename Function >
Function CallVirtual(PVOID pBase, DWORD dwIndex)
{
    PDWORD* VTablePointer = (PDWORD*)pBase;
    PDWORD VTableFunctionBase = *VTablePointer;
    DWORD dwAddress = VTableFunctionBase[dwIndex];
   
    return (Function)(dwAddress);
}

template<typename T >
T ReadOffset(PVOID pBase, DWORD dwIndex)
{
    return *(T*)((DWORD)pBase + dwIndex);
}

// Every entity is an object including lights, turrets, minions, champions, etc.
class CObject
{
public:
    INT GetTeam()
    {
        return ReadOffset<BYTE >(this, 0x1C);
    }

    BOOL IsMinion()
    {
        if (((GetFlags() >> 11) & 1) == FALSE)
            return FALSE;

        if (IsBadReadPtr(pszObjectName, 0x4) == TRUE)
            return FALSE;

        if (pszObjectName[0] != 'M')
            return FALSE;

        return TRUE;
    }

    BOOL IsTurret()
    {
        return (GetFlags() & 0x2000);
    }
   
    BOOL IsPlayer()
    {
        return ReadOffset<BYTE >(this, 0x580) == 1;
    }

    BOOL IsAlive()
    {
        return ReadOffset<BYTE >(this, 0x12) == FALSE && GetHealth() > 0;
    }

    D3DXVECTOR3 GetPosition()
    {
        return ReadOffset<D3DXVECTOR3 >(this, 0x70);
    }

    PCHAR GetName()
    {
        return (PCHAR)&pszObjectName;
    }

    PCHAR GetChampion()
    {
        return (PCHAR)&pszChampion;
    }

    FLOAT GetHealth()
    {
        return ReadOffset<FLOAT>(this, 0x128);
    }

    FLOAT GetMaxHealth()
    {
        return ReadOffset<FLOAT>(this, 0x138);
    }

    FLOAT GetMana()
    {
        return ReadOffset<FLOAT>(this, 0x194);
    }

    FLOAT GetMaxMana()
    {
        return ReadOffset<FLOAT>(this, 0x1A4);
    }

    FLOAT GetExtraDamage()
    {
        return ReadOffset<FLOAT>(this, 0x640);
    }

    FLOAT GetBaseDamage()
    {
        return ReadOffset<FLOAT>(this, 0x6A4);
    }

    FLOAT GetDamage()
    {
        return GetBaseDamage() + GetExtraDamage();
    }

    FLOAT GetArmor()
    {
        return ReadOffset<FLOAT>(this, 0x6C0);
    }

    FLOAT GetMagicResist()
    {
        return ReadOffset<FLOAT>(this, 0x6C4);
    }

    FLOAT GetMovementSpeed()
    {
        return ReadOffset<FLOAT>(this, 0x6D4);
    }

    FLOAT GetGold()
    {
        return ReadOffset<FLOAT>(this, 0xE9C);
    }

    DWORD GetFlags()
    {
        return ReadOffset<INT>(this, 0x20);
    }

    FLOAT BaseDamage()
    {
        return ReadOffset<FLOAT>(this, 0x13A0);
    }

    FLOAT AttackRange()
    {
        return ReadOffset<FLOAT>(this, 0x6D8);
    }

    char _unknown0x0[0x2C];
    PCHAR pszObjectName;
    char _unknown0x30[0x4CC];
    PCHAR pszChampion;
};

class CObjectManager
{
public:
    CObject* GetObjectByID( UINT ID )
    {
        return m_pObjectArray[ ID ];
    }

    DWORD GetHighestIndexUsed( )
    {
        return m_dwHighestObjectID;
    }

    CObject** m_pObjectArray; // Array of active objects
    DWORD m_dwMaxObjects; // This is the highest amount of objects the array can store
    DWORD m_dwObjectsUsed; // Total number of objects in use
    DWORD m_dwHighestObjectID; // Highest index of an object actually used
    DWORD m_dwHighestPlayerObjectID; // Highest index in use for a player object
};

class CView
{
public:
    char _unknown0x0[0x18];
    PVOID ThisPtr; // 0x0018
    char _unknown0x1C[0x218];
    INT m_Width; // 0x0234
    INT m_Height; // 0x0238
    char _unknown0x23C[0x110B8];
    INT _unknown0x112F4; // Seems to always be 0
    INT _unknown0x112F8; // Seems to always be 0
    INT m_ResolutionWidth; // 0x112FC
    INT m_ResolutionHeight; // 0x11300
};

class CMatrixData
{
public:
    char _unknown0x0[0x94];
    D3DXMATRIX m_matView; // 0x0094
    D3DXMATRIX m_matProjection; // 0x00D4
};

// =================================================
// Helper Functions
// =================================================
inline CObjectManager* GetObjectManager()
{
    return (CObjectManager*)OBJECT_ARRAY;
}

inline CObject** GetObjectArray()
{
    return *(CObject***)OBJECT_ARRAY;
}

inline CObject* GetLocalEntity()
{
    return *(CObject**)OBJECT_LOCAL;
}

inline CObject* GetObjectByID(UINT ObjectID)
{
    return (GetObjectArray()[ObjectID]);
}

VOID WorldToScreen(D3DXVECTOR3* vecWorld, D3DXVECTOR3* vecScreen)
{
    CView* pView = *(CView**)(0xE3A00C);
    PVOID ThisPtr = pView->ThisPtr;

    D3DVIEWPORT9 viewPort;
    memset(&viewPort, 0, sizeof(viewPort));

    typedef VOID (__thiscall* GetViewportFn)(PVOID, D3DVIEWPORT9*);
    CallVirtual<GetViewportFn >(ThisPtr, 56)(ThisPtr, &viewPort);

    CMatrixData* pMatrixData = *(CMatrixData**)0xE3A00C;

    D3DXMATRIX matWorld;
    memset(&matWorld, 0, sizeof(matWorld));

    D3DXMatrixIdentity(&matWorld);

    D3DXMATRIX matProjection = pMatrixData->m_matProjection;
    D3DXMATRIX matView = pMatrixData->m_matView;

    D3DXVec3Project(vecScreen, vecWorld, &viewPort, &matProjection, &matView, &matWorld);

    vecScreen->x = (vecScreen->x - pView->_unknown0x112F4) / (pView->m_ResolutionWidth - pView->_unknown0x112F4) * pView->m_Width;
    vecScreen->y = (vecScreen->y - pView->_unknown0x112F8) / (pView->m_ResolutionHeight - pView->_unknown0x112F8) * pView->m_Height;
}

#endif // ENGINE_H


Lo que quiero pediros es a ver si alguien puede crear un ejecutable de esto para inyectarlo en un juego MMORPG o que me lo diga a mí cómo se hace.  El juego es el League of Legends.
Eso es todo.