KERALA PC CHECKING COMMUNITY · EVIDENCE COMPENDIUM · COMPILED EDITION

PC Cheat-Check & Forensic Investigation Field Manual

A complete, organized reference for esports tournament anti-cheat officials — starting from built-in Windows commands, through Eric Zimmerman's forensic tool suite, kernel-level driver forensics, PE-sieve memory-scan interpretation, and all the way to a screenshot-based analyst protocol. Everything in one place.

SECTIONS: 7 PARTS
SCOPE: No-Tool → Advanced Forensics
TOOLS REFERENCED: Legitimate / Industry-Standard
STATUS: Reference Only — Human Decision Required
A

Full Manual PC Cheat-Check Guide (No Extra Tools Needed)

BUILT-IN WINDOWS ONLY

1 Registry (Manual GUI check via Win+R > regedit)

Autostart / Persistence check

HKCU\Software\Microsoft\Windows\CurrentVersion\Run
HKLM\Software\Microsoft\Windows\CurrentVersion\Run
HKLM\Software\WOW6432Node\Microsoft\Windows\CurrentVersion\Run
HKCU\Software\Microsoft\Windows\CurrentVersion\RunOnce
If any unknown or randomly-named .exe appears here, treat it as a red flag — cheat loaders often add an entry here so they start automatically at boot.

Recently opened files (MRU)

HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RecentDocs
HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\ComDlg32\OpenSavePidlMRU

Program execution history (very important)

HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist
This key is ROT13-encoded, but with a forensic decoder tool it reveals when and how many times an .exe was run. Even if the cheat was later deleted, this trace remains.

Shimcache / AppCompatCache (program run history, survives deletion)

HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache

Windows Defender Exclusions (a common cheat-hiding trick)

HKLM\SOFTWARE\Microsoft\Windows Defender\Exclusions\Paths
HKLM\SOFTWARE\Microsoft\Windows Defender\Exclusions\Processes
If someone has added their own cheat folder/process to this list to avoid Defender detection, that is 100% suspicious.

USB / Device history

HKLM\SYSTEM\CurrentControlSet\Enum\USBSTOR
Check whether a hardware cheat device (Cronus, programmable mouse, etc.) has ever been plugged in.

2 USN Journal (Deleted file history)

Traces remain even after a cheat file is deleted — run in CMD (Admin mode required):

fsutil usn queryjournal C:
Checks whether the journal is enabled.

To dump the full readable journal (built-in tool, no install needed):

fsutil usn readjournal C: csv > journal_dump.csv
This creates a CSV file containing the full create/delete/rename history of files, even if the file has already been deleted. Opening it in Excel and searching for file names (e.g. "loader", "inject", ".dll") will show exactly when a file was created and deleted.

3 CMD Commands (No tool needed)

Running processes list (with path)

tasklist /v
wmic process get name,executablepath,processid,parentprocessid
Best for checking the parent process — if the game was spawned from an unknown launcher, this reveals it.

Network connections (does the cheat tool connect to an external server?)

netstat -anob
The -b flag also shows which process opened which connection.

Scheduled tasks list (persistence check)

schtasks /query /fo LIST /v
Cheat loaders often create a scheduled task to relaunch themselves on restart — this is where that would show up.

Services list (is it running as a background service?)

sc query type= service state= all

DLLs loaded by a specific process (game process DLL check)

tasklist /m /fi "imagename eq <game.exe>"
Shows which DLLs are loaded alongside the game process — an unknown or randomly-named DLL is suspicious.

Recently modified/created files (last few days)

forfiles /P C:\Users\<username>\AppData\Local /S /D -3 /C "cmd /c echo @path @fdate @ftime"
Shows whether any file was created or modified inside AppData in the last 3 days.

Prefetch files check (program run history, no GUI needed)

dir C:\Windows\Prefetch
When a program runs, Windows creates a .pf file for optimization purposes. Even if the program is deleted, its name remains in Prefetch — this is very reliable evidence that the program ran at some point.

Alternate Data Streams check (is a file hidden inside another file?)

dir /r
Cheat files are often hidden inside a normal file's ADS (Alternate Data Stream).

4 Manual Folder Check (No tool)

These folders need to be checked manually:

C:\Windows\Temp
C:\Users\<user>\AppData\Local\Temp
C:\Users\<user>\AppData\Roaming
C:\Windows\Prefetch
C:\Windows\System32\Tasks
C:\ProgramData
Investigate if there's a randomly-named folder (e.g. 7ZS08F988D8 style), or a game-unrelated .exe/.dll sitting in these locations.

