#include 
#include 
class
ModuleHider
{
private
:
//only x86 structs
typedef
struct
_PEB_LDR_DATA
{
ULONG Length
;
BOOLEAN Initialized
;
HANDLE SsHandle
;
LIST_ENTRY InLoadOrderModuleList
;
LIST_ENTRY InMemoryOrderModuleList
;
LIST_ENTRY InInitializationOrderModuleList
;
PVOID      EntryInProgress
;
}
PEB_LDR_DATA
,
*
PPEB_LDR_DATA
;
typedef
struct
_LDR_DATA_ENTRY
{
//PVOID Reserved1[0];
LIST_ENTRY InLoadOrderModuleList
;
LIST_ENTRY InInitializationOrderModuleList
;
LIST_ENTRY InMemoryOrderModuleList
;
//PVOID Reserved2[2];
PVOID DllBase
;
PVOID Reserved3
[
2
]
;
UNICODE_STRING FullDllName
;
BYTE Reserved4
[
8
]
;
PVOID Reserved5
[
3
]
;
#pragma warning(push)
#pragma warning(disable: 4201)
// we'll always use the Microsoft compiler
union
{
ULONG CheckSum
;
PVOID Reserved6
;
}
DUMMYUNIONNAME
;
#pragma warning(pop)
ULONG TimeDateStamp
;
}
LDR_DATA_ENTRY
,
*
PLDR_DATA_ENTRY
;
PPEB_LDR_DATA _m_pPEB_LDR
;
PLDR_DATA_ENTRY _m_pEntry
;
HINSTANCE _m_DllHandle
;
PLDR_DATA_ENTRY _m_pDoEntry
,
_m_pAfterEntry
;
LIST_ENTRY _m_origAddrs
;
bool
_m_bIsHided
;
public
:
ModuleHider
(
const
HINSTANCE hModule
)
:
_m_DllHandle
(
hModule
)
,
_m_bIsHided
(
false
)
{
_m_pPEB_LDR
=
(
PPEB_LDR_DATA
)
NtCurrentTeb
(
)
->
ProcessEnvironmentBlock
->
Ldr
;
_m_pEntry
=
(
PLDR_DATA_ENTRY
)
_m_pPEB_LDR
->
InLoadOrderModuleList
.
Flink
;
}
;
~
ModuleHider
(
)
{
Show
(
)
;
}
;
auto
Hide
(
void
)
->
bool
{
if
(
_m_bIsHided
==
true
)
return
false
;
while
(
_m_pEntry
->
DllBase
)
{
if
(
_m_pEntry
->
DllBase
==
_m_DllHandle
)
{
_m_pDoEntry
=
(
PLDR_DATA_ENTRY
)
_m_pEntry
->
InLoadOrderModuleList
.
Blink
;
_m_pAfterEntry
=
(
PLDR_DATA_ENTRY
)
_m_pEntry
->
InLoadOrderModuleList
.
Flink
;
_m_origAddrs
.
Flink
=
_m_pAfterEntry
->
InLoadOrderModuleList
.
Blink
;
_m_origAddrs
.
Blink
=
_m_pDoEntry
->
InLoadOrderModuleList
.
Flink
;
_m_pDoEntry
->
InLoadOrderModuleList
.
Flink
=
_m_pEntry
->
InLoadOrderModuleList
.
Flink
;
_m_pAfterEntry
->
InLoadOrderModuleList
.
Blink
=
_m_pEntry
->
InLoadOrderModuleList
.
Blink
;
_m_bIsHided
=
true
;
return
true
;
}
_m_pEntry
=
(
PLDR_DATA_ENTRY
)
_m_pEntry
->
InLoadOrderModuleList
.
Flink
;
}
return
false
;
}
;
auto
Show
(
void
)
->
bool
{
if
(
_m_bIsHided
==
true
)
{
_m_pDoEntry
->
InLoadOrderModuleList
.
Flink
=
_m_origAddrs
.
Flink
;
_m_pAfterEntry
->
InLoadOrderModuleList
.
Blink
=
_m_origAddrs
.
Blink
;
_m_bIsHided
=
false
;
return
true
;
}
return
false
;
}
;
auto
IsModuleHided
(
void
)
->
bool
{
return
_m_bIsHided
;
}
;
}
;

HINSTANCE hModule
{
}
;
//предположим, что это валидный хендл нашего модуля
//создадим экзепляр класса, передавая в конструктор хендл модуля
std
::
unique_ptr

pModuleHider
=
std
::
make_unique

(
hModule
)
;
//метод для скрытия модуля
if
(
pModuleHider
->
Hide
(
)
)
std
::
cout

Show
(
)
)
std
::
cout

IsModuleHided
(
)
;

0B8F:
convert_screen_coords
1@
2@
depth
3@
to_world_3d
4@
5@
6@

