1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:

function mygetOwnModuleHandle: integer; stdcall;
{
  gets module handle of calling module
  [result]  module handle of calling module
}

function myLoadLibrary(dllname: pchar): integer; stdcall; overload;
{
  load a library which is not listed as a dll
  [dllname]  name of library
  [result]   handle of library
}
function myLoadLibrary(dllname, name: pchar): integer; stdcall; overload;
{
  load a library which is not listed as a dll
  [dllname]  name of library
  [name]     a string for the library, to use it in the dll
             you have to use the third parameter of Dllmain
  [result]   handle of library
}

function myFreeLib(module: integer): boolean; stdcall;
{
  unload a dll
  [module]  handle of dll to unload
  [result]  successful unloaded?
}

function myCreateRemoteThread(pid: cardinal; p: pointer): boolean; stdcall;
{
  function to create a thread in a process
  [pid]     process id
  [p]       startaddress of thread
  [result]  successful loaded?
}

function myInjectLibrary2(pid: cardinal; dlln: pchar): pointer; stdcall;
{
  function to inject a library into a process
  [pid]      process id
  [dlln]     dllname - must have path if its not in system directory or in the
                       directory of the process where it shall be loaded
  [result]   pointer of the address library injection in the target process
}
function myInjectLibrary(pid: cardinal; dlln: pchar): boolean; stdcall;
{
  function to inject a library into a process
  [pid]      process id
  [dlln]     dllname - must have path if its not in system directory or in the
                       directory of the process where it shall be loaded
  [result]   successful injected?
}

function myVirtualAllocEx(pid: cardinal; size: cardinal): pointer; stdcall;
{
  get memory in the process
  [pid]      process id
  [size]     size of memory which shall be allocated
  [result]   address of memory if
}

function myVirtualFreeEx(pid: cardinal; memaddr: pointer; size: cardinal): boolean; stdcall;
{
  free memory in process
  [pid]        process id
  [memaddr]    startaddress of memory which should be decommited
  [size]       size of memory which should be decommited
  [result]     successful if memory is decommited
}

function myOpenThread(access: integer; inherithandle: boolean; tid: integer): integer; stdcall;
{
  open a thread for specific access
  [access]             access rights
  [inheritedhandle]    should be false
  [tid]                thread id
  [result]             handle to opened thread
}

function myGetThread(pid: integer): integer; stdcall;
{
  gets a thread form the process id
  [pid]      process id
  [result]   thread id
}

function myFindProcessThread(exenames: pchar): integer; stdcall;
{
  find a thread from an executable name
  [exenames]   pchar with exenames  ex. "notepad.exe;explorer.exe;iexplore.exe;"
  [result]     thread id of one of the executables
}

function myFindModulesInProcess(pid: cardinal): pchar; stdcall;
{
  find all modules in a process
  [pid]      process id
  [result]   modules   ex. "kernel32.dll;ntdll.dll;user32.dll;"
}

function myHookApiIAT(modulehandle: integer; oldfunction, myfunction: pointer): boolean; stdcall; overload;
{
  hooks import table address
  [modulehandle]   handle of the module where the function is
  [oldfunction]    address of function to hook
  [myfunction]     address of new function
  [result]         successfull?
}


function myHookApiIAT(oldfunction, myfunction: pointer): boolean; stdcall; overload;
{
  hooks import table address

  [oldfunction]    address of function to hook
  [myfunction]     address of new function
  [result]         successfull?
}

function myInjectLibraryUnsecure(pid: cardinal; dlln: pchar): boolean; stdcall;
{
  function to inject a library into a process
  [pid]      process id
  [dlln]     dllname - must have path if its not in system directory or in the
                       directory of the process where it shall be loaded
  [result]   successful injected?
}

function myInjectLibraryUnsecure2(pid: cardinal; dlln: pchar): boolean; stdcall;
{
  function to inject a library into a process
  [pid]      process id
  [dlln]     dllname - must have path if its not in system directory or in the
                       directory of the process where it shall be loaded
  [result]   successful injected?
}


function myInstructionLength(addr: pointer): integer; stdcall;
{
  return the suce of the assembler instrucion
  [addr]     address of assembler instruction
  [result]   size of assembler instruction
}

function myHookAPIJMP(oldfunction,yourfunction: pointer; var nextfunction: pointer): boolean; stdcall;
{
  hooks a function
  [oldfunction]   function which to hook
  [yourfunction]  function where the hook should jump to
  [nextfunction]  function to call the original function
  [result]        successful hooked?
}

function myUnhookAPIJMP(nextfunction: pointer): boolean;
{
  unhooks a function
  [nextfunction]  function to unhook
  [result]        successful unhooked?
}


function myHookAPIJMPUnsecure(oldfunction,yourfunction: pointer; var nextfunction: pointer): boolean; stdcall; assembler;
{
  hooks a function
  [oldfunction]   function which to hook
  [yourfunction]  function where the hook should jump to
  [nextfunction]  function to call the original function
  [result]        successful hooked?
}

function myUnhookApiJMPunsecure(nextfunction: pointer): boolean; stdcall; assembler;
{
  unhooks a function
  [nextfunction]  function to unhook
  [result]        successful unhooked?
}

function myFindProcess(exenames: pchar): integer; stdcall;
{
  searches for a process id by executable name
  [exenames]   name of executable ex. "hl.exe;cstrike.exe;czero.exe"
  [result]     process id of one of the executables
}

function myCreateRemoteThreadUnsecure(pid: cardinal; addr: pointer; NTuseCRT: boolean): cardinal; stdcall;
{
  function to create a thread in a process

  [pid]     process id
  [p]       startaddress of thread
  [result]  successful loaded?
}

