#include 
#include 
#include 
#include "MinHook.h"
#pragma comment(lib, "libMinHook-x86-v141-mt.lib")
#pragma intrinsic(_ReturnAddress)
#define FAKEVER "0.3.7-R4"

enum
SampVersion
{
SAMP_UNKNOWN
=
-
1
,
SAMP_0_3_7_R1
=
0
,
SAMP_0_3_7_R3_1
,
SAMP_0_3_7_R4
,
}
;

DWORD READMEMFUNC
;
DWORD SAMPHMODULE
;
DWORD HOOKREADMEM
;
DWORD HOOKEXITREADMEM
;

HMODULE hSAMPModule
;
HMODULE hGTAModule
;
DWORD dwSampModule
;
DWORD dwGTAModule
;
unsigned
char
*
ClearSAMPModule
=
nullptr
;
// байты чистого сампа
unsigned
char
*
ClearGTAModule
=
nullptr
;
// байты чистой гташки

typedef
bool
(
__fastcall
*
RakPeer_RPC
)
(
void
*
,
void
*
,
int
*
,
BitStream
*
,
int
,
int
,
int
,
int
,
__int16
,
int
,
int
,
int
,
int
,
int
)
;
typedef
unsigned
char
(
__cdecl
*
ReadMemory
)
(
int
,
unsigned
__int16
)
;
typedef
void
(
__cdecl
*
ClientCheck
)
(
RPCParameters
*
)
;
RakPeer_RPC fpRPC
=
NULL
;
ReadMemory fpHkRead
=
NULL
;
ClientCheck fpHkClientCheck
=
NULL
;

.text:10011A3E 140 50                                push    eax
.text:10011A3F 144 E8 FC CC FF FF                    call    readMemory

// Объявляем функцию с параметром naked и укажем что она ничего не принимает и не возращает
__declspec
(
naked
)
void
HK_ReadMemory
(
void
)
{
static
unsigned
int
address
=
0
;
// Адрес откуда собирается читать самп
__asm
{
pushad
// Кидаем все регистры на стек, чтобы не затереть случайно лишнего
mov address
,
eax
// Вытаскиваем адрес с eax регистра
}
address
+=
reinterpret_cast

(
ClearGTAModule
)
-
dwGTAModule
;
// Меняем адрес на наш.
static
DWORD dwTmp
=
dwSampModule
+
READMEMFUNC
;
static
DWORD retjmp
=
dwSampModule
+
HOOKEXITREADMEM
;
__asm
{
popad
// тащим все регистры со стека обратно
mov eax
,
address
// перезаписываем регистр eax
push eax
// пушим его перед вызовом ReadMemory
call dwTmp
// Вызываем функцию ReadMemory
jmp retjmp
// Прыжок дальше
}
}

unsigned
char
__cdecl
HOOK_ReadMemory
(
unsigned
int
address
,
unsigned
short
readSize
)
{
auto
ret
=
reinterpret_cast

(
_ReturnAddress
(
)
)
;
// Получаем адрес куда вернется функция после своего возврата
if
(
ret
>=
0x400000
&&
ret

(
ClearGTAModule
)
-
dwGTAModule
;
}
else
{
// Чтение идет в модуле samp.dll
address
+=
reinterpret_cast

(
ClearSAMPModule
)
-
dwSAMPModule
;
}
return
fpHkReadMem
(
address
,
readSize
)
;
}

bool
__fastcall
HOOK_RakPeer_RPC
(
void
*
dis
,
void
*
EDX
,
int
*
uniqueID
,
BitStream
*
parameters
,
int
a4
,
int
a5
,
int
a6
,
int
a7
,
__int16 a8
,
int
a9
,
int
a10
,
int
a11
,
int
a12
,
int
a13
)
{
if
(
*
uniqueID
==
25
)
{
INT32 iVersion
;
UINT8 byteMod
;
UINT8 byteNicknameLen
;
UINT32 uiClientChallengeResponse
;
UINT8 byteAuthKeyLen
;
parameters
->
Read
(
iVersion
)
;
parameters
->
Read
(
byteMod
)
;
parameters
->
Read
(
byteNicknameLen
)
;
char
*
nickname
=
new
char
[
byteNicknameLen
+
1
]
;
nickname
[
byteNicknameLen
]
=
0
;
parameters
->
Read
(
nickname
,
byteNicknameLen
)
;
parameters
->
Read
(
uiClientChallengeResponse
)
;
parameters
->
Read
(
byteAuthKeyLen
)
;
char
*
authKey
=
new
char
[
byteAuthKeyLen
+
1
]
;
authKey
[
byteAuthKeyLen
]
=
0
;
parameters
->
Read
(
authKey
,
byteAuthKeyLen
)
;
parameters
->
SetWriteOffset
(
parameters
->
GetReadOffset
(
)
)
;
parameters
->
Write
(
static_cast

(
strlen
(
FAKEVER
)
)
)
;
parameters
->
Write
(
FAKEVER
,
strlen
(
FAKEVER
)
)
;
delete
[
]
authKey
,
nickname
;
}
return
fpRPC
(
dis
,
EDX
,
uniqueID
,
parameters
,
a4
,
a5
,
a6
,
a7
,
a8
,
a9
,
a10
,
a11
,
a12
,
a13
)
;
}