To see hidden files

File Explorer > View > Show > Hidden items ON, plus turn OFF "Hide protected operating system files" in Folder Options — otherwise many files stay hidden.

5 Event Viewer Manual Check (No Sysmon)

eventvwr.msc

The event ID list mentioned earlier (4688, 7045, 1116, 4104, 106, etc.) can also be checked manually through the GUI — no extra tool needed, just filter by that ID.

6 Browser History (Manual)

chrome://history
edge://history
brave://history
Searches for cheat websites, "undetected cheat", "bypass anticheat" etc. will show up directly here. Download history should also be checked: chrome://downloads

7 Quick Priority Checklist (For a Discord pin)

  • Registry Run keys check
  • Defender Exclusions check (Path + Process)
  • fsutil usn readjournal — deleted file history
  • dir C:\Windows\Prefetch — run history
  • schtasks /query — scheduled task check
  • tasklist /v — running processes + path
  • Loaded DLL check on the game process
  • Manual browser history/downloads check
  • Manual AppData/Temp folder scan
Following just this much amounts to a basically full manual forensic check — no tool download is required, everything runs on Windows' own built-in features.
B

Part 2 (Extra) — More Registry & CMD

BUILT-IN WINDOWS ONLY

8 More Registry Locations

BAM/DAM (Background Activity Moderator — which program ran when, very reliable)

HKLM\SYSTEM\CurrentControlSet\Services\bam\State\UserSettings\<SID>
Similar to Prefetch but includes an exact date/time along with the full path, and the entry survives even after the program is deleted. Extremely powerful for anti-cheat forensics.

Shellbags (history of which folders were browsed)

HKCU\Software\Microsoft\Windows\Shell\BagMRU
HKCU\Software\Microsoft\Windows\Shell\Bags
Even if a folder is deleted, evidence that someone visited it remains in this registry location.

Windows Firewall exceptions (was the cheat process given internet access?)

HKLM\SYSTEM\CurrentControlSet\Services\SharedAccess\Parameters\FirewallPolicy\FirewallRules

Installed programs list (registry version, faster than the GUI)

HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall
HKLM\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall

9 More CMD/PowerShell Commands

Startup folder check (direct folder, not the registry)

explorer shell:startup
explorer shell:common startup
Any shortcut/exe placed directly here will run at boot.

Hosts file check (cheat tools sometimes edit this to block anti-cheat servers)

notepad C:\Windows\System32\drivers\etc\hosts
Check whether any anti-cheat/game server domain has been blocked (e.g. a line like "0.0.0.0 vanguard.riotgames.com" would be suspicious).

Driver list (for catching kernel-level cheat drivers)

driverquery /v /fo LIST
Look for unknown/unsigned driver names, especially ones installed recently.

Full installed program list (without the GUI)

wmic product get name,installdate

Recycle Bin check (via CMD)

dir C:\$Recycle.Bin /a /s
Deleted files will still show up here if they weren't permanently deleted.

PowerShell command history (if someone downloaded/ran something via PowerShell)

type %appdata%\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.txt
Very important — every command a user typed into PowerShell is saved here, until it's manually cleared.

WMI persistence check (an advanced technique used by cheats/malware)

wmic /namespace:\\root\subscription PATH __EventFilter get Name
wmic /namespace:\\root\subscription PATH CommandLineEventConsumer get Name,CommandLineTemplate
This should be empty on a normal user's PC — if anything shows up here, it's deeply suspicious.

Currently open network ports mapped to a process

netstat -ano | findstr LISTENING

ARP cache (is someone controlling via another device on the LAN, e.g. remote assistance?)

arp -a

Clock/timezone check (for catching timestamp manipulation — cheat files may have their timestamps altered to hide them)

w32tm /query /status

10 More Manual Checks (No Tool)

Amcache file (program execution history, forensically strong)

C:\Windows\AppCompat\Programs\Amcache.hve
This can't be read directly in Notepad (it's a binary file), but its existence/modification date already tells you something was installed or run. A full analysis needs a parser, but it's worth noting for future reference.

Windows optional features

Control Panel > Programs > Turn Windows features on or off

Check whether any unusual feature is enabled, such as Windows Sandbox or WSL — someone could use these to run a cheat in isolation to avoid detection.

