Nim Fork of ZetaLoader.
Build:
-
main.nim
nim c -d:release --app:gui -o:"ZetaLoader.exe" main.nim
-
dll.nim
nim c -d:release --app:lib -o:"ZetaLoader.dll" dll.nim
Nim Fork of ZetaLoader.
Build:
main.nim
nim c -d:release --app:gui -o:"ZetaLoader.exe" main.nim
dll.nim
nim c -d:release --app:lib -o:"ZetaLoader.dll" dll.nim
import winim/[lean, shell] | |
import os | |
import strutils | |
type DLL = object | |
hwnd: HWND | |
dm: DEVMODE | |
mon: string | |
x, y, cx, cy: int32 | |
pri: bool | |
WindowProc: WNDPROC | |
var dll: DLL | |
dll.dm.dmSize = sizeof(DEVMODE).WORD | |
dll.dm.dmFields = DM_PELSWIDTH or DM_PELSHEIGHT | |
dll.pri = true | |
proc NtSetTimerResolution(DesiredResolution: ULONG, SetResolution: BOOLEAN, | |
CurrentResolution: PULONG): LONG {.stdcall, dynlib: "ntdll.dll", | |
importc, discardable.} | |
proc NtQueryTimerResolution(MinimumResolution, MaximumResolution, | |
CurrentResolution: PULONG): LONG {.stdcall, dynlib: "ntdll.dll", | |
importc, discardable.} | |
proc SetDM(dm: ptr DEVMODE) = | |
if dll.dm.dmFields != 0: | |
ChangeDisplaySettingsEx(dll.mon, dm, 0, CDS_FULLSCREEN, nil) | |
proc BorderlessFullscreen() = | |
SetWindowLongPtr(dll.hwnd, GWL_STYLE, WS_VISIBLE or WS_POPUP) | |
SetWindowLongPtr(dll.hwnd, GWL_EXSTYLE, WS_EX_APPWINDOW) | |
SetWindowPos(dll.hwnd, HWND_TOPMOST, dll.x, dll.y, dll.cx, dll.cy, | |
SWP_NOACTIVATE or SWP_NOSENDCHANGING) | |
proc ForegroundWindowLock(lparam: LPVOID): DWORD {.stdcall.} = | |
let hthread = GetCurrentThread() | |
SetThreadPriority(hthread, THREAD_MODE_BACKGROUND_BEGIN) | |
SetThreadPriorityBoost(hthread, false) | |
CloseHandle(hthread) | |
while true: | |
SwitchToThisWindow(dll.hwnd, true) | |
return 0 | |
proc WindowProc(hwnd: HWND, msg: UINT, wparam: WPARAM, | |
lparam: LPARAM): LRESULT {.stdcall.} = | |
case msg: | |
of WM_DESTROY, WM_CLOSE, WM_QUIT: | |
ShowWindow(hwnd, SW_HIDE) | |
SetDM(nil) | |
of WM_ACTIVATE, WM_ACTIVATEAPP: | |
if dll.pri: | |
case wparam: | |
of WA_ACTIVE, WA_CLICKACTIVE: | |
if (IsIconic(hwnd)): | |
SwitchToThisWindow(hwnd, TRUE) | |
SetDM(addr dll.dm) | |
of WA_INACTIVE: | |
if not IsIconic(hwnd): | |
ShowWindow(hwnd, SW_MINIMIZE) | |
SetDM(nil) | |
else: discard | |
of WM_WINDOWPOSCHANGING: | |
BorderlessFullscreen() | |
return 0 | |
else: discard | |
return CallWindowProc(dll.WindowProc, hwnd, msg, wparam, lparam) | |
proc EnumWindowsProc(hwnd: HWND, lparam: LPARAM): BOOL {.stdcall.} = | |
var | |
pid: DWORD | |
hthread: HANDLE | |
let tid = GetWindowThreadProcessId(hwnd, addr pid) | |
if cast[DWORD](lparam) != pid: | |
return true | |
dll.hwnd = hwnd | |
dll.WindowProc = cast[WNDPROC](GetWindowLongPtr(hwnd, GWLP_WNDPROC)) | |
DwmSetWindowAttribute(hwnd, DWMWA_TRANSITIONS_FORCEDISABLED, addr dll.pri, | |
4); | |
DwmSetWindowAttribute(hwnd, DWMWA_DISALLOW_PEEK, addr dll.pri, 4); | |
DwmSetWindowAttribute(hwnd, DWMWA_FORCE_ICONIC_REPRESENTATION, addr dll.pri, | |
4); | |
hthread = OpenThread(THREAD_SET_INFORMATION, false, tid) | |
SetThreadPriority(hthread, THREAD_PRIORITY_TIME_CRITICAL) | |
CloseHandle(hthread) | |
return false | |
proc ZetaLoader(lparam: LPVOID): DWORD {.stdcall.} = | |
var | |
hmon: HMONITOR | |
mi: MONITORINFOEX | |
dm: DEVMODE | |
str: seq[string] | |
tm: DWORD | |
hthread: HANDLE | |
min, max, cur: ULONG | |
mi.cbSize = sizeof(MONITORINFOEX).DWORD | |
let pid = GetCurrentProcessId() | |
NtQueryTimerResolution(addr min, addr max, addr cur) | |
NtSetTimerResolution(max, TRUE, addr cur) | |
DwmEnableMMCSS(true) | |
AllowSetForegroundWindow(pid) | |
while (EnumWindows(EnumWindowsProc, cast[LPARAM](pid))): discard | |
hmon = MonitorFromWindow(dll.hwnd, MONITOR_DEFAULTTONEAREST) | |
GetMonitorInfo(hmon, cast[ptr MONITORINFO](addr mi)) | |
for c in mi.szDevice: | |
if c != 0: dll.mon.add(cast[char](c)) | |
if mi.dwFlags != MONITORINFOF_PRIMARY: | |
dll.pri = false | |
EnumDisplaySettings(dll.mon, ENUM_CURRENT_SETTINGS, addr dm) | |
if not fileExists("ZetaLoader.txt"): | |
writeFile("ZetaLoader.txt", "$1\n$2" % [$dm.dmPelsWidth, | |
$dm.dmPelsHeight]) | |
dll.dm.dmPelsWidth = dm.dmPelsWidth | |
dll.dm.dmPelsHeight = dm.dmPelsHeight | |
else: | |
str = readFile("ZetaLoader.txt").strip().splitLines() | |
try: | |
dll.dm.dmPelsWidth = str[0].strip().parseInt().DWORD | |
dll.dm.dmPelsHeight = str[1].strip().parseInt().DWORD | |
except ValueError: | |
discard | |
if dm.dmPelsWidth == dll.dm.dmPelsWidth and dm.dmPelsHeight == | |
dll.dm.dmPelsHeight: | |
dll.dm.dmFields = 0 | |
SystemParametersInfo(SPI_GETFOREGROUNDLOCKTIMEOUT, 0, cast[LPVOID](addr tm), 0) | |
SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, cast[LPVOID](0), 0) | |
hthread = CreateThread(nil, 0, ForegroundWindowLock, nil, 0, nil) | |
SetDM(addr dll.dm) | |
GetMonitorInfo(hmon, cast[ptr MONITORINFO](addr mi)) | |
dll.x = mi.rcMonitor.left | |
dll.y = mi.rcMonitor.top | |
dll.cx = mi.rcMonitor.right - mi.rcMonitor.left | |
dll.cy = mi.rcMonitor.bottom - mi.rcMonitor.top | |
BorderlessFullscreen() | |
SetWindowLongPtr(dll.hwnd, GWLP_WNDPROC, cast[LONG_PTR](WindowProc)) | |
TerminateThread(hthread, 0) | |
CloseHandle(hthread) | |
if tm != 0: | |
SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, cast[LPVOID]( | |
addr tm), 0) | |
return 0 | |
when isMainModule: | |
CreateThread(nil, 0, ZetaLoader, nil, 0, nil) |
import winim/lean | |
import os | |
proc WinEventProc( | |
hwineventhook: HWINEVENTHOOK, | |
event: DWORD, | |
hwnd: HWND, | |
idobject, idchild: LONG, | |
ideventthread, dwmseventtime: DWORD) {.stdcall.} = | |
if event != EVENT_OBJECT_SHOW or idobject != OBJID_WINDOW or idChild != CHILDID_SELF: | |
return | |
UnHookWinEvent(hwineventhook) | |
PostQuitMessage(0) | |
proc IsProcessAlive(lparam: LPVOID): DWORD {.stdcall.} = | |
let pi = cast[ptr PROCESS_INFORMATION](lparam) | |
WaitForSingleObject(pi.hProcess, INFINITE) | |
CloseHandle(pi.hProcess) | |
CloseHandle(pi.hThread) | |
quit(0) | |
when isMainModule: | |
let | |
dir = getAppDir() | |
dll = winstrConverterStringToPtrChar(dir/"ZetaLoader.dll\0") | |
var | |
pi: PROCESS_INFORMATION | |
si: STARTUPINFO | |
msg: MSG | |
mem: LPVOID | |
si.cb = sizeof(si).DWORD | |
setCurrentDir(dir) | |
if not fileExists($dll) or not fileExists("HaloInfinite.exe") or | |
CreateProcess("HaloInfinite.exe", nil, nil, nil, false, 0, nil, nil, | |
addr si, addr pi) == FALSE: | |
quit(0) | |
SetWinEventHook(EVENT_OBJECT_SHOW, EVENT_OBJECT_SHOW, 0, WinEventProc, | |
pi.dwProcessId, 0, WINEVENT_OUTOFCONTEXT) | |
CreateThread(nil, 0, IsProcessAlive, cast[LPVOID](addr pi), 0, nil) | |
while GetMessage(addr msg, 0, 0, 0): | |
TranslateMessage(addr msg) | |
DispatchMessage(addr msg) | |
mem = VirtualAllocEx(pi.hProcess, nil, MAX_PATH, MEM_COMMIT or MEM_RESERVE, PAGE_EXECUTE_READWRITE) | |
WriteProcessMemory(pi.hProcess, mem, cast[LPCVOID](dll), MAX_PATH, nil) | |
WaitForSingleObject(CreateRemoteThread(pi.hProcess, nil, 0, cast[ | |
LPTHREAD_START_ROUTINE](LoadLibraryA), mem, 0, nil), INFINITE) | |
VirtualFreeEx(pi.hProcess, mem, 0, MEM_RELEASE) | |
CloseHandle(pi.hProcess) | |
CloseHandle(pi.hThread) |