unsigned
char
readMemory
(
int
address
,
unsigned
__int16 readSize
)
{
unsigned
char
result
=
0
;
int
i
=
0
;
if
(
readSize
)
{
do
result
^=
*
(
BYTE
*
)
(
i
++
+
address
)
&
0xCC
;
while
(
i
!=
readSize
)
;
}
return
result
;
}

void
HandleRPCPacketFunc
(
RPCParameters
*
rpcParams
)
{
BitStream
bs
(
rpcParams
->
input
,
rpcParams
->
numberOfBitsOfData
/
8
,
false
)
;
#pragma pack(push, 1)
struct
CCheck
{
// Для удобной работы с входящими параметрами
unsigned
__int8 requestType
;
unsigned
__int32 arg
;
unsigned
__int16 offset
,
readSize
;
}
;
#pragma pack(pop)
CCheck
*
data
=
reinterpret_cast

(
rpcParams
->
input
)
;
// Определяем структуру
// Мы отправляем ответ только на те типы, которые R1 не обрабатывает. Остальное отдаем ему.
if
(
data
->
requestType
!=
0x45
&&
data
->
requestType
!=
5
)
fpHkClientCheck
(
rpcParams
)
;
if
(
data
->
readSize
>
256u
||
data
->
readSize

offset
>
256u
)
return
;
// Делаем те же проверки что и самп
unsigned
__int8 result
=
0
;
// что будем отправлять серверу
switch
(
data
->
requestType
)
{
case
0x5
:
if
(
data
->
arg
>=
0x400000
&&
data
->
arg

arg
+
data
->
offset
-
dwGTAModule
+
reinterpret_cast

(
ClearGTAModule
)
,
data
->
readSize
)
;
}
break
;
case
0x45
:
{
if
(
data
->
arg

arg
+
data
->
offset
+
reinterpret_cast

(
ClearSAMPModule
)
,
data
->
readSize
)
;
}
}
break
;
}
// Создадим битстрим для отправки
BitStream sendBS
;
// Записываем нужные данные.
sendBS
.
Write
(
data
->
requestType
)
;
sendBS
.
Write
(
data
->
arg
)
;
sendBS
.
Write
(
result
)
;
int
sendID
=
RPC_ClientCheck
;
#pragma pack(push, 1)
struct
CNetGameR1
{
// Опять же мне так удобнее.
char
junk
[
0x3C9
]
;
RakClientInterface
*
m_pRakClient
;
}
;
#pragma pack(pop)
RakClientInterface
*
pRak
=
(
*
reinterpret_cast

(
dwSampModule
+
0x21A0F8
)
)
->
m_pRakClient
;
// Отправляем результат чтения.
pRak
->
RPC
(
&
sendID
,
&
sendBS
,
PacketPriority
::
HIGH_PRIORITY
,
PacketReliability
::
RELIABLE_ORDERED
,
0u
,
false
)
;
return
;
}

DWORD oldProt
;
MH_Initialize
(
)
;
MODULEINFO SAMPmoduleInfo
;
hSAMPModule
=
GetModuleHandle
(
L
"samp.dll"
)
;
hGTAModule
=
GetModuleHandle
(
L
"gta_sa.exe"
)
;
dwSampModule
=
reinterpret_cast

(
hSAMPModule
)
;
dwGTAModule
=
reinterpret_cast

(
hGTAModule
)
;
if
(
hSAMPModule
==
NULL
||
hGTAModule
==
NULL
)
return
FALSE
;
// Вдруг самп не загружен

