ZetaLoader

README.md

Nim Fork of ZetaLoader.

Build:

1. main.nim

   nim c -d:release --app:gui -o:"ZetaLoader.exe" main.nim
   

2. dll.nim

   nim c -d:release --app:lib -o:"ZetaLoader.dll" dll.nim
   

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)

main.nim

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)