Group Policy scripts (does a script run automatically at login/logout?)

gpedit.msc
Computer Configuration > Windows Settings > Scripts (Startup/Shutdown)

RDP/Remote access log

Check whether the PC is being accessed remotely, or whether a cheat is being run via a third party:

eventvwr.msc > Applications and Services Logs > Microsoft > Windows > TerminalServices-RemoteConnectionManager > Operational

⚡ UPDATED QUICK PRIORITY LIST (Combined)

  • Registry Run keys + BAM/DAM
  • Defender Exclusions (Path + Process)
  • fsutil usn readjournal — deleted file history
  • dir C:\Windows\Prefetch — run history
  • Amcache.hve existence/date check
  • schtasks /query + WMI event subscription check
  • tasklist /v + driverquery /v
  • PowerShell history file
  • Hosts file check
  • Game process DLL check
  • Browser history/downloads
  • AppData/Temp/Recycle Bin manual scan
This is now basically a professional-level manual forensic checklist — after this, nothing more should generally be needed, just practice using it.
C

Part 3 — Final Additions

MANUAL + EZ TOOLS CLI

11 Jump Lists (Manual GUI check, no tool)

%AppData%\Microsoft\Windows\Recent\AutomaticDestinations
%AppData%\Microsoft\Windows\Recent\CustomDestinations
This folder holds .automaticDestinations-ms files that record which files/apps were recently opened. They can't be read directly in Notepad (binary), but the file's modification date alone tells you when activity occurred.

12 Clipboard History

Win + V
If clipboard history is turned on, you can see what was recently copied — a cheat license key, download link, Discord invite, etc. copy-pasted there could get caught.

13 Browser Extensions Check

chrome://extensions   (Chrome)
edge://extensions     (Edge)
Check any unknown extension — some cheat-related tools are distributed as browser extensions too (screen-capture bypass, macro tools, etc.).

14 Windows Error Reporting (WER) Files

C:\ProgramData\Microsoft\Windows\WER\ReportArchive
C:\ProgramData\Microsoft\Windows\WER\ReportQueue
When a program crashes, a detailed crash report is stored here, showing the crashed .exe's full path and its module list — if a cheat tool crashed, a trace may be found here.

15 Volume Shadow Copy (Deleted file recovery check)

vssadmin list shadows
If a system restore point/shadow copy exists, old deleted files can be recovered (advanced, requires admin access).

16 LNK (Shortcut) Files Manual Check

%AppData%\Microsoft\Windows\Recent
This folder holds shortcuts (.lnk) to recently opened files. Right-click > Properties > "Target" shows where the original file was located — even if the file itself was deleted, this shortcut remains, which is useful for learning the original path/name.