function myisNT: boolean; stdcall;
{
  returns if operting system is a windowsNT based system
  [return] true if windowsNT based system else false
}
function myGetProcAddr(module: integer; procname: pchar): pointer; stdcall;
{
  get a procedure address from a module
  [module]    module handle
  [procname]  procedure name
  [result]    address of procedure
}

function myGetDebugPrivilege: boolean; stdcall;
{
  gives u the debug privilegue
  [result] successful got it
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

function myForceLoadLibraryA(name: pchar): integer; stdcall;
{
  loads a dll, doesnt matter if its allready loaded
  [name]    name of the dll to load
  [result]  handle of loaded dll
}

function myGhostLibrary(lib: integer): boolean; stdcall;
{
  hides a library in the process
  [lib]     handle of module to hide
  [result]  successful hided?
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

library fakeogl32;

uses
  windows;

const opengl32 = 'C:\windows\system32\opengl32.dll';

type
  HGLRC = THandle;

type
  GLenum  = Cardinal;

const
  GL_TRIANGLE_STRIP = $0005;
  GL_TRIANGLE_FAN  = $0006;
  GL_DEPTH_TEST = $0B71;

procedure {ka}oldglBegin (mode: GLenum); stdcall; external opengl32 name 'glBegin';
procedure {ka}glDisable (cap: GLenum); stdcall; external opengl32 name 'glDisable';
procedure {ka}glEnable (cap: GLenum); stdcall; external opengl32 name 'glEnable';

procedure glBegin(mode: glenum); stdcall;
begin
  if (mode = GL_TRIANGLE_STRIP) or (mode = GL_TRIANGLE_FAN) then
    glDisable(GL_DEPTH_TEST) else
      glEnable(GL_DEPTH_TEST);
end;

exports
  glBegin;

begin
end.					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:

library hackdll;


uses windows, myhook;

type
  GLenum  = Cardinal;
const   
  GL_TRIANGLE_STRIP = $0005;   
  GL_TRIANGLE_FAN  = $0006;
  GL_DEPTH_TEST = $0B71;   

var
 nextglBegin: procedure (mode: GLenum); stdcall;
 oldglBegin: procedure (mode: GLenum); stdcall;
 oldglDisable: procedure (cap: GLenum); stdcall;
 oldglEnable: procedure (cap: GLenum); stdcall;

procedure myglBegin(mode: glenum); stdcall;
begin
  if (mode = GL_TRIANGLE_STRIP) or (mode = GL_TRIANGLE_FAN) then
    oldglDisable(GL_DEPTH_TEST) else oldglEnable(GL_DEPTH_TEST);
  nextglBegin(mode);
end;

var hogl: integer;
begin
  hogl := GetModuleHandle('opengl32.dll');
  if hogl = 0 then hogl := LoadLibaryA('opengl32.dll');

  @oldglBegin := GetProcAddress(oglh,'glBegin');
  @oldglEnable := GetProcAddress(oglh,'glEnable');
  @oldglDisable := GetProcAddress(oglh,'glDisable');

  myhook.myHookAPIJMP(@oldglBegin,@myglBegin,@nextglBegin);
end.					

1:

nextglBegin(mode);					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:

library glhook;

uses
  windows,
  SysUtils,
  uallhook;

type
  GLenum = cardinal;
const   
  GL_TRIANGLE_STRIP = $0005;   
  GL_TRIANGLE_FAN  = $0006;
  GL_DEPTH_TEST = $0B71;
var
  oldglBegin, nextglBegin: procedure(mode: GLenum); stdcall;
  oldglDisable: procedure(cap: GLenum); stdcall;
  oldglEnable: procedure(cap: GLenum); stdcall;

procedure myglBegin(mode: glenum); stdcall;
begin
  if (mode = GL_TRIANGLE_STRIP) or (mode = GL_TRIANGLE_FAN) then
    oldglDisable(GL_DEPTH_TEST) else
      oldglEnable(GL_DEPTH_TEST);
  nextglBegin(mode);    
end;

procedure injectmain;
var
  h: integer;
begin
  h := GetModuleHandle('opengl32.dll');
  if h = 0 then
    LoadLibraryA('opengl32.dll');
  if h > 0 then
  begin
    @oldglBegin := GetProcAddress(h, 'glBegin');
    @oldglEnable := GetProcAddress(h, 'glEnable');
    @oldglDisable := GetProcAddress(h, 'glDisable');
    if @oldglBegin <> nil then
      uallHook.HookCode(@oldglBegin, @myglBegin, @nextglBegin);
  end;
end;

procedure uninjectmain;
begin
  uallHook.UnhookCode(@nextglBegin);
end;

procedure dllmain(dwReason: integer);
begin
  case dwreason of
    DLL_PROCESS_ATTACH:
      injectmain;
    DLL_PROCESS_DETACH:
      uninjectmain;
  end;
end;

begin
  DLLProc := @DLLMain;
  DLLMain(1);
end.					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

program hack;

{$APPTYPE CONSOLE}

uses
  windows,
  uallHook,
  uallProcess,
  uallUtil;

var pid: integer;
begin
  pid := uallProcess.FindProcess('cstrike.exe');
  if pid = 0 then
    pid := uallProcess.FindProcess('hl.exe');
  if pid <> 0 then
  begin
    if uallHook.InjectLibrary(pid,pchar(uallUtil.GetExeDirectory + 'glhook.dll')) <> nil then
      MessageBox(0, 'Injection successful', nil, 0) else
        MessageBox(0, 'Injection failed', nil, 0);
  end;
end.					

1:

uallProcess.FindProcess('hl.exe' + #13#10 + 'cstrike.exe' + #13#10 + 'czero.exe');