#if defined(_MSC_VER)
#define CC_STDCALL   __stdcall
#elif defined(__GNUC__) || defined(__clang__)
#define CC_STDCALL   __attribute__((stdcall))
#endif
typedef
struct
D3DMATRIX
{
union
{
struct
{
float
_11
;
float
_12
;
float
_13
;
float
_14
;
float
_21
;
float
_22
;
float
_23
;
float
_24
;
float
_31
;
float
_32
;
float
_33
;
float
_34
;
float
_41
;
float
_42
;
float
_43
;
float
_44
;
}
;
float
m
[
4
]
[
4
]
;
}
;
}
D3DMATRIX
;
typedef
struct
CVector
{
float
x
;
float
y
;
float
z
;
}
CVector
;
typedef
char
(
CC_STDCALL
*
D3DXMatrixInverse_t
)
(
void
*
a1
,
float
*
a2
,
const
void
*
a3
)
;
D3DXMatrixInverse_t D3DXMatrixInverse
=
(
D3DXMatrixInverse_t
)
0x76795B
;
void
convert_screen_coords_to_world_3d
(
const
CVector
*
screen_coors
,
CVector
*
world_coors
)
{
D3DMATRIX worldMatrix
;
/* Get the combined view-projection matrix and invert it */
memcpy
(
&
worldMatrix
,
(
const
void
*
)
0xB6FA2C
,
sizeof
(
worldMatrix
)
)
;
worldMatrix
.
m
[
3
]
[
3
]
=
1.0f
;
D3DMATRIX inverseMatrix
;
// TODO: Check is it possible to reuse the same matrix
D3DXMatrixInverse
(
&
inverseMatrix
,
NULL
,
&
worldMatrix
)
;
/* Apply the inverse view-projection matrix to the screen coordinates */
float
invZ
=
1.0f
/
screen_coors
->
z
;
float
screenX
=
screen_coors
->
x
/
(
*
(
int
*
)
0xC17044
*
invZ
)
;
float
screenY
=
screen_coors
->
y
/
(
*
(
int
*
)
0xC17048
*
invZ
)
;
/* Transform the screen coordinates into world coordinates */
world_coors
->
x
=
screenX
*
inverseMatrix
.
_11
+
screenY
*
inverseMatrix
.
_21
+
screen_coors
->
z
*
inverseMatrix
.
_31
+
inverseMatrix
.
_41
;
world_coors
->
y
=
screenX
*
inverseMatrix
.
_12
+
screenY
*
inverseMatrix
.
_22
+
screen_coors
->
z
*
inverseMatrix
.
_32
+
inverseMatrix
.
_42
;
world_coors
->
z
=
screenX
*
inverseMatrix
.
_13
+
screenY
*
inverseMatrix
.
_23
+
screen_coors
->
z
*
inverseMatrix
.
_33
+
inverseMatrix
.
_43
;
}

std
::
string
separate_number
(
auto
number
,
char
separator
=
' '
)
{
static_assert
(
std
::
is_integral_v

,
"only integral values are supported"
)
;
std
::
string ret_number
;
auto
number_str
=
std
::
to_string
(
number
)
;
auto
i
=
0
;
for
(
auto
str_iter
=
number_str
.
rbegin
(
)
;
str_iter
!=
number_str
.
rend
(
)
;
++
str_iter
)
{
auto
next_str_iter
=
str_iter
+
1
;
ret_number
+=
*
str_iter
;
if
(
next_str_iter
!=
number_str
.
rend
(
)
&&
*
next_str_iter
!=
'-'
&&
++
i
==
3
)
{
ret_number
+=
separator
;
i
=
0
;
}
}
std
::
reverse
(
ret_number
.
begin
(
)
,
ret_number
.
end
(
)
)
;
return
ret_number
;
}

void
WriteNamesToFile
(
const
std
::
string
&
filename
,
const
std
::
set

&
names
)
{
std
::
ofstream
outfile
(
filename
)
;
for
(
const
auto
&
name
:
names
)
{
if
(
!
name
.
empty
(
)
)
{
outfile

names
=
ReadNamesFromFile
(
filename
)
;
if
(
new_name
.
empty
(
)
||
names
.
find
(
new_name
)
!=
names
.
end
(
)
)
return
;
names
.
insert
(
new_name
)
;
WriteNamesToFile
(
filename
,
names
)
;
}
//name_to_remove or in general any text
void
RemoveNameFromFile
(
const
std
::
string
&
filename
,
const
std
::
string
&
name_to_remove
)
{
std
::
set

names
=
ReadNamesFromFile
(
filename
)
;
if
(
names
.
erase
(
name_to_remove
)
>
0
)
WriteNamesToFile
(
filename
,
names
)
;
}
bool
NameExistsInFile
(
const
std
::
string
&
filename
,
const
std
::
string
&
name_to_check
)
{
std
::
set

names
=
ReadNamesFromFile
(
filename
)
;
return
names
.
find
(
name_to_check
)
!=
names
.
end
(
)
;
}
std
::
set

ReadNamesFromFile
(
const
std
::
string
&
filename
)
{
std
::
set

names
;
std
::
ifstream
infile
(
filename
)
;
std
::
string name
;
while
(
std
::
getline
(
infile
,
name
)
)
{
if
(
!
name
.
empty
(
)
)
names
.
insert
(
name
)
;
}
return
names
;
}

float
getFloatFromMemory
(
unsigned
char
*
memoryAddress
)
{
float
*
floatPtr
=
reinterpret_cast

(
memoryAddress
)
;
return
*
floatPtr
;
}
void
setFloatToMemory
(
unsigned
char
*
memoryAddress
,
float
value
)
{
float
*
floatPtr
=
reinterpret_cast

(
memoryAddress
)
;
*
floatPtr
=
value
*
31.47000244
;
}