17 Discord/Chat App Local Cache (The player's own "confession" may be here)

%AppData%\discord\Cache
%AppData%\discord\Local Storage\leveldb
A chat app's local cache often stores old messages/images even without a screenshot — useful if a previous conversation discussed buying or discussing a cheat.

18 Installed Fonts/Driver Timestamp Anomaly

C:\Windows\Fonts
C:\Windows\System32\drivers
Cheat drivers are often hidden under the name of a normal driver/font file (a misleading name) — sorting the file list by "Date modified" helps surface the recent/odd file.
✅ Combining these three parts (Part 1, 2, 3), practically every manual Windows-based forensic check is now covered — Registry, Journal, Prefetch, BAM/DAM, Event Logs, CMD/PowerShell commands, browser, chat cache, shortcuts, WER crash logs — all of it.

To be honest: the next level up is memory dump analysis (looking directly at running injected code inside RAM) or disk imaging — these genuinely require dedicated forensic tools (WinDbg, Volatility, FTK Imager, etc.); they can't be done with built-in Windows commands alone. At that stage this stops being a "quick PC check" and becomes a full-blown digital forensics investigation.

With these three parts combined, any tournament official should now be able to perform a full manual check on their own, without needing an external guide.

EZ Eric Zimmerman's Tools — CLI Commands

Eric Zimmerman's forensic tool suite (EZ Tools) is a completely legitimate, industry-standard digital forensics toolset — used by law enforcement and corporate investigators. These tools parse the same registry/journal data we were reading manually earlier into a readable format (CSV/JSON).

Download (Official)

All tools together: https://ericzimmerman.github.io/#!index.md
Or individual tools from GitHub: https://github.com/EricZimmerman

⚠️ Note: Only download from this official source.

1. AmcacheParser (to parse Amcache.hve)

AmcacheParser.exe -f "C:\Windows\AppCompat\Programs\Amcache.hve" --csv "C:\Output"
Extracts program execution history (previously unreadable raw binary). The output CSV includes file path, execution timestamp, and SHA1 hash.

2. AppCompatCacheParser (to parse Shimcache)

AppCompatCacheParser.exe -f "C:\Windows\System32\config\SYSTEM" --csv "C:\Output"
Extracts program execution traces directly from the registry hive.

3. RECmd (to parse the entire registry — the most powerful option)

RECmd.exe --bn "BatchExamples\Kroll_Batch.reb" -d "C:\Users\<user>\NTUSER.DAT" --csv "C:\Output"
The BatchExamples folder contains pre-built batch files that scan Run keys, persistence locations, etc. all at once.

To check a single key:

RECmd.exe -f "C:\Users\<user>\NTUSER.DAT" --kn "Software\Microsoft\Windows\CurrentVersion\Run" --csv "C:\Output"

4. MFTECmd (to parse the $MFT and USN Journal)

Far more detailed than the earlier fsutil usn readjournal. Master File Table parsing:

MFTECmd.exe -f "C:\$MFT" --csv "C:\Output"

USN Journal parsing (deleted file history, much more readable):

MFTECmd.exe -f "C:\$Extend\$J" --csv "C:\Output" --json "C:\Output"

5. JLECmd (Jump List parsing — CLI version)

JLECmd.exe -d "C:\Users\<user>\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations" --csv "C:\Output"

6. LECmd (LNK/Shortcut file parsing)

LECmd.exe -d "C:\Users\<user>\AppData\Roaming\Microsoft\Windows\Recent" --csv "C:\Output"
Extracts the original file path and timestamp embedded inside a shortcut.

7. PECmd (Prefetch parsing)

PECmd.exe -d "C:\Windows\Prefetch" --csv "C:\Output"
Produces a readable timeline directly from Prefetch — how many times, and when, a program was run.

8. SBECmd (Shellbags parsing)

SBECmd.exe -d "C:\Users\<user>\NTUSER.DAT" --csv "C:\Output"

9. SrumECmd (SRUM database parsing)

SrumECmd.exe -f "C:\Windows\System32\sru\SRUDB.dat" --csv "C:\Output"
Extracts each program's network/CPU usage history, even after it's been uninstalled.

10. EvtxECmd (Event Log parsing — makes filtering much easier)

EvtxECmd.exe -f "C:\Windows\System32\winevt\Logs\Security.evtx" --csv "C:\Output"

Practical Workflow

To build a timeline from all the outputs gathered in one place, use Timeline Explorer (bundled with EZ Tools) to open all the CSVs together and sort by date/time — this produces a single timeline of the entire PC's activity.

⚠️ Important notes
  • All commands require Administrator privilege, because $MFT, the SYSTEM hive, and SRUDB.dat can't be opened with normal user access — the system locks them while running.
  • C:\Windows\System32\config\SYSTEM and NTUSER.DAT can't be opened directly while the system is running — either copy them from a Volume Shadow Copy, or export them first using the reg save command:
reg save HKLM\SYSTEM C:\Output\SYSTEM_copy
reg save HKCU C:\Output\NTUSER_copy

Then parse that copied file instead.

With these CLI commands, all the manual registry/journal/prefetch checks from earlier can now be produced as automated, readable CSV reports.
D

Advanced — Kernel Forensics & ETW

TOOL-ASSISTED / EXPERT LEVEL

D1 Anti-Cheat Investigation Guide — How to Perform Each Check

This guide explains, step by step, how to carry out each of the checks discussed, using standard forensic and system-administration tools.

1. Kernel / Driver-Level Checks

Check signed vs unsigned drivers — Open PowerShell as Administrator and run:

driverquery /v /fo csv | ConvertFrom-Csv | Export-Csv drivers.csv

Cross-check driver publishers using sigcheck (Sysinternals):

sigcheck64.exe -u -e C:\Windows\System32\drivers

Compare certificate issuers against a list of known cheat-provider or leaked certificates (community-maintained blocklists exist for this).

Check MiniFilter drivers

fltmc filters
fltmc instances

Look for filter names that aren't part of standard Windows/AV filters (unexpected file-system hooks).

Check for BYOVD (Bring Your Own Vulnerable Driver)

  • Compare the loaded driver list against known-vulnerable driver hash databases (e.g., the LOLDrivers project lists these).
  • Look for old/unusual utility or AV drivers loaded that don't match anything the user says they've installed.

2. Boot-Level Checks

Secure Boot / Test Signing status

bcdedit /enum
Confirm-SecureBootUEFI

If testsigning is Yes or Secure Boot is disabled, that's a red flag — many kernel-mode cheats require this to load unsigned drivers.

Boot log check — Enable boot logging temporarily (bcdedit /set {current} bootlog yes) and review C:\Windows\ntbtlog.txt after reboot for unexpected driver loads.

3. Virtualization / Isolation Evasion

Detect VM/hypervisor

systeminfo | findstr /i "hyper-v virtual"
wmic computersystem get model,manufacturer

Use Get-CimInstance Win32_ComputerSystem and check for VM-typical vendor names (VMware, VirtualBox, QEMU).

Check for HWID spoofers running at hypervisor level — Check for hypervisor presence even on "bare metal" claims: systeminfo shows "A hypervisor has been detected" if a nested/hidden hypervisor layer is active.

4. File Signature / Hash Level

Hash all suspicious files

Get-FileHash -Algorithm SHA256 "C:\path\to\file.exe"

Cross-check hashes against VirusTotal and community cheat-hash databases (VT alone often misses private/FUD cheats).

Entropy / packing analysis — Use a tool like Detect It Easy (DIE) or PEiD to check entropy and detect packers/obfuscation on suspicious executables. High entropy (close to 8.0) usually indicates packing.

5. Additional Sysmon Event IDs to Review

After Sysmon is installed, configure it with a solid ruleset (e.g., SwiftOnSecurity's sysmon-config) and review these Event IDs in Event Viewer under Applications and Services Logs > Microsoft > Windows > Sysmon > Operational:

Event IDMeaning / What to look for
1 — Process CreateCheck command-line arguments for suspicious flags or unusual parent-child process relationships.
7 — Image LoadedCheck for unexpected DLLs loading into the game's process.
8 — CreateRemoteThreadA classic sign of DLL injection into another process.
10 — ProcessAccessShows which processes opened handles to the game process — external cheats reading/writing memory will show up here.
11 — FileCreateLook for new files created around the reported gameplay time.
13 — RegistryEventLook for registry writes matching known cheat persistence locations (Run keys, services, etc.).

Export these logs and feed the relevant entries into Claude for pattern analysis, same as your existing step 9.

6. Communication Traces

Discord cache check — Discord's local cache is at:

%AppData%\discord\Cache
%AppData%\discord\Local Storage\leveldb

These can be parsed with a leveldb viewer to recover cached messages/images, which may reveal cheat-seller conversations or purchase confirmations. (Only pursue this with appropriate authorization/consent given privacy implications.)

7. Power / Sleep Artifacts

Hibernation file — Located at C:\hiberfil.sys (hidden system file). Requires a memory-forensics tool (e.g., Volatility with the imagecopy/hibernation plugin) to convert and analyze — it can contain memory remnants from before a shutdown.

Pagefile analysis — Located at C:\pagefile.sys. Use strings.exe (Sysinternals) or a hex viewer to search for cheat process names or strings:

strings64.exe -accepteula C:\pagefile.sys | findstr /i "cheatname"

8. Alternate Data Streams (ADS)

Check suspicious files for hidden ADS payloads:

Get-Item -Path "C:\path\to\file.exe" -Stream *

Any stream other than :$DATA is worth investigating further.

9. Environment Variables / PATH

Get-ChildItem Env:

Look for unusual entries added to PATH or custom variables that point to unexpected folders (common for loader scripts).

Practical Notes

  • Order of operations matters: volatile evidence (running processes, memory, network connections) should be captured before less volatile evidence (registry, files, logs), to avoid losing data.
  • Document everything: screenshot or log the output of each command as you go, since your workflow already requires screenshots for the initial Claude analysis step.
  • Chain of custody: if this investigation could lead to a formal ban or dispute, keep a clear record of who ran which check and when, since results may need to be defended if challenged.
  • Tool legitimacy: Volatility, Sysmon, Process Hacker, FTK Imager, Hayabusa, sigcheck, and strings.exe are all legitimate, publicly available forensic/sysadmin tools — no need to source anything from unofficial channels.

D2 Kernel-Level Driver Forensics & ETW Tracing

Why this matters

Advanced cheats — especially ones aiming to bypass kernel-level anti-cheat systems like Vanguard/BattlEye — load themselves as a kernel driver. These aren't caught by normal user-level process scans (PE-sieve, Task Manager), because they operate at the OS's most trusted layer.

1. Driver Signature Enforcement Check

driverquery /v /fo LIST

The output shows each driver's "Link Date" and path. Note anything where the path is outside C:\Windows\System32\drivers\, was installed recently (a Link Date close to now), or has an unfamiliar name (not a game/anti-cheat driver).

To specifically find unsigned drivers:

sigverif
A built-in Windows GUI tool. It scans and produces a list of all signed/unsigned drivers (also saved as a log file named sigverif.txt, usually near %windir%\Logs\CBS\ or in the user profile).

2. Test Signing Mode Check

(often required to load a custom driver)

bcdedit /enum | findstr "testsigning"
If testsigning shows Yes, it means unsigned custom-driver loading mode is turned on for this PC — that's itself a major red flag, since a normal user never turns this on; only developers or custom-driver users do (many kernel cheats turn this on themselves).

3. ETW (Event Tracing for Windows) — Concept

ETW is Windows' low-level logging framework, capable of capturing kernel- and driver-level events — going deeper than anything visible from user-mode.

Simple check (built-in, GUI):

perfmon /rel
This opens Reliability Monitor, which shows a timeline of system crashes, driver failures, and hardware events. If an unknown driver crashed or loaded, a trace may appear here.

Advanced ETW session capture (built-in, but analysis needs a tool):

logman query providers | findstr -i "kernel"
Shows which kernel-level ETW providers exist on the system. To actually capture a trace at this level, you'd need to start a session with logman start and then analyze it with Windows Performance Analyzer (WPA) or WinDbg — at this point it genuinely stops being a "quick check".

4. Kernel Driver List — a simpler manual alternative (Autoruns' Driver tab)

Autoruns (Sysinternals, portable, no install needed) has a "Drivers" tab showing every loaded kernel driver, along with: publisher/signature status (color-coded — unsigned ones are highlighted), file path, and a direct option to check it on VirusTotal.

In practice, this is the most practical approach — far more so than learning raw ETW/WinDbg.

D3 Advanced — How to Read PE-sieve Output

What happens after running the command

pe-sieve64.exe /pid <game_process_PID>

After the scan finishes you get two things: (1) console output (a summary, visible right away) and (2) a folder created (named after the process plus its PID), containing suspicious/dumped modules saved for further analysis.

Console output — key parts

[*] PID: 1234, using EXE: game.exe
[*] Scanning...
Total scanned:        45
Skipped:               0
---
Hooked:                0
Replaced:              0
Hdrs Modified:         0
IAT Hooked:             0
Implanted:              1
Implanted PE:            1
Implanted shc:           0
Unreachable files:      0
Other:                   0
---
Total suspicious:       1

What each field means

FieldMeaningWhy it's suspicious
Total scannedHow many modules were scanned in the processJust context, not suspicious by itself
HookedThe start of a function was altered to jump elsewhereCheats often hook game functions to read or alter data (aimbot, ESP)
ReplacedA whole module was replaced with different codeA legitimate DLL swapped out for a malicious one
Hdrs ModifiedThe PE header was manually altered (to evade detection)Cheats corrupt/alter header info to make themselves "invisible"
IAT HookedThe Import Address Table was hooked (redirecting which function gets called)A very common injection/hooking technique
ImplantedA memory region that isn't mapped to any file on diskThe classic signature of manual-mapped DLL injection — the cheat was loaded straight into RAM instead of existing as a file on disk (the single most important finding)
Implanted PEThe implanted region is in full PE (executable) formatDirectly means a complete executable/DLL that doesn't exist on disk is running here
Implanted shcShellcode (raw machine code, not PE format) was implantedAn even stealthier injection technique
Unreachable filesThe disk file tied to a module is no longer accessible (deleted)A pattern of deleting the file at runtime to erase traces
The single most important line: Total suspicious: 1 — a value of 0 is normal, no cheat detected. 1 or higher means something injected/hooked/modified was found in that process — this is the main indicator.

What's in the output folder

After scanning, a folder is created (e.g. process_1234), containing:

  • The dumped .dll/.exe file of the suspicious module (extracted from RAM and saved to disk)
  • A .tag file or report with the exact address details of what was found
  • This dumped file can be uploaded to VirusTotal or statically analyzed for further confirmation

Simple decision rule

ResultMeaning
Total suspicious: 0Clean — no injection found (at this scan's time)
Implanted PE: 1+The strongest evidence — an unknown executable is running directly in RAM, very likely a cheat
Hooked or IAT Hooked counts highFunction hooking occurred — interference with game logic (could be overlay/ESP/aimbot-type)
Unreachable filesA file used at runtime and then deleted from disk — a pattern of evidence cleanup
⚠️ Limitations to keep in mind
  • PE-sieve only works on the process scanned at that exact moment — if the cheat is closed/unloaded before the scan, nothing will be found.
  • Some legitimate anti-cheat/overlay software (e.g. Discord overlay, RTSS, streaming software) also uses hooking — so a Total suspicious: 1 result shouldn't be assumed to be a "cheat" outright; the dumped file needs to be analyzed to confirm.
  • This is most effective when scanned while the game process is running (during the match) — scanning after it has closed will find nothing.
E

Part 4 (Truly Final) — Last Additions

MIXED MANUAL / GUI

19 Anti-Cheat Software's Own Log (game-specific)

Many games' own anti-cheat systems (EasyAntiCheat, BattlEye, Vanguard) keep a local log:

C:\Program Files\EasyAntiCheat\
C:\ProgramData\EasyAntiCheat\
C:\Program Files (x86)\Steam\logs\
A game's official anti-cheat log often records its own flag/kick reason, which can be checked directly.

20 Bluetooth/HID Device Pairing History (Hardware cheat devices like Cronus)

HKLM\SYSTEM\CurrentControlSet\Enum\HID
HKLM\SYSTEM\CurrentControlSet\Enum\BTHENUM
Check whether any unknown HID device (e.g. Cronus Zen, XIM) was ever connected.

21 GPU Overlay Tools Check (Overlay-based cheats)

Task Manager > Details > look for any RTSS.exe, MSI Afterburner, or unknown overlay process

Cheats that render ESP/wallhacks via a screen overlay often hide themselves under a legitimate overlay tool's name (like RTSS).

22 Windows Sandbox / Virtual Machine Check

Control Panel > Programs > Turn Windows features on or off

This is used to check whether someone is running a cheat inside Windows Sandbox/a VM to avoid leaving a trace on the main system.

23 Autoruns (Sysinternals — technically a tool, but portable, no install needed)

This is technically outside the "no tool" list, but worth mentioning: running Autoruns.exe (Microsoft's own Sysinternals suite) shows Registry + Startup + Scheduled Tasks + Drivers + Services — everything in one place, integrating everything we did manually and separately up to this point. It falls outside the pure "no tool" list, but leaving it out would make this incomplete.

F

Screenshot Analysis — Standard Operating Procedure

ANALYST PROTOCOL

SOP Anti-Cheat Analyst Protocol

Role: an esports tournament anti-cheat analyst assisting a human tournament official, reviewing screenshots taken from a player's PC during an in-person or remote cheat-check (Task Manager, running processes, installed programs, browser history, file explorer, config files, in-game settings, overlays, peripherals, etc.). For each screenshot or batch of screenshots, the workflow is:

1. Describe

Describe what is visible factually (processes, program names, file names, settings, anything visible) — no assumptions yet.

2. Flag & Classify

Flag anything suspicious and classify each flagged item into one of these categories:

  • Known cheat/hack software or injector (named if recognizable)
  • Process injection / DLL injection indicators
  • Macro or script automation tools (e.g. AHK, third-party macro engines)
  • Unauthorized overlay or capture/injection tools
  • Config files or registry entries associated with cheat tools
  • Suspicious file names, hidden/renamed executables, recently deleted items
  • Hardware-based cheat devices (e.g. Cronus, programmable mice/keyboards) if visible
  • Anything unclear that could be a false positive (common software misidentified as a cheat)

3. Confidence Rating

RatingMeaning
CONFIRMEDClearly identifiable cheat tool/signature
HIGHLY SUSPICIOUSStrong indicators, needs verification
WORTH CHECKINGAmbiguous, could be legitimate software
LIKELY FALSE POSITIVECommon/benign tool, unlikely to be a cheat

4. Recommend Next Steps

What the official should additionally check to confirm or rule out cheating — e.g. checking installation timestamp of a file, whether a process was running during the match, asking the player to explain a file, checking browser download history, cross-checking with known cheat signature databases, checking hidden folders/AppData, etc.

5. Recommended Severity Tier

No final punishment decision is made by the analyst — only a recommended tier, based solely on findings from the screenshots (final decision is always human-made):

TierDescription
Tier 0No action — insufficient/no evidence
Tier 1Warning / Monitor — ambiguous evidence, needs more checking
Tier 2Temporary suspension pending investigation — highly suspicious, not fully confirmed
Tier 3Disqualification from current tournament — confirmed cheat tool present, but first offense / limited-use evidence
Tier 4Disqualification + Ban — confirmed, clear intent, repeat offender, or tool actively used during competitive play

6. Facts vs. Inference

Reasoning for the suggested tier must be stated explicitly, clearly separating FACTS (what's visibly in the screenshot) from INFERENCE (interpretation).

7. Weak or Unclear Evidence

If evidence is weak or the screenshot is unclear/low quality, this is stated explicitly, and a clearer screenshot or additional angle is requested instead of guessing.

IMPORTANT — Decision-support only. The analyst is a decision-support tool, not the final judge. Punishment decisions must be confirmed by a human based on tournament rules, additional investigation, and the player's right to explain/respond before any final action.
G

Appendix — Scripts

POWERSHELL

PS1 Check-UnsignedDLLs.ps1

Detects unsigned or invalid-signature DLLs loaded by a running process.

ParameterDescription
-ProcessNameName of the process (without .exe), e.g. "notepad"
-ContinuousIf set, keeps monitoring every few seconds for newly loaded modules
-IntervalSecondsPolling interval in seconds when -Continuous is used (default 5)

Example usage:

.\Check-UnsignedDLLs.ps1 -ProcessName "myapp"
<#
.SYNOPSIS
    Detects unsigned or invalid-signature DLLs loaded by a running process.

.PARAMETER ProcessName
    Name of the process (without .exe), e.g. "notepad"

.PARAMETER Continuous
    If set, keeps monitoring every few seconds for newly loaded modules.

.EXAMPLE
    .\Check-UnsignedDLLs.ps1 -ProcessName "myapp"
#>

param(
    [Parameter(Mandatory = $true)]
    [string]$ProcessName,

    [switch]$Continuous,

    [int]$IntervalSeconds = 5
)

function Check-ProcessModules {
    param([string]$Name)

    $procs = Get-Process -Name $Name -ErrorAction SilentlyContinue

    if (-not $procs) {
        Write-Warning "Process '$Name' not found running."
        return
    }

    foreach ($proc in $procs) {
        Write-Host "`n=== PID: $($proc.Id) | Process: $($proc.ProcessName) ===" -ForegroundColor Cyan

        try {
            $modules = $proc.Modules
        }
        catch {
            Write-Warning "PID $($proc.Id) - could not read modules (may be a permission issue). Try running as Administrator."
            continue
        }

        foreach ($mod in $modules) {
            $path = $mod.FileName
            if (-not $path) { continue }

            try {
                $sig = Get-AuthenticodeSignature -FilePath $path -ErrorAction Stop

                switch ($sig.Status) {
                    "Valid" {
                        # Signed & valid - skip/optionally show
                        # Write-Host "[OK] $path" -ForegroundColor Green
                    }
                    "NotSigned" {
                        Write-Host "[UNSIGNED] $path" -ForegroundColor Red
                    }
                    default {
                        Write-Host "[SUSPECT: $($sig.Status)] $path" -ForegroundColor Yellow
                        if ($sig.SignerCertificate) {
                            Write-Host "    Signer: $($sig.SignerCertificate.Subject)" -ForegroundColor DarkYellow
                        }
                    }
                }
            }
            catch {
                Write-Host "[ERROR reading signature] $path - $($_.Exception.Message)" -ForegroundColor DarkRed
            }
        }
    }
}

if ($Continuous) {
    Write-Host "Starting continuous monitoring ($IntervalSeconds sec interval). Press Ctrl+C to stop." -ForegroundColor Magenta
    while ($true) {
        Check-ProcessModules -Name $ProcessName
        Start-Sleep -Seconds $IntervalSeconds
    }
}
else {
    Check-ProcessModules -Name $ProcessName
}
↑ Back to top