GetModuleInformation
(
GetCurrentProcess
(
)
,
hSAMPModule
,
&
SAMPmoduleInfo
,
sizeof
(
SAMPmoduleInfo
)
)
;
// Получаем инфу о модуле
switch
(
reinterpret_cast

(
SAMPmoduleInfo
.
EntryPoint
)
-
dwSampModule
)
{
case
0x31DF13
:
sampVer
=
SampVersion
::
SAMP_0_3_7_R1
;
break
;
case
0xCC4D0
:
sampVer
=
SampVersion
::
SAMP_0_3_7_R3_1
;
break
;
case
0xCBCB0
:
sampVer
=
SampVersion
::
SAMP_0_3_7_R4
;
break
;
default
:
return
FALSE
;
// Если версия неизвестная.
}

if
(
sampVer
==
SampVersion
::
SAMP_0_3_7_R1
)
{
ClearSAMPModule
=
reinterpret_cast

(
LockResource
(
LoadResource
(
hModule
,
FindResourceW
(
hModule
,
MAKEINTRESOURCEW
(
IDR_DLL_FILE1
)
,
L
"DLL_FILE"
)
)
)
)
;
// Получаем DLL сампа из ресурсов
MH_CreateAndEnableHook
(
dwSampModule
+
0xEAF0
,
&
HandleRPCPacketFunc
,
reinterpret_cast

(
&
fpHkClientCheck
)
)
;
// Ставим хук на обработчик RPC ClientCheck
MH_CreateAndEnableHook
(
dwSampModule
+
0x36C30
,
&
HOOK_RakPeer_RPC
,
reinterpret_cast

(
&
fpRPC
)
)
;
// Ставим хук на отправку рпц
}
else
{
switch
(
sampVer
)
{
case
SampVersion
::
SAMP_0_3_7_R3_1
:
{
HOOKREADMEM
=
0x11A3F
;
HOOKEXITREADMEM
=
0x11A44
;
READMEMFUNC
=
0xE740
;
SAMPHMODULE
=
0x26E880
;
}
break
;
case
SampVersion
::
SAMP_0_3_7_R4
:
{
HOOKREADMEM
=
0x11D6F
;
HOOKEXITREADMEM
=
0x11D74
;
READMEMFUNC
=
0xEA50
;
SAMPHMODULE
=
0x26E9B0
;
}
break
;
}
ClearSAMPModule
=
new
unsigned
char
[
SAMPmoduleInfo
.
SizeOfImage
]
;
// Выделяем массив
// Копируем модуль samp.dll
memcpy
(
ClearSAMPModule
,
reinterpret_cast

(
dwSampModule
)
,
0xC3500
+
256
)
;
// пределы чеков сампа - C3500
VirtualProtect
(
reinterpret_cast

(
dwSampModule
+
HOOKREADMEM
-
1
)
,
6
,
PAGE_EXECUTE_READWRITE
,
&
oldProt
)
;
*
reinterpret_cast

(
dwSampModule
+
HOOKREADMEM
-
1
)
=
0x90
;
// Нопим байт чтобы листинг не сбивался
//MH_CreateAndEnableHook(dwSampModule + HOOKREADMEM, &HK_ReadMemory, NULL); // Если у вас naked хук - расскоммментировать!
// Строку ниже закомментировать, если у вас naked хук
MH_CreateAndEnableHook
(
dwSampModule
+
0xEA50
,
&
sub_1000EA50
,
reinterpret_cast

(
&
fpHkRead
)
)
;
VirtualProtect
(
reinterpret_cast

(
dwSampModule
+
HOOKREADMEM
-
1
)
,
6
,
oldProt
,
&
oldProt
)
;
// Раскомментировать если у вас naked хук
/*
    VirtualProtect(reinterpret_cast(dwSampModule + SAMPHMODULE), 4, PAGE_EXECUTE_READWRITE, &oldProt);
    *reinterpret_cast(dwSampModule + SAMPHMODULE) = reinterpret_cast(ClearSAMPModule);
    VirtualProtect(reinterpret_cast(dwSampModule + SAMPHMODULE), 4, oldProt, &oldProt);
    */
}

MODULEINFO GTAmoduleInfo
;
GetModuleInformation
(
GetCurrentProcess
(
)
,
hGTAModule
,
&
GTAmoduleInfo
,
sizeof
(
GTAmoduleInfo
)
)
;
// копируем только то, что может прочитать сервер.
ClearGTAModule
=
new
unsigned
char
[
0x856000
+
256
-
0x400000
]
;
memcpy
(
ClearGTAModule
,
reinterpret_cast

(
dwGTAModule
)
,
0x856000
+
256
-
0x400000
)
;