Compare commits

...
1 Commits
Author SHA1 Message Date
poli0981andClaude Opus 5.5 1360fd3409 feat(guard): check 3 is live in both halves and seeded; any kernel driver in a game's folder is a finding; the pre-scan sees the install root
beta.8 PR-2, the owner's strictness decisions of 2026-09-25 (HANDOFF D30, D31).

- Check 3's store half: Sources::StoreIdentity reads the store's own metadata from the install root the guard
  derives itself - the Steam library's appmanifest_*.acf whose installdir is the game's folder, or a GOG
  goggame-<id>.info - so no caller hands in evidence (S3) and nothing is read from the game (rule 4). Matrix: listed
  refuses (BlockedStoreId); no store identity is not refused; unreadable store metadata refuses (PreScanFailed).
- rules 2026.09.4 seeds both per-title lists - 30 Steam app ids, 33 executables across nine families (VAC titles,
  Riot, Roblox, Blizzard, Call of Duty, NetEase, ACE, HoYoverse, EA) - and floors them like the families, so data
  can add a title and never remove one. kMaxTitleRules 64 -> 128 (the floor doubles the worst case). rules-validate
  refuses generic executable names, exact rules without .exe, and duplicates, and checks the 2x capacity.
- The kernel-driver rule: a *.sys file in the install tree that no files entry names is AntiCheatFile under
  "Kernel driver in the game folder". Code, not data; a named entry (randgrid.sys) keeps its own family.
- FlStaticPreScan(gameDirectory) -> FlStaticPreScanGame(exePath), and IAntiCheatGuard.PreScanGameDirectoryAsync ->
  PreScanGameAsync(executablePath): SetHookEnabled passed the exe's own folder and the guard scanned exactly that, so
  an Unreal title's root-level EasyAntiCheat folder was never seen by the enable-time scan. The guard now resolves
  the install root itself and runs check 3 there too. The port keeps four methods.

Tests: native fakes gain the store seam; new cases for the store matrix, the driver rule, the root resolution and
check 3 in the advisory scan; the real seam against a Steam library and a GOG folder built in %TEMP%; the floor
reproduction and the minimal-file test cover the title lists.
Docs: 19_SAFETY checks 3 and 4, the VAC row; 20_OPEN_QUESTIONS S14 closed and the S24 count; 05_DETECTION; HANDOFF
D30/D31 and traps; CHANGELOG.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 20:46:35 +07:00
31 changed files with 1072 additions and 163 deletions

No files matched your search

+21
View File
@@ -40,6 +40,22 @@ under a `## [x.y.z] - date` heading in the same commit that bumps `VERSION`, the
support pages, LOLDrivers, DRML — and none is measured on a real title yet; each entry's `note` says which. Three
services are deliberately left out because they run outside play and would refuse every session on the machine:
`EAAntiCheatService`, PunkBuster's `PnkBstrA`, and Denuvo's update service.
- **Check 3 is live in both halves, and the per-title lists are seeded** (rules `2026.09.4`, owner decision
2026-09-25). The store half reads the store's own files through a seam the guard owns — `appmanifest_*.acf` in the
Steam library that holds the game, `goggame-<id>.info` for GOG — so nothing is handed in by a caller and nothing is
read from the game. 30 Steam app ids and 33 executable names across nine families are listed: Valve's VAC titles
(CS2, Dota 2, TF2, Deadlock and the older ones), VALORANT and League of Legends, Roblox, Blizzard's online titles,
Call of Duty, Marvel Rivals, NARAKA, FragPunk, Once Human, Delta Force, Arena Breakout: Infinite, HoYoverse's games,
Battlefield 2042/6 and EA SPORTS FC 25/26 — the titles whose anti-cheat leaves nothing of the game's own for the
other checks to find. A game no store names is not refused by this half; a Steam library whose manifests cannot be
read is. Both lists are floored like the families, so a rules file can add a title and never take one off, and the
validator refuses names engines share (`Game.exe`, `Client-Win64-Shipping.exe`…). The AreWeAntiCheatYet bulk list was
considered and declined: community data that outlives a game's anti-cheat would turn hooking off for good.
- **Any kernel driver in a game's folder counts as anti-cheat** (owner decision 2026-09-25). A `*.sys` file in the
install tree that no rule names is reported as "Kernel driver in the game folder" and turns that game's hooking off,
like any finding. Every driver found in a game so far was an anti-cheat's; this catches the next one before anyone
names it. It is code, so no rules file can remove it — and a game that ships a driver for another reason loses
hooking with no way back, which is the trade the owner took.
- **The guard holds 256 blocklist entries instead of 64** (2 × 74 no longer fitted the worst case of the compiled-in
floor plus a drifted file). The parsed rules are ~530 KB, so they are now reset in place instead of being copied from
a temporary: the Vulkan layer parses them on whichever of a game's threads creates its Vulkan instance, and a
@@ -47,6 +63,11 @@ under a `## [x.y.z] - date` heading in the same commit that bumps `VERSION`, the
### Fixed
- **Turning hooking on for an Unreal game now sees its `EasyAntiCheat` folder.** The scan that runs when hooking is
enabled was given the executable's own folder — `<game>\<Project>\Binaries\Win64\` for Unreal titles — and scanned
exactly that, while `EasyAntiCheat\` sits at the game's root. The session-time scan always looked at the root, so no
injection was ever allowed by the gap, but the toggle could be switched on and the refusal came only at launch. The
guard now takes the executable and finds the root itself, and also checks the executable's name and its store id.
- **19_SAFETY's fixture rule is enforced for every family, not eleven.** A generated test walks every value of the
shipped seed and requires it to match its own family in its own group — which also catches a later row that an
earlier prefix shadows. The rules file's note that called XIGNCODE3's `x3.xem` "not a loadable module" is corrected:
+1 -1
View File
@@ -261,7 +261,7 @@ The UI wording is deliberate: **"Supports DLSS-G"** (capability, from files) ver
Before a game is ever launched with hooking enabled, the static scan checks for anti-cheat SDKs shipped alongside it (`EasyAntiCheat/` directory, BattlEye binaries, EOS anti-cheat components, etc.). A hit **disables the hooking toggle for that game entirely** in the UI, with an explanation — the user cannot enable it, so the guard never even has to fire at launch. Prevention beats interception.
**Implemented in the native guard, not here** (`fl_prescan.cpp`, exposed as `FlStaticPreScan`). It uses the same `MatchName` and the same rules file as the injection guard, matching directory names against the `anticheat.directories` group and file names against `anticheat.files`. Nothing managed matches a blocklist (§S15 item 1).
**Implemented in the native guard, not here** (`fl_prescan.cpp`, exposed as ~~`FlStaticPreScan`~~ `FlStaticPreScanGame` since 2026-09-25, which takes the executable, resolves the install root itself and runs check 3 as well). It uses the same `MatchName` and the same rules file as the injection guard, matching directory names against the `anticheat.directories` group and file names against `anticheat.files`. Nothing managed matches a blocklist (§S15 item 1).
Three things this section previously implied that are not true, and are worth stating:
+47 -1
View File
@@ -220,6 +220,35 @@ Implemented in `FrameLedger.Injector` and reached from managed code through a th
> never as *clean*. `20_OPEN_QUESTIONS` §S7 tracks the remaining work.
3. **Rules blocklist** — `detection-rules.json` carries `anticheat.blockedExecutables` (exe names) and `anticheat.blockedStoreIds` (Steam appids etc.) for known competitive/online titles, updatable independently of app releases (`05_DETECTION` §Rules updates).
> **Both halves are wired and seeded since 2026-09-25** (owner: "as many and as strict as possible"; rules
> `2026.09.4`). The block below is the history it replaces, kept for the reasoning.
>
> **The store half reads the store's own files, through a seam the guard owns.** `Sources::StoreIdentity` takes the
> install root the guard already derives from the pid (check 4's `ImageDirectory`) and answers from disk: under
> `<library>\steamapps\common\<folder>`, the one `appmanifest_<id>.acf` whose `installdir` is `<folder>` →
> `steam:<id>`; a `goggame-<id>.info` in the root → `gog:<id>`. Nothing is handed in by a caller (§S3 is untouched —
> the ABI still takes a pid and nothing else) and nothing is read from the game's process (rule 4).
>
> **The matrix §S14 asked for:** a listed identity refuses (`BlockedStoreId`, naming the family); an install no store
> names — a loose folder, a GOG-less, manifest-less copy — is **not** refused, because "no store identity" is an
> answer, not an unknown, and refusing it would be the gate that cannot pass; a store layout whose metadata could not
> be read (a manifest that will not open, more than 4096 of them, a listing error) refuses as `PreScanFailed`. With
> nothing listed, nothing is read. Epic has no reader: an Epic install carries no identity to this check.
>
> **What is listed, and why a title list at all:** 30 Steam app ids and 33 executable names across nine families —
> Valve VAC (CS2, Dota 2, TF2, Deadlock and Valve's older VAC titles), Riot Vanguard, Roblox Hyperion, Blizzard's
> online titles ("Blizzard Warden"), Call of Duty (Activision Ricochet), NetEase (Marvel Rivals, NARAKA, FragPunk,
> Once Human), ACE (Delta Force, Arena Breakout: Infinite), HoYoverse and EA (Battlefield 2042/6, EA SPORTS FC 25/26).
> These are the titles whose anti-cheat leaves nothing of the game's own for checks 1, 2 and 4 to find — VAC runs
> inside Steam, Blizzard's scanner is built into the game — or whose kernel driver loads only after the checks run.
> Every app id was checked against its Steam store page; Call of Duty's changed when Activision split CoD HQ, so only
> ids with a live store page are listed. The per-title lists are **floored** like the families: a rules file can
> add a title and cannot take one off. `rules-validate` refuses a name engines and tools share (`Game.exe`,
> `Client-Win64-Shipping.exe`, `hl2.exe`…), an exact rule that names no `.exe`, and duplicates.
>
> **The owner declined the bulk list** (AreWeAntiCheatYet's ~250 Steam ids): community data that keeps listing a game
> after it drops its anti-cheat would turn hooking off for good on a title that no longer needs it.
> ⚠ **◐ The EXECUTABLE half is wired as of 2026-08-05; the STORE-ID half is
> blocked.** `CheckBlockedExecutable` runs inside `EvaluateImpl` between the
> module scan and the pre-scan, and an unresolvable identity refuses with
@@ -250,6 +279,23 @@ Implemented in `FrameLedger.Injector` and reached from managed code through a th
> rules file — and therefore every title on the machine (§S17).
4. **Multiplayer heuristic** — if the pre-launch file scan finds an anti-cheat SDK shipped alongside the game (e.g. EOS anti-cheat binaries, `EasyAntiCheat/` directory) even when not currently loaded → refuse and explain.
> **Any kernel driver in the install tree counts, since 2026-09-25 (owner decision).** A `*.sys` file that no
> `files` entry names is reported as `AntiCheatFile` under the family **"Kernel driver in the game folder"**. Every
> driver this project has found shipped inside a game — `PGameProtectDriver_X64.sys`, `randgrid.sys`,
> `NeacSafe64.sys`, `BlackCat64.sys`, `mhyprot*.sys` — was an anti-cheat's, and naming each one in data first is how
> the next one walks past, as ACE's did in August. The rule is **code, not data** (`fl_prescan.cpp`,
> `kKernelDriverInTreeFamily`): no rules file can remove it or rename its family. A named `files` entry still wins,
> so `randgrid.sys` reads as Activision Ricochet. **The cost the owner accepted:** a game that ships a driver for
> some other purpose (a wheel, a peripheral, an old disc check) has its hooking turned off like any finding, and
> nothing clears it.
>
> **The advisory pre-scan takes the executable and resolves the install root itself, since 2026-09-25.**
> `FlStaticPreScan(gameDirectory)` scanned the directory it was handed, and its one caller (`SetHookEnabled`) handed
> it the executable's own folder — so for an Unreal title, the scan that decides whether hooking may be turned on
> looked at `<root>\<Project>\Binaries\Win64\`, exactly where the Lies of P measurement below says `EasyAntiCheat/`
> is not. The chokepoint always resolved the root. `FlStaticPreScanGame(exePath)` replaces it: the same
> `ResolveInstallRoot`, plus check 3 on the executable's name and the install's store identity.
> **Implemented, and stated narrowly.** `fl_prescan.cpp` walks the target's
> own directory (derived from its pid, never from a caller-supplied path) to
> **depth 3** — raised from 2 on 2026-08-04 (§S22, `spike-notes.md` §13), because a
@@ -541,7 +587,7 @@ normative documentation. Write tokens here exactly as the data must hold them.
| Activision Ricochet | `services` | name | `atvi-randgrid_sr`, `atvi-randgrid_msstore` | 2026-09-25 |
| Activision Ricochet | `files` | name | `randgrid.sys` | 2026-09-25 |
| FredaikisAntiCheat | `directories` | name | `FredaikisAntiCheat` | 2026-09-25 |
| **Valve VAC** | — | — | **No data yet** — needs `blockedStoreIds`, whose half of check 3 **cannot be called** (§S14; the executable half was wired in #52, but a renamed exe defeats it anyway, which is why this row reserves the store-id route). **Measured 2026-08-04: a real VAC title returns `Allow`** (`spike-notes.md` §13) | — |
| **Valve VAC** | — | — | ~~**No data yet** — needs `blockedStoreIds`, whose half of check 3 **cannot be called**~~ **Per-title lists since 2026-09-25** (check 3): 13 Steam app ids and 8 executables, the store half wired. VAC runs inside Steam, so no module, driver or file of the game's own can name it — this row stays a dash on purpose. (**Measured 2026-08-04: a real VAC title returned `Allow`**, `spike-notes.md` §13 — the gap these lists close.) | 2026-09-25 |
The "no data yet" rows are deliberately kept rather than deleted. An admitted
gap is reviewable; a deleted row is invisible. ~~Activision Ricochet's was one of them~~ — it has data since
+13 -2
View File
@@ -94,7 +94,7 @@ or it becomes the next stale status claim this file exists to record.
| **S1** | ◐ **launch mode built as "inject late" 2026-09-06 (P1 item 2); the cost is now measured per title** | `FlGuardedInjectWhenReady` polls until a presentation runtime is mapped, then runs the full guard; `dxgiPresentsBeforeHook` and the reported wait are the input the 2026-08-05 deferral lacked. The ruling "inject late vs. no launch mode" is answered by construction — inject late exists — and whether it is *preferred* per title is what the numbers decide |
| **S13(c)** | ✅ **salvageable, and salvaged 2026-09-06** | The externally observable proxy the entry proposed is what was built; the missing input is produced by every launched session |
| **S19(b)** | 🅓 **deferred, rationale written — and MEASURED** | CI 2026-08-05: the fragment fires on `System.Security.Cryptography.ProtectedData.dll` loaded by a .NET **test host**, i.e. inside a real scan set in the launch-mode arrangement — refusing our own injection. The entry's "plausible and unmeasured" is superseded; the deferral rationale (a `CryptCATAdmin*` PR doing network I/O inside the hard gate, NFR-10) still stands. *(Marked 🔴 until 2026-08-27. The measurement belongs in this cell, not in the marker — a glyph that means "deferred" and a glyph that means "open defect" cannot be the same one in a table audited by counting.)* |
| **S14** | 🅓 **exe half wired 2026-08-05; store-id half deferred to P4, rationale written 2026-09-06** | The store-id half's only in-policy route is P4's platform metadata extractors feeding a guard-side resolver; a resolver with no extractor would refuse every title. No title is blocked by store id today because none is listed |
| **S14** | ✅ **both halves wired and seeded 2026-09-25** (exe half 2026-08-05) | ~~The store-id half's only in-policy route is P4's platform metadata extractors feeding a guard-side resolver~~ — built as a guard-side seam that reads Steam's `appmanifest_*.acf` and GOG's `goggame-<id>.info` itself; an install no store names is not refused, unreadable store metadata is. 30 Steam ids and 33 executables listed (rules 2026.09.4), floored. Epic has no reader |
| **S23-1** | ✅ **resolved 2026-08-05** | `FlGuardBuildId` gives the Agent a build id of its own, and `ShmHandshakeValidator` performs the comparison `07_IPC` and `04_CAPTURE` both specify. Every refusal path is driven, including **both ids empty** — the shape the feature shipped in, where `"" == ""` reported `Ok` for every process on the machine |
| **S23-4** | ✅ **resolved 2026-08-05** | `19_SAFETY` §During a session said "the module scan and the driver scan"; `EvaluateImpl` runs four. Reworded to "every pre-injection check" so it cannot go stale when a check is added, with the two omissions named — `services` is the only tier measured firing on real anti-cheat, and the pre-scan is the only one touching the filesystem |
| **S2 part three** | ✅ **built 2026-09-06 (P1 item 3)** | In-layer supervision on the present path, landed with `vkQueuePresentKHR`; `unhookRequested` and the tick deadline both stop the layer (passthrough with the reason on the mapping), proven by a fake loader chain and a 1.5 s test-only flavour of the DLL |
@@ -171,6 +171,10 @@ the recount becomes the next thing that needs recounting.
> as ◐ two here rather than re-glyphing the rows: the rows were right and the paragraph was
> wrong, and the residue of each is a run, not a rationale. P2's sequencing is `HANDOFF` §P2.
>
> **2026-09-25: S14 ✅.** The store-id half, one of the six deferrals of 2026-09-06 (to P4), is built and seeded
> in the beta.8 train: a guard-side seam reads the store's own metadata, and the lists carry 30 Steam ids and 33
> executables. The deferred set is five; ◐ stays two (S1, H11); nothing else in this count moved.
>
> **STILL TEN on 2026-08-27, for the third consecutive movement.** S31 moved from ❓ to ◐,
> so ❓ goes four to three and ◐ goes two to three. **The number has now stayed at ten across
> three different changes**, and that is worth saying out loud precisely because a reader
@@ -3160,7 +3164,14 @@ gate.
> and the block's own comment says so. The block was rewritten to 2026-09-06 truth in the same
> PR (the previous §4 note still said frame generation and ray tracing had no hook).
### S14 ◐ · Pre-injection check 3 is **unwired**, and has no "cannot determine" state
### S14 ✅ · Pre-injection check 3 ~~is **unwired**, and has no "cannot determine" state~~ — both halves wired and seeded 2026-09-25
> **Closed 2026-09-25 (beta.8, owner decision: title lists yes, the AreWeAntiCheatYet bulk list no).** The store
> half reads the store's own metadata through `Sources::StoreIdentity`, from the install root the guard derives
> from the pid — the ABI is unchanged, which was reason (2). Reason (3) is answered by the matrix in `19_SAFETY`
> check 3: listed refuses, no store identity is not applicable, unreadable store metadata refuses. Both lists are
> seeded (30 Steam ids, 33 executables) and floored. What stays open is Epic, which has no reader and so carries no
> identity to this check. The body below is the history.
Found 2026-08-02 while hardening the rules toolchain. `19_SAFETY` §Pre-injection
checks lists a per-title blocklist as check 3, but `anticheat.blockedExecutables`
+29
View File
@@ -1556,6 +1556,35 @@ và legal"), so the Legal Gate shows both once.
- **`SqliteGameRepository._columns` is read by ordinal** (`ReadMore`): a new column goes at the end of the list, and the
twin merge reads its own columns — both had to learn `record_sessions`.
## 2026-09-25 — the beta.8 train
*Status is `CHANGELOG.md` `[Unreleased]` (then `[0.1.0-beta.8]`); this is what no other file carries. The owner's list
(eight items: the anti-cheat set as large and strict as possible, hiding the hook part for anti-cheat games, more
metadata, NVIDIA App overrides, clearer reasons, a working Trend, FPS decimals, chart fixes) is planned as nine PRs in
one approved plan; each PR cites it.*
**Decision (D30, owner, asked before any code: "which strict rules, beyond named tokens?").** Two of three: **any
kernel driver (`*.sys`) inside a game's install tree** is a finding (code, not data — `kKernelDriverInTreeFamily`),
and **per-title lists** (30 Steam ids, 33 executables across nine families, floored like the families). **Not** the
AreWeAntiCheatYet bulk import (~250 Steam ids): community data that keeps listing a game after it drops its anti-cheat
would turn hooking off for good, since nothing clears a block. Recorded because the next person to "expand the list"
will find that import one search away.
**Decision (D31, owner): the store half's matrix.** Listed → refuse; no store identity (a loose folder, an Epic
install, a Steam folder no manifest names) → not applicable, recorded as nothing; a store layout whose metadata cannot
be read → refuse (`PreScanFailed`). §S14's "unknown must never read clean" is kept by the third row; the second is not
an unknown — it is the answer "this is not a store title", and refusing it would be the gate that cannot pass.
**Traps.**
- **`Rules` is ~650 KB now** (256 families, 128 per-title rules). `x = Rules{}` builds that on the stack before
copying — use `ResetRules`. The Vulkan layer parses on a game's own `vkCreateInstance` thread, and native tests hold
it on the heap (two in one test function overflowed the 1 MB default).
- **New `anticheat.modules` rows go at the END.** The Overlay's early stop reports a 1-based index into that order, and
`sessions.early_stop_family` stores it.
- **`sed -i` and the Bash tool's heredocs strike again**: a heredoc halved `\\` in a Python patch (a C# verbatim path
still matched by luck), and a one-line `sed -i` turned `layer.cpp` into LF. Scripts go through the Write tool and run
by path; `git ls-files --eol -m` after any shell edit.
## Owner-only — no PR can close these
1. **§S23-2 — branch protection.** `Rules / validate` is not a required status check on
+57 -9
View File
@@ -20,12 +20,10 @@
"entries). Activision Ricochet was the other until 2026-09-25, when its",
"driver and services arrived from Activision's own support pages.",
"",
"PRE-INJECTION CHECK 3 MATCHES NOTHING, because `blockedExecutables` and",
"`blockedStoreIds` are both empty. That is a fact about THIS DATA, which is",
"why it is stated here; seeding the lists is a product decision (which",
"titles, and what an unresolvable store id means) tracked as",
"docs/20_OPEN_QUESTIONS.md §S14. Recorded rather than left to be inferred",
"from two empty arrays.",
"PRE-INJECTION CHECK 3 MATCHED NOTHING until 2026-09-25, because",
"`blockedExecutables` and `blockedStoreIds` were both empty. The owner seeded",
"them that day (rules 2026.09.4); what an unresolvable store id means is",
"the matrix in docs/19_SAFETY check 3 (docs/20_OPEN_QUESTIONS.md §S14).",
"",
"WHICH CHECKS RUN IS DELIBERATELY NOT STATED HERE ANY MORE. This comment used",
"to list them — a FOURTH restatement of the gate's composition, in the one",
@@ -42,7 +40,7 @@
"level, which made it a check that could not fire."
],
"schemaVersion": 2,
"rulesVersion": "2026.09.3",
"rulesVersion": "2026.09.4",
"engines": [
{
@@ -371,7 +369,57 @@
],
"action": "warn_and_refuse"
},
"blockedExecutables": [],
"blockedStoreIds": []
"blockedExecutables": [
{ "family": "Valve VAC", "match": "exact", "values": [ "cs2.exe", "csgo.exe", "dota2.exe", "tf_win64.exe", "deadlock.exe", "project8.exe", "left4dead2.exe", "gmod.exe" ],
"reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "family": "Riot Vanguard", "match": "exact", "values": [ "VALORANT-Win64-Shipping.exe", "League of Legends.exe" ],
"reason": "Protected by Riot Vanguard, a kernel anti-cheat that loads at boot." },
{ "family": "Roblox Hyperion", "match": "exact", "values": [ "RobloxPlayerBeta.exe" ],
"reason": "The Roblox player is protected by Hyperion anti-tamper." },
{ "family": "Blizzard Warden", "match": "exact", "values": [ "Overwatch.exe", "Diablo IV.exe", "Diablo III64.exe", "Wow.exe", "WowClassic.exe", "SC2_x64.exe", "HeroesOfTheStorm_x64.exe" ],
"reason": "An online Blizzard title: its anti-cheat is built into the game and ships no file of its own." },
{ "family": "Activision Ricochet", "match": "exact", "values": [ "cod.exe", "ModernWarfare.exe", "BlackOpsColdWar.exe" ],
"reason": "Call of Duty, protected by the RICOCHET kernel anti-cheat." },
{ "family": "NetEase Anti-Cheat", "match": "exact", "values": [ "Marvel-Win64-Shipping.exe", "NarakaBladepoint.exe" ],
"reason": "Protected by NetEase's kernel anti-cheat (NEAC)." },
{ "family": "Anti-Cheat Expert", "match": "exact", "values": [ "DeltaForceClient-Win64-Shipping.exe" ],
"reason": "Protected by Tencent Anti-Cheat Expert (ACE), a kernel anti-cheat." },
{ "family": "mihoyo protect", "match": "exact", "values": [ "GenshinImpact.exe", "YuanShen.exe", "StarRail.exe", "ZenlessZoneZero.exe", "BH3.exe" ],
"reason": "A HoYoverse title, protected by its kernel anti-cheat driver." },
{ "family": "EA AntiCheat", "match": "exact", "values": [ "bf2042.exe", "bf6.exe", "FC25.exe", "FC26.exe" ],
"reason": "Protected by EA AntiCheat (Javelin), a kernel anti-cheat." }
],
"blockedStoreIds": [
{ "store": "steam", "id": "730", "family": "Valve VAC", "reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "store": "steam", "id": "570", "family": "Valve VAC", "reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "store": "steam", "id": "440", "family": "Valve VAC", "reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "store": "steam", "id": "1422450", "family": "Valve VAC", "reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "store": "steam", "id": "240", "family": "Valve VAC", "reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "store": "steam", "id": "10", "family": "Valve VAC", "reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "store": "steam", "id": "80", "family": "Valve VAC", "reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "store": "steam", "id": "550", "family": "Valve VAC", "reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "store": "steam", "id": "500", "family": "Valve VAC", "reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "store": "steam", "id": "4000", "family": "Valve VAC", "reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "store": "steam", "id": "320", "family": "Valve VAC", "reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "store": "steam", "id": "300", "family": "Valve VAC", "reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "store": "steam", "id": "20", "family": "Valve VAC", "reason": "A VAC-secured online title. VAC runs inside Steam, so no file of the game's own names it." },
{ "store": "steam", "id": "1938090", "family": "Activision Ricochet", "reason": "Call of Duty, protected by the RICOCHET kernel anti-cheat." },
{ "store": "steam", "id": "1962663", "family": "Activision Ricochet", "reason": "Call of Duty, protected by the RICOCHET kernel anti-cheat." },
{ "store": "steam", "id": "3595270", "family": "Activision Ricochet", "reason": "Call of Duty, protected by the RICOCHET kernel anti-cheat." },
{ "store": "steam", "id": "4384550", "family": "Activision Ricochet", "reason": "Call of Duty, protected by the RICOCHET kernel anti-cheat." },
{ "store": "steam", "id": "2519060", "family": "Activision Ricochet", "reason": "Call of Duty, protected by the RICOCHET kernel anti-cheat." },
{ "store": "steam", "id": "2357570", "family": "Blizzard Warden", "reason": "An online Blizzard title: its anti-cheat is built into the game and ships no file of its own." },
{ "store": "steam", "id": "2344520", "family": "Blizzard Warden", "reason": "An online Blizzard title: its anti-cheat is built into the game and ships no file of its own." },
{ "store": "steam", "id": "2767030", "family": "NetEase Anti-Cheat", "reason": "Protected by NetEase's kernel anti-cheat (NEAC)." },
{ "store": "steam", "id": "1203220", "family": "NetEase Anti-Cheat", "reason": "Protected by NetEase's kernel anti-cheat (NEAC)." },
{ "store": "steam", "id": "2943650", "family": "NetEase Anti-Cheat", "reason": "Protected by NetEase's kernel anti-cheat (NEAC)." },
{ "store": "steam", "id": "2139460", "family": "NetEase Anti-Cheat", "reason": "Protected by NetEase's kernel anti-cheat (NEAC)." },
{ "store": "steam", "id": "2507950", "family": "Anti-Cheat Expert", "reason": "Protected by Tencent Anti-Cheat Expert (ACE), a kernel anti-cheat." },
{ "store": "steam", "id": "2073620", "family": "Anti-Cheat Expert", "reason": "Protected by Tencent Anti-Cheat Expert (ACE), a kernel anti-cheat." },
{ "store": "steam", "id": "1517290", "family": "EA AntiCheat", "reason": "Protected by EA AntiCheat (Javelin), a kernel anti-cheat." },
{ "store": "steam", "id": "2807960", "family": "EA AntiCheat", "reason": "Protected by EA AntiCheat (Javelin), a kernel anti-cheat." },
{ "store": "steam", "id": "2669320", "family": "EA AntiCheat", "reason": "Protected by EA AntiCheat (Javelin), a kernel anti-cheat." },
{ "store": "steam", "id": "3405690", "family": "EA AntiCheat", "reason": "Protected by EA AntiCheat (Javelin), a kernel anti-cheat." }
]
}
}
+3 -3
View File
@@ -443,15 +443,15 @@
"heuristic": { "$ref": "#/$defs/heuristic" },
"blockedExecutables": {
"$comment": "May legitimately be empty - a per-title list, not the family blocklist. minItems is deliberately absent here and deliberately present on modules/drivers. maxItems is fl::guard::kMaxTitleRules; at kMaxValuesPerTitleRule values each that is 512 blockable names, more than the 4096 this used to claim could ever have survived the parser.",
"$comment": "May legitimately be empty - a per-title list, not the family blocklist. minItems is deliberately absent here and deliberately present on modules/drivers. maxItems is fl::guard::kMaxTitleRules (128 since 2026-09-25); at kMaxValuesPerTitleRule values each that is 1024 blockable names, more than the 4096 this used to claim could ever have survived the parser.",
"type": "array",
"maxItems": 64,
"maxItems": 128,
"items": { "$ref": "#/$defs/acBlockedExecutable" }
},
"blockedStoreIds": {
"type": "array",
"maxItems": 64,
"maxItems": 128,
"items": { "$ref": "#/$defs/acBlockedStoreId" }
}
}
@@ -54,24 +54,30 @@ public interface IAntiCheatGuard
CancellationToken ct = default);
/// <summary>
/// Check 4 asked before anything is launched: does this game directory ship
/// anti-cheat? Answers FR-2.2's question — whether the hooking toggle may be
/// offered for this title at all.
/// Checks 3 and 4 asked before anything is launched: is this executable a listed title, does its install carry a
/// listed store identity, does its install tree ship anti-cheat? Answers FR-2.2's question — whether the hooking
/// toggle may be offered for this title at all — and the Agent's pre-scan of the library.
/// </summary>
/// <remarks>
/// <para>
/// ADVISORY ONLY. This does not gate injection; <see cref="EvaluateAsync"/>
/// and <see cref="GuardedInjectAsync"/> run the same scan inside the guard,
/// and <see cref="GuardedInjectAsync"/> run the same checks inside the guard,
/// against a directory derived from the target's own pid rather than one a
/// caller named. A caller that skips this question, or lies about the
/// answer, changes nothing about whether injection is allowed.
/// </para>
/// <para>
/// It takes the EXECUTABLE since 2026-09-25 (it was <c>PreScanGameDirectoryAsync</c>). The only caller passed the
/// executable's own folder and the guard scanned exactly that, so an Unreal title's root-level
/// <c>EasyAntiCheat</c> folder was never seen by the scan that decides whether hooking may be enabled. The guard
/// now resolves the install root from the path itself, as the chokepoint always did.
/// </para>
/// <para>
/// It lives on this port rather than a second one deliberately. Splitting it
/// out would have kept <c>NoSecondMatcherTests</c>' method count at two
/// without that test ever seeing the new surface — the count would have gone
/// on passing while the thing it guards grew somewhere else.
/// </para>
/// </remarks>
ValueTask<AntiCheatVerdict> PreScanGameDirectoryAsync(string gameDirectory, CancellationToken ct = default);
ValueTask<AntiCheatVerdict> PreScanGameAsync(string executablePath, CancellationToken ct = default);
}
@@ -175,8 +175,9 @@ public sealed class AgentCommandHandler
return Error(request, IpcErrorCode.ExecutableUnreadable, $"{path} could not be read, so nothing can be scanned or stamped");
}
string directory = Path.GetDirectoryName(path) ?? path;
AntiCheatVerdict verdict = await _guard.PreScanGameDirectoryAsync(directory, ct).ConfigureAwait(false);
// The EXECUTABLE, not its folder (2026-09-25): the guard resolves the install root and runs check 3 on the
// name and the store identity as well as check 4 on the tree.
AntiCheatVerdict verdict = await _guard.PreScanGameAsync(path, ct).ConfigureAwait(false);
if (!verdict.IsAllowed)
{
// A refusal, or a scan that reached no answer: the store records which (a default verdict is
@@ -74,7 +74,7 @@ public sealed class NativeAntiCheatGuard : IAntiCheatGuard
[DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
[DllImport(_guardDll, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
private static extern void FlStaticPreScan(string gameDirectory, out FlGuardResult result);
private static extern void FlStaticPreScanGame(string exePath, out FlGuardResult result);
[DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
[DllImport(_guardDll, CallingConvention = CallingConvention.Cdecl)]
@@ -140,13 +140,12 @@ public sealed class NativeAntiCheatGuard : IAntiCheatGuard
}
/// <inheritdoc />
public ValueTask<AntiCheatVerdict> PreScanGameDirectoryAsync(string gameDirectory,
CancellationToken ct = default)
public ValueTask<AntiCheatVerdict> PreScanGameAsync(string executablePath, CancellationToken ct = default)
{
ArgumentException.ThrowIfNullOrWhiteSpace(gameDirectory);
ArgumentException.ThrowIfNullOrWhiteSpace(executablePath);
return RunAsync(() =>
{
FlStaticPreScan(gameDirectory, out FlGuardResult r);
FlStaticPreScanGame(executablePath, out FlGuardResult r);
return AntiCheatVerdict.FromNative(r.Reason, r.Family, r.Signal);
}, ct);
}
@@ -33,7 +33,8 @@ enum class Group : std::uint8_t { kModules = 0, kDrivers, kDirectories, kService
// Note the off-by-one: CopyToken reserves a byte for the NUL and rejects at
// `len >= cap`, so kMaxValueLen 96 admits 95 characters, not 96.
// 64 until 2026-09-25, when the seed grew from 19 entries to 74 (eleven families became twenty-two, and most
// gained a driver, a service or a file) and 2 x 74 no longer fitted. Each slot is ~1.6 KB, so `Rules` is ~530 KB:
// gained a driver, a service or a file) and 2 x 74 no longer fitted. Each slot is ~1.6 KB, so `Rules` is ~650 KB with
// the per-title lists (kMaxTitleRules below):
// every production instance is static or heap-allocated and reset with ResetRules, never a stack temporary.
inline constexpr std::size_t kMaxFamilies = 256;
inline constexpr std::size_t kMaxValuesPerFamily = 16;
@@ -59,9 +60,13 @@ inline constexpr std::size_t kMaxRulesPathLen = 1024;
// Per-title rules (check 3). These are OBJECTS in the schema, not bare strings:
// 19_SAFETY requires the UI to name the check that fired and why, and a bare exe
// name carries neither. kMaxTitleRules x kMaxValuesPerTitleRule = 512 blockable
// names per array, more than the 256 the previous flat cap allowed.
inline constexpr std::size_t kMaxTitleRules = 64;
// name carries neither. kMaxTitleRules x kMaxValuesPerTitleRule = 1024 blockable
// names per array.
//
// 64 until 2026-09-25, when the lists were seeded AND floored: a store id is one entry per title, the floor doubles
// the worst case, and the first seed of 30 store ids already needed 60 of 64. Each slot is ~1 KB (the values array
// dominates), so `Rules` grew by ~125 KB with it.
inline constexpr std::size_t kMaxTitleRules = 128;
inline constexpr std::size_t kMaxValuesPerTitleRule = 8;
inline constexpr std::size_t kMaxReasonLen = 128;
@@ -221,22 +226,29 @@ enum class ParseResult : std::uint8_t {
//
// MatchesBlockedExecutable — WIRED. `CheckBlockedExecutable` calls it from
// inside `EvaluateImpl`, between the module scan and the static pre-scan. The
// shipped array is still empty, so it refuses nothing today; what changed is
// that filling it now does something.
// shipped array was empty until rules 2026.09.4 and is seeded since (owner
// decision 2026-09-25).
//
// MatchesBlockedStoreId — UNCALLED, and it cannot be called, for three
// independent reasons rather than for want of effort (§S14): nothing produces
// a store id (the platform metadata extractors are unbuilt), `FlGuardEvaluate`
// takes a pid and nothing else BY DESIGN (§S3 forbids a caller asserting a
// safety fact), and "unknown refuses" applied to it would refuse every title
// on every machine — a gate that cannot pass. Do NOT "fix" the second by
// widening the ABI.
// MatchesBlockedStoreId — WIRED 2026-09-25. It was uncalled until then, for
// three reasons (§S14): nothing produced a store id, `FlGuardEvaluate` takes a
// pid and nothing else BY DESIGN, and "unknown refuses" would have refused every
// title. `CheckBlockedStoreId` (fl_prescan.cpp) now reads the identity from the
// store's own files through a seam the guard owns — the ABI is unchanged — and
// an install no store names is not refused, while one whose store metadata
// cannot be read is.
//
// `storeId` is the joined form ("steam:730"); an unresolvable identity must
// reach the caller as unknown, never as a clean miss.
[[nodiscard]] const TitleRule* MatchesBlockedExecutable(const Rules& rules, const char* exeName) noexcept;
[[nodiscard]] const TitleRule* MatchesBlockedStoreId(const Rules& rules, const char* storeId) noexcept;
// The per-title lists are floored too, since 2026-09-25 — the same §S21 mechanism as the families: generated from
// the shipped seed, seeded before the file is read, never removable by data. A file entry identical to a floor entry
// is deduplicated, so the worst case is again the floor plus a fully drifted file (2 x each array must fit
// kMaxTitleRules; tools/rules-validate.ps1 checks it).
[[nodiscard]] const TitleRule* FloorBlockedExecutables(std::size_t& count) noexcept;
[[nodiscard]] const TitleRule* FloorBlockedStoreIds(std::size_t& count) noexcept;
// True if `moduleName` contains a suspicious fragment. The caller pairs this
// with a signer check; a fragment alone never refuses (19_SAFETY: "name
// fragment AND not signed by a known vendor").
@@ -129,7 +129,7 @@ enum class Reason : std::uint8_t {
// Consent and per-game enablement are records of something a human did;
// they live in the Agent's database and the native guard never sees them.
// They are nevertheless reasons a Tier-1 capture was refused, and they
// belong in THIS enum for the reason FlStaticPreScan already reports
// belong in THIS enum for the reason FlStaticPreScanGame already reports
// through FlGuardResult: one reason table, one mirror surface, one place
// the UI maps to a string.
//
@@ -307,6 +307,15 @@ struct Sources {
// something the caller infers from the string.
Collected (*EnumerateDirEntries)(const wchar_t* dir, DirEntrySink sink, void* ctx) = nullptr;
// Check 3's STORE half (2026-09-25): the store identity an install root carries, read from the store's own
// metadata on disk — never handed in by a caller (§S3) and never read out of the game's process (rule 4).
//
// kOk with a non-empty `out` is the joined form MatchesBlockedStoreId compares ("steam:730", "gog:1207658924").
// kOk with an EMPTY `out` is "this install carries no store identity": not a store layout we recognise, or a
// Steam library none of whose manifests names this folder. kFailed is a store layout whose metadata could not be
// read — cannot determine, which refuses. Three answers, so not a bool: the QueryService rule.
Collected (*StoreIdentity)(const wchar_t* installRoot, char* out, std::size_t cap) = nullptr;
// §S18/§S22(b) — is this MODULE one of OUR OWN binaries?
//
// The single narrow exception in this gate, and the only thing it may ever
@@ -69,17 +69,20 @@ FL_GUARD_ABI void FlGuardedInjectWhenReady(std::uint32_t targetPid, const wchar_
// FlGuardedInjectAcknowledged, FlGuardedInjectWhenReadyAcknowledged and FlGuardIsJudgement were exported for one day
// (2026-09-21, the user's bypass) and withdrawn on 2026-09-22. The ABI has no entry that injects past a refusal.
// Check 4 against a directory, before anything is launched (FR-2.2). ADVISORY:
// it answers "may this game's hooking toggle be offered at all", and gates
// nothing. The same scan runs inside FlGuardEvaluate and FlGuardedInject
// against a directory derived from the target's own pid, so a caller who never
// asks this — or ignores the answer — changes nothing about what is allowed.
// Checks 3 and 4 against an EXECUTABLE, before anything is launched (FR-2.2, and the Agent's pre-scan of the
// library). ADVISORY: it answers "may this game's hooking toggle be offered at all", and gates nothing. The same
// checks run inside FlGuardEvaluate and FlGuardedInject against the target's own pid, so a caller who never asks this
// — or ignores the answer — changes nothing about what is allowed.
//
// It reports through FlGuardResult rather than an outcome enum of its own, so
// there is ONE reason table and ONE mirror surface: kAllow means clean,
// AntiCheatDirectory/AntiCheatFile name what was found, and PreScanFailed or a
// Rules* reason means the scan could not reach an answer.
FL_GUARD_ABI void FlStaticPreScan(const wchar_t* gameDirectory, FlGuardResult* out);
// It replaced FlStaticPreScan(gameDirectory) on 2026-09-25. That export scanned the directory it was given, and its
// one caller gave the executable's own folder, so an Unreal title's root-level EasyAntiCheat/ was never seen by the
// scan that decides whether hooking may be enabled. This one resolves the install root itself (ResolveInstallRoot, as
// the chokepoint always did) and adds check 3: the executable's name and the install's store identity.
//
// It reports through FlGuardResult rather than an outcome enum of its own, so there is ONE reason table and ONE
// mirror surface: kAllow means clean; BlockedExecutable, BlockedStoreId, AntiCheatDirectory and AntiCheatFile name
// what was found; PreScanFailed or a Rules* reason means the scan could not reach an answer.
FL_GUARD_ABI void FlStaticPreScanGame(const wchar_t* exePath, FlGuardResult* out);
// Stable name for a reason code. The managed mirror test compares these against
// its own enum, so this is a contract and not a debugging aid.
@@ -85,6 +85,14 @@ inline constexpr std::size_t kMaxPreScanPathLen = 1024;
// "cannot determine".
[[nodiscard]] bool ResolveInstallRoot(const wchar_t* exeDir, wchar_t* out, std::size_t cap) noexcept;
// THE KERNEL-DRIVER RULE (owner decision 2026-09-25). Any `*.sys` file inside a game's install tree that no
// `files` entry names is reported as an anti-cheat file under this family, because a kernel driver shipped with a
// game is, measured on every case this project has met (PGameProtectDriver_X64.sys, randgrid.sys, NeacSafe64.sys,
// BlackCat64.sys, mhyprot*.sys), an anti-cheat driver — and naming each one in data first is how a new one walks
// past. It is CODE, not data: a rules file can neither remove it nor rename the family. A false positive turns the
// game's hooking off like any finding (19_SAFETY §What a finding does to the game); the owner took that trade.
inline constexpr const char* kKernelDriverInTreeFamily = "Kernel driver in the game folder";
// Check 4, as EvaluateImpl runs it: derive the target's directory from its pid,
// then scan it.
//
@@ -95,17 +103,34 @@ inline constexpr std::size_t kMaxPreScanPathLen = 1024;
// only caller already had to reach anyway.
[[nodiscard]] Verdict CheckStaticPreScan(const Sources& s, const Rules& rules, std::uint32_t targetPid) noexcept;
// The advisory form, for the UI's pre-launch question "can this game be
// enabled at all?" (FR-2.2). Same matcher, same polarity, no pid.
// Check 3's store half over an install root: the store identity it carries (Sources::StoreIdentity) against
// `blockedStoreIds`. An install with no store identity is NOT refused — "not a store title" is an answer, and
// refusing every title that no store names would be a gate that cannot pass (§S14's matrix) — but a store layout
// whose metadata cannot be read is (kPreScanFailed): that one is "cannot determine". With nothing listed, nothing is
// read.
[[nodiscard]] Verdict CheckStoreIdentity(const Sources& s, const Rules& rules, const wchar_t* installRoot) noexcept;
// The same, as EvaluateImpl runs it: the install root derived from the pid, exactly as check 4 derives it.
[[nodiscard]] Verdict CheckBlockedStoreId(const Sources& s, const Rules& rules, std::uint32_t targetPid) noexcept;
// The advisory form, for the question "can this game be enabled at all?" (FR-2.2) and for the Agent's pre-scan of
// the library (19_SAFETY §What a finding does to the game). Same matcher, same polarity, no pid: check 3 (the
// executable's own name, and the store identity of its install root) and check 4 (the install root's tree), from the
// EXECUTABLE's path.
//
// Loads the rules itself and uses SystemSources(), so a caller cannot choose the
// evidence — the same reason Evaluate and GuardedInject take no Sources.
[[nodiscard]] Verdict StaticPreScan(const wchar_t* gameDirectory) noexcept;
// It takes the executable, not a directory, since 2026-09-25. It took a directory, and its one caller passed the
// executable's own folder while nothing resolved the install root — so the pre-scan that decides whether hooking may
// be turned on looked where 19_SAFETY's Lies of P measurement says an Unreal title's EasyAntiCheat/ never is. The
// chokepoint always resolved the root; now this does too, from the same function.
//
// Loads the rules itself and uses SystemSources(), so a caller cannot choose the evidence — the same reason Evaluate
// and GuardedInject take no Sources.
[[nodiscard]] Verdict StaticPreScanGame(const wchar_t* exePath) noexcept;
#ifdef FL_GUARD_TESTABLE
// TEST-ONLY, exactly as fl_guard.h defines the term: compiled out of everything
// that ships, and only src/native/tests may define the macro.
[[nodiscard]] Verdict StaticPreScanWithSources(const wchar_t* gameDirectory, const Sources& sources) noexcept;
[[nodiscard]] Verdict StaticPreScanGameWithSources(const wchar_t* exePath, const Sources& sources) noexcept;
#endif
} // namespace fl::guard
@@ -341,23 +341,46 @@ bool ReadStoreRule(const char* json, const jsmntok_t* toks, int count, int objIn
using TitleReader = bool (*)(const char*, const jsmntok_t*, int, int, TitleRule&) noexcept;
// True when `candidate` repeats a floor entry field for field — SameFamily's rule, for the per-title lists.
bool SameTitleRule(const TitleRule& a, const TitleRule& b) noexcept {
if (a.match != b.match || a.valueCount != b.valueCount || !IEquals(a.family, b.family) ||
!IEquals(a.reason, b.reason)) {
return false;
}
for (std::size_t i = 0; i < a.valueCount; ++i) {
if (!IEquals(a.values[i], b.values[i])) {
return false;
}
}
return true;
}
// APPENDS after the floor (2026-09-25), like the families: the first `floorCount` entries of `out` are the
// compiled-in lists, an unmodified file repeats all of them, and a repeat is skipped rather than stored twice.
bool ReadTitleArray(const char* json, const jsmntok_t* toks, int count, int arrayTok, TitleReader read, TitleRule* out,
std::size_t& outCount) noexcept {
outCount = 0;
std::size_t& outCount, std::size_t floorCount) noexcept {
if (arrayTok < 0 || toks[arrayTok].type != JSMN_ARRAY) {
return false;
}
if (static_cast<std::size_t>(toks[arrayTok].size) > kMaxTitleRules) {
return false;
}
for (int i = arrayTok + 1; i < count && outCount < kMaxTitleRules; ++i) {
for (int i = arrayTok + 1; i < count; ++i) {
if (toks[i].parent != arrayTok) {
continue;
}
if (!read(json, toks, count, i, out[outCount])) {
TitleRule rule;
if (!read(json, toks, count, i, rule)) {
return false;
}
++outCount;
bool duplicate = false;
for (std::size_t f = 0; f < floorCount && !duplicate; ++f) {
duplicate = SameTitleRule(out[f], rule);
}
if (duplicate) {
continue;
}
if (outCount >= kMaxTitleRules) {
return false; // more distinct entries than we can hold: refuse the file, never drop one
}
out[outCount++] = rule;
}
return true;
}
@@ -435,6 +458,16 @@ const char* const* FloorFragments(std::size_t& count) noexcept {
return generated::kFloorFragments;
}
const TitleRule* FloorBlockedExecutables(std::size_t& count) noexcept {
count = generated::kFloorBlockedExecutableCount;
return generated::kFloorBlockedExecutables;
}
const TitleRule* FloorBlockedStoreIds(std::size_t& count) noexcept {
count = generated::kFloorBlockedStoreIdCount;
return generated::kFloorBlockedStoreIds;
}
ParseResult ParseRules(const char* json, std::size_t length, Rules& out) noexcept {
ResetRules(out);
@@ -466,6 +499,21 @@ ParseResult ParseRules(const char* json, std::size_t length, Rules& out) noexcep
++out.nameFragmentCount;
}
}
// And the per-title lists (2026-09-25), for the same reason and in the same position: a rules file that empties
// blockedExecutables or blockedStoreIds cannot take a floored title off either list.
std::size_t execFloorCount = 0;
const TitleRule* execFloor = FloorBlockedExecutables(execFloorCount);
for (std::size_t i = 0; i < execFloorCount && out.blockedExecutableCount < kMaxTitleRules; ++i) {
out.blockedExecutables[out.blockedExecutableCount++] = execFloor[i];
}
const std::size_t execFirst = out.blockedExecutableCount;
std::size_t storeFloorCount = 0;
const TitleRule* storeFloor = FloorBlockedStoreIds(storeFloorCount);
for (std::size_t i = 0; i < storeFloorCount && out.blockedStoreIdCount < kMaxTitleRules; ++i) {
out.blockedStoreIds[out.blockedStoreIdCount++] = storeFloor[i];
}
const std::size_t storeFirst = out.blockedStoreIdCount;
if (json == nullptr || length == 0) {
return ParseResult::kMalformed;
}
@@ -536,12 +584,12 @@ ParseResult ParseRules(const char* json, std::size_t length, Rules& out) noexcep
// ReadTitleRule for what reading them as strings would have done.
const int execTok = FindMember(json, toks, count, acTok, "blockedExecutables");
if (execTok >= 0 && !ReadTitleArray(json, toks, count, execTok, &ReadTitleRule, out.blockedExecutables,
out.blockedExecutableCount)) {
out.blockedExecutableCount, execFirst)) {
return ParseResult::kMalformed;
}
const int storeTok = FindMember(json, toks, count, acTok, "blockedStoreIds");
if (storeTok >= 0 &&
!ReadTitleArray(json, toks, count, storeTok, &ReadStoreRule, out.blockedStoreIds, out.blockedStoreIdCount)) {
if (storeTok >= 0 && !ReadTitleArray(json, toks, count, storeTok, &ReadStoreRule, out.blockedStoreIds,
out.blockedStoreIdCount, storeFirst)) {
return ParseResult::kMalformed;
}
@@ -559,23 +559,18 @@ namespace {
// both refuse with kProcessUnreadable -- the same reason CheckModules already
// uses for the same underlying inability.
//
// THE STORE-ID HALF IS NOT HERE, and that is a limitation rather than an
// omission. MatchesBlockedStoreId exists and is tested; it cannot be called,
// for three independent reasons (§S14):
// THE STORE-ID HALF was not here until 2026-09-25, and this comment gave three independent reasons (§S14):
//
// 1. NO PRODUCER. Nothing in the tree parses Steam .acf, GOG .info or Epic
// .item -- the platform metadata extractors were never built, so `store_id`
// is null for every title.
// 2. NO CHANNEL, BY DESIGN. FlGuardEvaluate takes a pid and nothing else, and
// fl_guard_abi.h says so deliberately: "no way to hand in evidence -- the
// guard collects its own". A store id passed in by the caller is a caller
// 1. NO PRODUCER. Nothing in the tree parsed Steam .acf, GOG .info or Epic .item.
// 2. NO CHANNEL, BY DESIGN. FlGuardEvaluate takes a pid and nothing else, and fl_guard_abi.h says so deliberately:
// "no way to hand in evidence -- the guard collects its own". A store id passed in by the caller is a caller
// asserting a safety fact, which §S3's rule forbids in as many words.
// 3. APPLYING "unknown refuses" TO IT WOULD BE A GATE THAT CANNOT PASS. If the
// guard can never resolve a store id and an unresolved store id refuses,
// every title on every machine refuses.
// 3. APPLYING "unknown refuses" TO IT WOULD BE A GATE THAT CANNOT PASS.
//
// So the exe-name half runs and the store-id half is named as blocked. Do not
// "fix" (2) by widening the ABI.
// It is wired now without touching (2): Sources::StoreIdentity reads the store's OWN metadata from disk, from the
// install root the guard derives itself (CheckBlockedStoreId, fl_prescan.cpp). (3) is answered by the matrix there:
// an install no store names is not refused — that is an answer, not an unknown — while a store layout whose
// metadata cannot be read is. Do not "fix" anything here by widening the ABI.
Verdict CheckBlockedExecutable(const Sources& s, const Rules& rules, std::uint32_t targetPid) noexcept {
if (s.ImageFileName == nullptr) {
return Refuse(Reason::kProcessUnreadable, nullptr, "no image-name source");
@@ -619,6 +614,11 @@ Verdict EvaluateImpl(std::uint32_t targetPid, const Sources& sources) noexcept {
if (Verdict v = CheckBlockedExecutable(sources, rules, targetPid); !v.Allowed()) {
return v;
}
// Check 3's store half (2026-09-25): the install root's store identity against blockedStoreIds. It touches the
// filesystem only when something is listed, and it comes before check 4's walk because it reads one folder.
if (Verdict v = CheckBlockedStoreId(sources, rules, targetPid); !v.Allowed()) {
return v;
}
// Check 4, INSIDE the chokepoint rather than beside it.
//
// 19_SAFETY and 05_DETECTION both describe this as gating injection, and it
@@ -48,11 +48,11 @@ void FlGuardedInjectWhenReady(std::uint32_t targetPid, const wchar_t* dllPath, s
Fill(out, fl::guard::GuardedInjectWhenReady(targetPid, dllPath, timeoutMs));
}
void FlStaticPreScan(const wchar_t* gameDirectory, FlGuardResult* out) {
void FlStaticPreScanGame(const wchar_t* exePath, FlGuardResult* out) {
if (!Usable(out)) {
return;
}
Fill(out, fl::guard::StaticPreScan(gameDirectory));
Fill(out, fl::guard::StaticPreScanGame(exePath));
}
const char* FlGuardReasonName(std::int32_t reason) {
@@ -18,6 +18,7 @@
#include <cstdio>
#include <cstring>
#include <cwchar>
#include <fl_ac_rules.h>
#include <fl_guard.h>
#include <fl_prescan.h>
@@ -616,6 +617,218 @@ Collected EnumerateDirEntriesImpl(const wchar_t* dir, DirEntrySink sink, void* c
return truncated ? Collected::kIncomplete : Collected::kOk;
}
// --- Check 3's store half (2026-09-25): the install root's store identity, from the store's own files -------------
//
// Bounds, all REFUSALS rather than truncations, like check 4's: a Steam library whose manifests we could not all read
// is a library whose answer we do not know.
constexpr std::size_t kMaxSteamManifests = 4096;
constexpr std::size_t kMaxManifestBytes = 256 * 1024;
// The quoted value that follows `"key"` in Valve's KeyValues text, ASCII case-insensitive on the key, with the
// format's two escapes (\" and \\) undone. False when the key is absent or its value does not fit.
bool VdfValue(const char* text, std::size_t len, const char* key, char* out, std::size_t cap) noexcept {
const std::size_t keyLen = std::strlen(key);
for (std::size_t i = 0; i + keyLen + 2 <= len; ++i) {
if (text[i] != '"' || _strnicmp(text + i + 1, key, keyLen) != 0 || text[i + 1 + keyLen] != '"') {
continue;
}
std::size_t j = i + keyLen + 2;
while (j < len && (text[j] == ' ' || text[j] == '\t')) {
++j;
}
if (j >= len || text[j] != '"') {
continue; // a key followed by a block, not a value: keep looking
}
++j;
std::size_t n = 0;
while (j < len && text[j] != '"') {
char c = text[j];
if (c == '\\' && j + 1 < len && (text[j + 1] == '"' || text[j + 1] == '\\')) {
c = text[++j];
}
if (c == '\r' || c == '\n' || n + 1 >= cap) {
return false; // an unterminated value, or one longer than we hold
}
out[n++] = c;
++j;
}
if (j >= len) {
return false;
}
out[n] = '\0';
return true;
}
return false;
}
bool AllDigits(const char* s, std::size_t maxLen) noexcept {
const std::size_t n = std::strlen(s);
if (n == 0 || n > maxLen) {
return false;
}
for (std::size_t i = 0; i < n; ++i) {
if (s[i] < '0' || s[i] > '9') {
return false;
}
}
return true;
}
// Steam: `<library>\steamapps\common\<folder>` is named by exactly one `<library>\steamapps\appmanifest_<id>.acf`,
// whose "installdir" is <folder>. kOk + "" when no manifest names it; kFailed when the manifests cannot be read.
Collected SteamIdentity(const wchar_t* steamapps, const wchar_t* folder, std::size_t folderLen, char* out,
std::size_t cap) noexcept {
wchar_t folderZ[kMaxPreScanPathLen] = {};
if (folderLen + 1 > kMaxPreScanPathLen) {
return Collected::kFailed;
}
std::wmemcpy(folderZ, folder, folderLen);
char wanted[kMaxPreScanPathLen] = {};
const int wn =
WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, folderZ, -1, wanted, sizeof(wanted), nullptr, nullptr);
if (wn <= 0) {
return Collected::kFailed; // a folder name we cannot spell exactly is one we cannot compare
}
wchar_t pattern[kMaxPreScanPathLen] = {};
if (_snwprintf_s(pattern, kMaxPreScanPathLen, _TRUNCATE, L"%s\\appmanifest_*.acf", steamapps) < 0) {
return Collected::kFailed;
}
WIN32_FIND_DATAW fd{};
HANDLE find = FindFirstFileW(pattern, &fd);
if (find == INVALID_HANDLE_VALUE) {
const DWORD err = GetLastError();
// No manifest at all is an answer (a folder under steamapps\common that Steam does not manage); anything else
// is a library we could not read.
return (err == ERROR_FILE_NOT_FOUND) ? Collected::kOk : Collected::kFailed;
}
static char text[kMaxManifestBytes];
std::size_t seen = 0;
Collected result = Collected::kOk;
do {
if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
continue;
}
if (++seen > kMaxSteamManifests) {
result = Collected::kFailed;
break;
}
wchar_t path[kMaxPreScanPathLen] = {};
if (_snwprintf_s(path, kMaxPreScanPathLen, _TRUNCATE, L"%s\\%s", steamapps, fd.cFileName) < 0) {
result = Collected::kFailed;
break;
}
HANDLE file = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
if (file == INVALID_HANDLE_VALUE) {
result = Collected::kFailed;
break;
}
DWORD got = 0;
const BOOL read = ReadFile(file, text, static_cast<DWORD>(sizeof(text)), &got, nullptr);
CloseHandle(file);
if (!read || got >= sizeof(text)) {
result = Collected::kFailed; // unreadable, or larger than any manifest Steam writes
break;
}
char installDir[kMaxPreScanPathLen] = {};
if (!VdfValue(text, got, "installdir", installDir, sizeof(installDir)) || _stricmp(installDir, wanted) != 0) {
continue;
}
char appId[32] = {};
if (!VdfValue(text, got, "appid", appId, sizeof(appId)) || !AllDigits(appId, 10) ||
_snprintf_s(out, cap, _TRUNCATE, "steam:%s", appId) < 0) {
result = Collected::kFailed; // the manifest that names this folder does not say which app it is
break;
}
FindClose(find);
return Collected::kOk;
} while (FindNextFileW(find, &fd) != 0);
const DWORD err = GetLastError();
FindClose(find);
if (result == Collected::kOk && err != ERROR_NO_MORE_FILES) {
result = Collected::kFailed;
}
if (result != Collected::kOk) {
out[0] = '\0';
}
return result;
}
// GOG: a `goggame-<id>.info` in the install root names the product. kOk + "" when there is none.
Collected GogIdentity(const wchar_t* installRoot, char* out, std::size_t cap) noexcept {
wchar_t pattern[kMaxPreScanPathLen] = {};
if (_snwprintf_s(pattern, kMaxPreScanPathLen, _TRUNCATE, L"%s\\goggame-*.info", installRoot) < 0) {
return Collected::kFailed;
}
WIN32_FIND_DATAW fd{};
HANDLE find = FindFirstFileW(pattern, &fd);
if (find == INVALID_HANDLE_VALUE) {
const DWORD err = GetLastError();
return (err == ERROR_FILE_NOT_FOUND || err == ERROR_PATH_NOT_FOUND) ? Collected::kOk : Collected::kFailed;
}
FindClose(find);
// goggame-<digits>.info: the digits are the product id.
const wchar_t* name = fd.cFileName;
const wchar_t* digits = name + 8; // past "goggame-"
const wchar_t* dot = wcschr(digits, L'.');
char id[32] = {};
std::size_t n = 0;
for (const wchar_t* p = digits; dot != nullptr && p < dot; ++p) {
if (*p < L'0' || *p > L'9' || n + 1 >= sizeof(id)) {
return Collected::kOk; // not the shape GOG writes: no identity, rather than a guessed one
}
id[n++] = static_cast<char>(*p);
}
if (n == 0 || _snprintf_s(out, cap, _TRUNCATE, "gog:%s", id) < 0) {
out[0] = '\0';
return Collected::kOk;
}
return Collected::kOk;
}
Collected StoreIdentityImpl(const wchar_t* installRoot, char* out, std::size_t cap) noexcept {
if (installRoot == nullptr || out == nullptr || cap == 0) {
return Collected::kFailed;
}
out[0] = '\0';
// The last three segments decide the layout: `...\steamapps\common\<folder>` is a Steam library.
const std::size_t len = wcslen(installRoot);
std::size_t end = len;
while (end > 0 && (installRoot[end - 1] == L'\\' || installRoot[end - 1] == L'/')) {
--end;
}
std::size_t seps[3] = {}; // positions of the three separators before the last three segments' ends
std::size_t found = 0;
for (std::size_t i = end; i > 0 && found < 3; --i) {
if (installRoot[i - 1] == L'\\' || installRoot[i - 1] == L'/') {
seps[found++] = i - 1;
}
}
if (found == 3) {
const wchar_t* folder = installRoot + seps[0] + 1;
const wchar_t* common = installRoot + seps[1] + 1;
const wchar_t* steamappsSeg = installRoot + seps[2] + 1;
const bool isCommon = (seps[0] - seps[1] - 1) == 6 && _wcsnicmp(common, L"common", 6) == 0;
const bool isSteamapps = (seps[1] - seps[2] - 1) == 9 && _wcsnicmp(steamappsSeg, L"steamapps", 9) == 0;
if (isCommon && isSteamapps) {
wchar_t steamappsDir[kMaxPreScanPathLen] = {};
const std::size_t dirLen = seps[1]; // "...\steamapps": up to the separator before "common"
if (dirLen + 1 > kMaxPreScanPathLen) {
return Collected::kFailed;
}
std::wmemcpy(steamappsDir, installRoot, dirLen);
return SteamIdentity(steamappsDir, folder, end - seps[0] - 1, out, cap);
}
}
return GogIdentity(installRoot, out, cap);
}
// §S22 — does this file live in the directory the guard's own code came from?
//
// ONE implementation behind TWO seams (fl_guard.h): the payload we are about to
@@ -785,6 +998,7 @@ Sources SystemSources() noexcept {
s.ImageDirectory = &ImageDirectoryImpl;
s.ImageFileName = &ImageFileNameImpl;
s.EnumerateDirEntries = &EnumerateDirEntriesImpl;
s.StoreIdentity = &StoreIdentityImpl;
// Both identity seams, one implementation — see fl_guard.h §TWO SEAMS.
s.ModuleIsOurOwn = &FileIsOurOwnImpl;
s.PayloadIsOurOwn = &FileIsOurOwnImpl;
@@ -1,3 +1,7 @@
// windows.h stays in its own block above the sorted group, as fl_ac_rules.cpp does: WideCharToMultiByte (the one
// Win32 call here, for the executable's leaf name) needs it.
#include <windows.h>
#include <cstring>
#include <cwchar>
#include <fl_prescan.h>
@@ -27,11 +31,19 @@ Verdict Passed() noexcept {
return v;
}
// True for a name ending in ".sys", ASCII case-insensitively. Names reach the sink as UTF-8 and the suffix is ASCII,
// so a byte comparison of the last four characters is exact.
bool IsKernelDriverName(const char* name) noexcept {
const std::size_t n = std::strlen(name);
return n > 4 && _stricmp(name + n - 4, ".sys") == 0;
}
// What the sink accumulates. No allocation: the walk reports names one at a
// time and we keep only the first hit.
struct ScanState {
const Rules* rules = nullptr;
const Family* hit = nullptr;
const char* driverRuleHit = nullptr; // kKernelDriverInTreeFamily once the code rule fired
bool hitWasDirectory = false;
char signal[260] = {};
};
@@ -51,14 +63,21 @@ bool EntrySink(void* ctx, const char* name, bool isDirectory) noexcept {
// a data edit move one gate into the other without anything noticing.
const Group group = isDirectory ? Group::kDirectories : Group::kFiles;
const Family* f = MatchName(*st->rules, group, name);
if (f == nullptr) {
return true;
if (f != nullptr) {
st->hit = f;
st->hitWasDirectory = isDirectory;
strncpy_s(st->signal, sizeof(st->signal), name, _TRUNCATE);
return false; // stop: we have the answer
}
st->hit = f;
st->hitWasDirectory = isDirectory;
strncpy_s(st->signal, sizeof(st->signal), name, _TRUNCATE);
return false; // stop: we have the answer
// The kernel-driver rule (fl_prescan.h). A `files` entry that names the driver wins above, so a driver the data
// knows keeps its own family; any other `*.sys` in the tree is reported under the code rule's family.
if (!isDirectory && IsKernelDriverName(name)) {
st->driverRuleHit = kKernelDriverInTreeFamily;
strncpy_s(st->signal, sizeof(st->signal), name, _TRUNCATE);
return false;
}
return true;
}
Verdict ScanWith(const Sources& s, const Rules& rules, const wchar_t* dir) noexcept {
@@ -81,6 +100,9 @@ Verdict ScanWith(const Sources& s, const Rules& rules, const wchar_t* dir) noexc
return Refused(st.hitWasDirectory ? Reason::kAntiCheatDirectory : Reason::kAntiCheatFile, st.hit->name,
st.signal);
}
if (st.driverRuleHit != nullptr) {
return Refused(Reason::kAntiCheatFile, st.driverRuleHit, st.signal);
}
// EVERY uncertainty is a refusal, and each has its own text because "the
// directory is gone" and "there were more entries than we will look at" are
@@ -101,6 +123,83 @@ bool SegmentIs(const wchar_t* begin, const wchar_t* end, const wchar_t* literal)
return wcslen(literal) == n && _wcsnicmp(begin, literal, n) == 0;
}
// The rules the advisory pre-scan reads, loaded as LoadRules loads them for the chokepoint: the one rules location,
// the one parser, every failure a refusal with its own reason. Static rather than stack for LoadRules' reason too:
// ~1 MiB of text and ~530 KB of parsed rules, and the guard is not re-entrant.
Verdict LoadPreScanRules(const Sources& s, Rules& rules) noexcept {
if (s.ReadRulesFile == nullptr) {
return Refused(Reason::kRulesUnreadable, nullptr, "no rules source");
}
static char buffer[kMaxRulesBytes];
const std::size_t n = s.ReadRulesFile(buffer, sizeof(buffer));
if (n == static_cast<std::size_t>(-1) || n == 0) {
return Refused(Reason::kRulesUnreadable, nullptr, "rules file could not be read");
}
switch (ParseRules(buffer, n, rules)) {
case ParseResult::kOk:
return Passed();
case ParseResult::kIncomplete:
return Refused(Reason::kRulesIncomplete, nullptr, "a required anti-cheat family is missing");
case ParseResult::kTooLarge:
return Refused(Reason::kRulesMalformed, nullptr, "rules file exceeds the parser's bounds");
case ParseResult::kMalformed:
default:
return Refused(Reason::kRulesMalformed, nullptr, "rules file is not the shape the guard requires");
}
}
// The advisory pre-scan over whichever Sources the caller may hold (production: SystemSources, and nothing else).
Verdict PreScanGameWith(const wchar_t* exePath, const Sources& s) noexcept {
if (exePath == nullptr || exePath[0] == L'\0') {
return Refused(Reason::kPreScanFailed, nullptr, "no executable to scan");
}
// Split the path into its directory and its leaf. A path with no separator is not a path we understand.
wchar_t dir[kMaxPreScanPathLen] = {};
if (wcscpy_s(dir, kMaxPreScanPathLen, exePath) != 0) {
return Refused(Reason::kPreScanFailed, nullptr, "the executable's path is longer than the scan will hold");
}
wchar_t* lastSep = nullptr;
for (wchar_t* p = dir; *p != L'\0'; ++p) {
if (*p == L'\\' || *p == L'/') {
lastSep = p;
}
}
if (lastSep == nullptr || lastSep == dir || lastSep[1] == L'\0') {
return Refused(Reason::kPreScanFailed, nullptr, "the executable's path names no file in a directory");
}
const wchar_t* leafWide = exePath + (lastSep - dir) + 1;
*lastSep = L'\0';
wchar_t root[kMaxPreScanPathLen] = {};
if (!ResolveInstallRoot(dir, root, kMaxPreScanPathLen)) {
return Refused(Reason::kPreScanFailed, nullptr, "could not establish the game's install root");
}
static Rules rules;
if (Verdict v = LoadPreScanRules(s, rules); !v.Allowed()) {
return v;
}
// Check 3, the executable half. The exact-conversion rule ImageFileNameImpl follows: a name we cannot represent
// exactly is a name we could not compare, never a clean miss.
char leaf[kMaxValueLen] = {};
const int written = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, leafWide, -1, leaf,
static_cast<int>(sizeof(leaf)), nullptr, nullptr);
if (written <= 0) {
return Refused(Reason::kPreScanFailed, nullptr, "the executable's name could not be read exactly");
}
if (const TitleRule* hit = MatchesBlockedExecutable(rules, leaf); hit != nullptr) {
return Refused(Reason::kBlockedExecutable, hit->family, leaf);
}
// Check 3's store half, then check 4 — both over the install root.
if (Verdict v = CheckStoreIdentity(s, rules, root); !v.Allowed()) {
return v;
}
return ScanWith(s, rules, root);
}
} // namespace
bool ResolveInstallRoot(const wchar_t* exeDir, wchar_t* out, std::size_t cap) noexcept {
@@ -184,61 +283,52 @@ Verdict CheckStaticPreScan(const Sources& s, const Rules& rules, std::uint32_t t
return ScanWith(s, rules, dir);
}
Verdict StaticPreScan(const wchar_t* gameDirectory) noexcept {
const Sources s = SystemSources();
if (s.ReadRulesFile == nullptr) {
return Refused(Reason::kRulesUnreadable, nullptr, "no rules source");
Verdict CheckStoreIdentity(const Sources& s, const Rules& rules, const wchar_t* installRoot) noexcept {
// Nothing listed, nothing to compare: the store's files are not opened at all.
if (rules.blockedStoreIdCount == 0) {
return Passed();
}
if (s.StoreIdentity == nullptr) {
return Refused(Reason::kPreScanFailed, nullptr, "no store-identity source");
}
if (installRoot == nullptr || installRoot[0] == L'\0') {
return Refused(Reason::kPreScanFailed, nullptr, "no install root to read a store identity from");
}
// Static rather than stack for the same reason LoadRules does it: this is
// ~1 MiB of text and the guard is not re-entrant.
static char buffer[kMaxRulesBytes];
const std::size_t n = s.ReadRulesFile(buffer, sizeof(buffer));
if (n == static_cast<std::size_t>(-1) || n == 0) {
return Refused(Reason::kRulesUnreadable, nullptr, "rules file could not be read");
char id[kMaxValueLen] = {};
if (s.StoreIdentity(installRoot, id, sizeof(id)) != Collected::kOk) {
return Refused(Reason::kPreScanFailed, nullptr, "the store's metadata for this install could not be read");
}
if (id[0] == '\0') {
return Passed(); // no store names this install: check 3's store half does not apply (§S14's matrix)
}
if (const TitleRule* hit = MatchesBlockedStoreId(rules, id); hit != nullptr) {
return Refused(Reason::kBlockedStoreId, hit->family, id);
}
return Passed();
}
static Rules rules;
ResetRules(rules);
switch (ParseRules(buffer, n, rules)) {
case ParseResult::kOk:
break;
case ParseResult::kIncomplete:
return Refused(Reason::kRulesIncomplete, nullptr, "a required anti-cheat family is missing");
case ParseResult::kTooLarge:
return Refused(Reason::kRulesMalformed, nullptr, "rules file exceeds the parser's bounds");
case ParseResult::kMalformed:
default:
return Refused(Reason::kRulesMalformed, nullptr, "rules file is not the shape the guard requires");
Verdict CheckBlockedStoreId(const Sources& s, const Rules& rules, std::uint32_t targetPid) noexcept {
if (rules.blockedStoreIdCount == 0) {
return Passed();
}
return ScanWith(s, rules, gameDirectory);
if (s.ImageDirectory == nullptr) {
return Refused(Reason::kPreScanFailed, nullptr, "no image-path source");
}
wchar_t root[kMaxPreScanPathLen] = {};
if (s.ImageDirectory(targetPid, root, kMaxPreScanPathLen) != Collected::kOk || root[0] == L'\0') {
return Refused(Reason::kPreScanFailed, nullptr, "could not establish the target's directory");
}
return CheckStoreIdentity(s, rules, root);
}
Verdict StaticPreScanGame(const wchar_t* exePath) noexcept {
return PreScanGameWith(exePath, SystemSources());
}
#ifdef FL_GUARD_TESTABLE
Verdict StaticPreScanWithSources(const wchar_t* gameDirectory, const Sources& sources) noexcept {
if (sources.ReadRulesFile == nullptr) {
return Refused(Reason::kRulesUnreadable, nullptr, "no rules source");
}
static char buffer[kMaxRulesBytes];
const std::size_t n = sources.ReadRulesFile(buffer, sizeof(buffer));
if (n == static_cast<std::size_t>(-1) || n == 0) {
return Refused(Reason::kRulesUnreadable, nullptr, "rules file could not be read");
}
static Rules rules;
ResetRules(rules);
switch (ParseRules(buffer, n, rules)) {
case ParseResult::kOk:
break;
case ParseResult::kIncomplete:
return Refused(Reason::kRulesIncomplete, nullptr, "a required anti-cheat family is missing");
case ParseResult::kTooLarge:
return Refused(Reason::kRulesMalformed, nullptr, "rules file exceeds the parser's bounds");
case ParseResult::kMalformed:
default:
return Refused(Reason::kRulesMalformed, nullptr, "rules file is not the shape the guard requires");
}
return ScanWith(sources, rules, gameDirectory);
Verdict StaticPreScanGameWithSources(const wchar_t* exePath, const Sources& sources) noexcept {
return PreScanGameWith(exePath, sources);
}
#endif
+5 -4
View File
@@ -210,10 +210,11 @@ bool RunSelfScan() noexcept {
// moment the verdict is known. Init is not a hook path, so allocating here
// breaks no rule; keeping it resident would waste budget on data we never
// look at again. The parsed rules were ~226 KB (this comment said ~155 KB,
// a figure from before the per-title lists were objects) and are 541,736
// bytes since kMaxFamilies became 256 on 2026-09-25 — ctest fl_rules_budget
// prints sizeof(Rules) on every run. ParseRules resets them in place
// (ResetRules), so no copy of that size ever lands on this thread's stack.
// a figure from before the per-title lists were objects) and are 666,664
// bytes since kMaxFamilies became 256 and kMaxTitleRules 128 on 2026-09-25 —
// ctest fl_rules_budget prints sizeof(Rules) on every run. ParseRules resets
// them in place (ResetRules), so no copy of that size ever lands on this
// thread's stack.
auto* text = static_cast<char*>(HeapAlloc(GetProcessHeap(), 0, kMaxRulesBytes));
if (text == nullptr) {
return true;
+236 -6
View File
@@ -138,6 +138,13 @@ struct Fake {
Collected dirEntriesResult = Collected::kOk;
std::wstring imageDirectory = L"C:\\Games\\Example";
Collected imageDirectoryResult = Collected::kOk;
std::wstring lastScannedDir; // what check 4 was asked to walk
// Check 3's store half (2026-09-25). Defaults to "this install carries no store identity", so every
// pre-existing case keeps its meaning now that the floor lists store ids: check 3 asks, and allows.
std::string storeIdentity;
Collected storeIdentityResult = Collected::kOk;
std::wstring lastStoreRoot; // what the store half was asked about
// §S18/§S22(b) — which MODULES the seam reports as FrameLedger's own, by base
// name, and whether it can answer at all. Empty by default, so no existing
@@ -271,7 +278,8 @@ Collected FakeImageFileName(std::uint32_t, char* out, std::size_t cap) {
return Collected::kOk;
}
Collected FakeEnumDirEntries(const wchar_t*, DirEntrySink sink, void* ctx) {
Collected FakeEnumDirEntries(const wchar_t* dir, DirEntrySink sink, void* ctx) {
g.lastScannedDir = dir != nullptr ? dir : L"";
for (const auto& e : g.dirEntries) {
if (!sink(ctx, e.first.c_str(), e.second)) {
break;
@@ -280,6 +288,18 @@ Collected FakeEnumDirEntries(const wchar_t*, DirEntrySink sink, void* ctx) {
return g.dirEntriesResult;
}
Collected FakeStoreIdentity(const wchar_t* installRoot, char* out, std::size_t cap) {
g.lastStoreRoot = installRoot != nullptr ? installRoot : L"";
if (g.storeIdentityResult != Collected::kOk) {
return g.storeIdentityResult;
}
if (g.storeIdentity.size() + 1 > cap) {
return Collected::kFailed;
}
strcpy_s(out, cap, g.storeIdentity.c_str());
return Collected::kOk;
}
Collected FakeModuleIsOurOwn(const wchar_t* modulePath, bool* isOurs) {
if (g.moduleIsOursResult != Collected::kOk) {
// Writes TRUE and THEN fails, deliberately. A seam that touches the
@@ -379,6 +399,7 @@ Sources FakeSources() {
s.ImageDirectory = &FakeImageDirectory;
s.ImageFileName = &FakeImageFileName;
s.EnumerateDirEntries = &FakeEnumDirEntries;
s.StoreIdentity = &FakeStoreIdentity;
s.ModuleIsOurOwn = &FakeModuleIsOurOwn;
s.PayloadIsOurOwn = &FakePayloadIsOurOwn;
s.ModuleSignerOrganisation = &FakeModuleSignerOrganisation;
@@ -3473,19 +3494,228 @@ TEST_CASE("an unrecognised layout keeps the exe's own directory", "[guard][presc
TEST_CASE("the advisory pre-scan reaches the same verdict as the one inside the guard", "[guard][prescan]") {
// FR-2.2's UI question. Same matcher, same polarity — the only difference is
// that it takes a directory instead of a pid.
// that it takes the executable's path instead of a pid.
ResetFake();
g.dirEntries = {{"EasyAntiCheat", true}};
const Verdict v = StaticPreScanWithSources(L"C:\\Games\\Example", FakeSources());
const Verdict v = StaticPreScanGameWithSources(L"C:\\Games\\Example\\game.exe", FakeSources());
CHECK(v.reason == Reason::kAntiCheatDirectory);
ResetFake();
g.dirEntries = {{"game.exe", false}};
CHECK(StaticPreScanWithSources(L"C:\\Games\\Example", FakeSources()).Allowed());
CHECK(StaticPreScanGameWithSources(L"C:\\Games\\Example\\game.exe", FakeSources()).Allowed());
// A null directory is not an empty one.
// A null path is not an empty one, and a path that names no file is not a game.
ResetFake();
CHECK(StaticPreScanWithSources(nullptr, FakeSources()).reason == Reason::kPreScanFailed);
CHECK(StaticPreScanGameWithSources(nullptr, FakeSources()).reason == Reason::kPreScanFailed);
CHECK(StaticPreScanGameWithSources(L"game.exe", FakeSources()).reason == Reason::kPreScanFailed);
CHECK(StaticPreScanGameWithSources(L"C:\\Games\\Example\\", FakeSources()).reason == Reason::kPreScanFailed);
}
TEST_CASE("the advisory pre-scan walks the INSTALL ROOT, not the executable's folder", "[guard][prescan]") {
// Until 2026-09-25 the advisory pre-scan scanned the directory it was handed, and the Agent handed it the
// executable's own folder: for Lies of P's layout, a folder of seven files, with EasyAntiCheat/ three levels up.
// The chokepoint resolved the root all along; the scan that decides whether hooking may be enabled did not.
ResetFake();
g.dirEntries = {{"EasyAntiCheat", true}};
const Verdict v = StaticPreScanGameWithSources(
LR"(D:\SteamLibrary\steamapps\common\Lies of P\LiesofP\Binaries\Win64\LOP-Win64-Shipping.exe)", FakeSources());
CHECK(v.reason == Reason::kAntiCheatDirectory);
CHECK(g.lastScannedDir == LR"(D:\SteamLibrary\steamapps\common\Lies of P)");
CHECK(g.lastStoreRoot == LR"(D:\SteamLibrary\steamapps\common\Lies of P)");
}
TEST_CASE("the advisory pre-scan runs check 3 on the executable's own name", "[guard][prescan][check3]") {
ResetFake();
g.rulesJson = RulesWithBlockedExecutable();
g.dirEntries = {{"ranked.exe", false}};
const Verdict v = StaticPreScanGameWithSources(L"C:\\Games\\Ranked\\RANKED.EXE", FakeSources());
REQUIRE_FALSE(v.Allowed());
CHECK(v.reason == Reason::kBlockedExecutable);
CHECK(std::strcmp(v.family, "Example Online") == 0);
}
// ===========================================================================
// The kernel-driver rule (owner decision 2026-09-25, fl_prescan.h): any `*.sys` in a game's install tree that no
// `files` entry names is reported under a family the CODE carries.
// ===========================================================================
TEST_CASE("an unnamed kernel driver in the install tree is an anti-cheat file", "[guard][prescan][driverrule]") {
ResetFake();
g.dirEntries = {{"Binaries", true}, {"driver", true}, {"GameShield64.SYS", false}};
const Verdict v = EvaluateWithSources(1234, FakeSources());
REQUIRE_FALSE(v.Allowed());
CHECK(v.reason == Reason::kAntiCheatFile);
CHECK(std::strcmp(v.family, kKernelDriverInTreeFamily) == 0);
CHECK(std::strcmp(v.signal, "GameShield64.SYS") == 0);
}
TEST_CASE("a kernel driver the data names keeps its own family", "[guard][prescan][driverrule]") {
// randgrid.sys is in the seed's `files` group (Activision Ricochet), which the floor carries: the named entry wins
// over the code rule, so the page says RICOCHET rather than "a kernel driver".
ResetFake();
g.dirEntries = {{"randgrid.sys", false}};
const Verdict v = EvaluateWithSources(1234, FakeSources());
REQUIRE_FALSE(v.Allowed());
CHECK(v.reason == Reason::kAntiCheatFile);
CHECK(std::strcmp(v.family, "Activision Ricochet") == 0);
}
TEST_CASE("the kernel-driver rule is about FILES ending in .sys, nothing else", "[guard][prescan][driverrule]") {
// The directions that could pass by accident: a folder called `x.sys`, a name that merely contains `.sys`, and a
// bare `.sys`.
ResetFake();
g.dirEntries = {{"weird.sys", true}, {"notes.sys.txt", false}, {".sys", false}, {"sys", false}};
const Verdict v = EvaluateWithSources(1234, FakeSources());
INFO("reason was " << ReasonName(v.reason) << " family=" << v.family << " signal=" << v.signal);
CHECK(v.Allowed());
}
TEST_CASE("the kernel-driver rule survives a rules file that names nothing", "[guard][prescan][driverrule][floor]") {
// It is code, not data: no rules file can remove it, rename its family, or switch it off.
ResetFake();
g.rulesJson = R"({"anticheat": {
"modules": [
{ "family": "Easy Anti-Cheat", "match": "exact", "values": ["zzzz-not-real.dll"] },
{ "family": "BattlEye", "match": "exact", "values": ["zzzz-also-not.dll"] }
],
"drivers": [ { "family": "Riot Vanguard", "match": "exact", "values": ["zzzz-nothing.sys"] } ],
"directories": [], "services": [], "files": [],
"blockedExecutables": [], "blockedStoreIds": []
}})";
g.dirEntries = {{"someguard.sys", false}};
const Verdict v = EvaluateWithSources(1234, FakeSources());
REQUIRE_FALSE(v.Allowed());
CHECK(std::strcmp(v.family, kKernelDriverInTreeFamily) == 0);
}
// ===========================================================================
// Check 3's store half (2026-09-25). The identity comes from the store's own files, through a seam the guard owns —
// never from a caller (§S3). The matrix: listed -> refuse; no identity -> not applicable; unreadable -> refuse.
// ===========================================================================
TEST_CASE("a listed store id refuses as BlockedStoreId, naming its family", "[guard][check3][store]") {
ResetFake();
g.storeIdentity = "steam:730"; // the floor lists it (Valve VAC) since rules 2026.09.4
const Verdict v = EvaluateWithSources(1234, FakeSources());
REQUIRE_FALSE(v.Allowed());
CHECK(v.reason == Reason::kBlockedStoreId);
CHECK(std::strcmp(v.family, "Valve VAC") == 0);
CHECK(std::strcmp(v.signal, "steam:730") == 0);
CHECK(g.lastStoreRoot == L"C:\\Games\\Example"); // the install root check 4 walks, derived from the pid
}
TEST_CASE("an install no store names is not refused by the store half", "[guard][check3][store]") {
ResetFake();
g.storeIdentity = "";
CHECK(EvaluateWithSources(1234, FakeSources()).Allowed());
ResetFake();
g.storeIdentity = "steam:7300"; // identity, never a prefix: listing 730 must not take out 7300
CHECK(EvaluateWithSources(1234, FakeSources()).Allowed());
}
TEST_CASE("store metadata that cannot be read refuses, never reads as clean", "[guard][check3][store][failclosed]") {
ResetFake();
g.storeIdentityResult = Collected::kFailed;
const Verdict v = EvaluateWithSources(1234, FakeSources());
REQUIRE_FALSE(v.Allowed());
CHECK(v.reason == Reason::kPreScanFailed);
// A missing seam is the same answer, not a skipped check.
ResetFake();
Sources s = FakeSources();
s.StoreIdentity = nullptr;
CHECK(EvaluateWithSources(1234, s).reason == Reason::kPreScanFailed);
}
TEST_CASE("the advisory pre-scan applies the store half to the install root", "[guard][prescan][check3][store]") {
ResetFake();
g.storeIdentity = "steam:570";
const Verdict v = StaticPreScanGameWithSources(
LR"(E:\Steam\steamapps\common\dota 2 beta\game\bin\win64\dota2x.exe)", FakeSources());
REQUIRE_FALSE(v.Allowed());
CHECK(v.reason == Reason::kBlockedStoreId);
CHECK(g.lastStoreRoot == LR"(E:\Steam\steamapps\common\dota 2 beta)");
}
// ===========================================================================
// The REAL store-identity seam, against Steam and GOG layouts built in a temp folder. The fakes cannot tell whether
// the manifest parser reads what Steam writes; only a file on disk can.
// ===========================================================================
namespace {
std::wstring MakeTempTree(const wchar_t* leaf) {
wchar_t base[MAX_PATH] = {};
REQUIRE(GetTempPathW(MAX_PATH, base) > 0);
const std::wstring root = std::wstring(base) + L"fl_store_" + std::to_wstring(GetCurrentProcessId()) + L"_" + leaf;
return root;
}
void WriteText(const std::wstring& path, const char* text) {
HANDLE h = CreateFileW(path.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
REQUIRE(h != INVALID_HANDLE_VALUE);
DWORD written = 0;
REQUIRE(WriteFile(h, text, static_cast<DWORD>(std::strlen(text)), &written, nullptr));
CloseHandle(h);
}
} // namespace
TEST_CASE("the real seam reads a Steam library's manifest by installdir", "[guard][check3][store][real]") {
const std::wstring lib = MakeTempTree(L"steam");
const std::wstring steamapps = lib + L"\\steamapps";
const std::wstring common = steamapps + L"\\common";
CreateDirectoryW(lib.c_str(), nullptr);
CreateDirectoryW(steamapps.c_str(), nullptr);
CreateDirectoryW(common.c_str(), nullptr);
CreateDirectoryW((common + L"\\Counter-Strike Global Offensive").c_str(), nullptr);
CreateDirectoryW((common + L"\\Some Indie Game").c_str(), nullptr);
CreateDirectoryW((common + L"\\Not Managed").c_str(), nullptr);
// What Steam writes: tab-separated KeyValues, installdir long after appid, other blocks in between.
WriteText(steamapps + L"\\appmanifest_730.acf",
"\"AppState\"\n{\n\t\"appid\"\t\t\"730\"\n\t\"universe\"\t\t\"1\"\n\t\"name\"\t\t\"Counter-Strike 2\"\n"
"\t\"StateFlags\"\t\t\"4\"\n\t\"installdir\"\t\t\"Counter-Strike Global Offensive\"\n"
"\t\"InstalledDepots\"\n\t{\n\t\t\"2347771\"\n\t\t{\n\t\t\t\"manifest\"\t\t\"1\"\n\t\t}\n\t}\n}\n");
WriteText(steamapps + L"\\appmanifest_1234560.acf",
"\"AppState\"\n{\n\t\"appid\"\t\t\"1234560\"\n\t\"installdir\"\t\t\"Some Indie Game\"\n}\n");
const Sources s = SystemSources();
REQUIRE(s.StoreIdentity != nullptr);
char id[kMaxValueLen] = {};
REQUIRE(s.StoreIdentity((common + L"\\Counter-Strike Global Offensive").c_str(), id, sizeof(id)) == Collected::kOk);
CHECK(std::string(id) == "steam:730");
// Case-insensitive on the folder, as NTFS is.
REQUIRE(s.StoreIdentity((common + L"\\some indie game").c_str(), id, sizeof(id)) == Collected::kOk);
CHECK(std::string(id) == "steam:1234560");
// A folder under steamapps\common that no manifest names carries no identity — an answer, not a failure.
REQUIRE(s.StoreIdentity((common + L"\\Not Managed").c_str(), id, sizeof(id)) == Collected::kOk);
CHECK(std::string(id).empty());
DeleteFileW((steamapps + L"\\appmanifest_730.acf").c_str());
DeleteFileW((steamapps + L"\\appmanifest_1234560.acf").c_str());
RemoveDirectoryW((common + L"\\Counter-Strike Global Offensive").c_str());
RemoveDirectoryW((common + L"\\Some Indie Game").c_str());
RemoveDirectoryW((common + L"\\Not Managed").c_str());
RemoveDirectoryW(common.c_str());
RemoveDirectoryW(steamapps.c_str());
RemoveDirectoryW(lib.c_str());
}
TEST_CASE("the real seam reads a GOG product id, and a plain folder carries none", "[guard][check3][store][real]") {
const std::wstring root = MakeTempTree(L"gog");
CreateDirectoryW(root.c_str(), nullptr);
WriteText(root + L"\\goggame-1207658924.info", "{\"gameId\": \"1207658924\"}");
const Sources s = SystemSources();
char id[kMaxValueLen] = {};
REQUIRE(s.StoreIdentity(root.c_str(), id, sizeof(id)) == Collected::kOk);
CHECK(std::string(id) == "gog:1207658924");
DeleteFileW((root + L"\\goggame-1207658924.info").c_str());
REQUIRE(s.StoreIdentity(root.c_str(), id, sizeof(id)) == Collected::kOk);
CHECK(std::string(id).empty());
RemoveDirectoryW(root.c_str());
}
// ===========================================================================
+29 -2
View File
@@ -190,6 +190,18 @@ TEST_CASE("the generated floor reproduces the shipped seed exactly", "[rules][se
INFO("the seed contributed " << (rules.nameFragmentCount - fragCount) << " name fragments beyond the floor");
CHECK(rules.nameFragmentCount == fragCount);
// The per-title lists are floored since 2026-09-25: the same reproduction, entry for entry.
std::size_t execFloor = 0;
std::size_t storeFloor = 0;
(void)FloorBlockedExecutables(execFloor);
(void)FloorBlockedStoreIds(storeFloor);
REQUIRE(execFloor > 0);
REQUIRE(storeFloor > 0);
INFO("the seed contributed " << (rules.blockedExecutableCount - execFloor) << " executable rules and "
<< (rules.blockedStoreIdCount - storeFloor) << " store ids beyond the floor");
CHECK(rules.blockedExecutableCount == execFloor);
CHECK(rules.blockedStoreIdCount == storeFloor);
std::printf("[floor] %zu families, %zu fragments — generated from the seed\n", floorCount, fragCount);
}
@@ -281,6 +293,14 @@ TEST_CASE("a minimal rules file cannot shrink the blocklist", "[rules][floor][fa
CHECK(HasSuspiciousFragment(rules, "SomeAntiTamper64.dll"));
CHECK(HasSuspiciousFragment(rules, "xprotect.dll"));
CHECK_FALSE(HasSuspiciousFragment(rules, "d3d11.dll"));
// And the per-title lists (2026-09-25): this file lists no title, and the floor still does.
const TitleRule* exe = MatchesBlockedExecutable(rules, "cs2.exe");
REQUIRE(exe != nullptr);
CHECK(std::string(exe->family) == "Valve VAC");
const TitleRule* store = MatchesBlockedStoreId(rules, "steam:730");
REQUIRE(store != nullptr);
CHECK(std::string(store->family) == "Valve VAC");
}
TEST_CASE("the shipped seed is inside the guard's parse budget", "[rules][seed][budget]") {
@@ -458,7 +478,10 @@ TEST_CASE("blockedExecutables entries are objects, and carry family and reason",
d.blockedExecutables =
R"([{ "family": "Example Online", "match": "exact", "values": ["ranked.exe"], "reason": "competitive online title" }])";
REQUIRE(ParseDoc(Build(d), rules) == ParseResult::kOk);
REQUIRE(rules.blockedExecutableCount == 1);
// The floored titles are already in the array (2026-09-25); this document adds one of its own.
std::size_t execFloor = 0;
(void)FloorBlockedExecutables(execFloor);
REQUIRE(rules.blockedExecutableCount == execFloor + 1);
const TitleRule* hit = MatchesBlockedExecutable(rules, "RANKED.EXE");
REQUIRE(hit != nullptr);
@@ -511,7 +534,11 @@ TEST_CASE("blockedStoreIds compose store and id into the joined form", "[rules][
d.blockedStoreIds =
R"([{ "store": "steam", "id": "730", "family": "Valve VAC", "reason": "VAC-protected online title" }])";
REQUIRE(ParseDoc(Build(d), rules) == ParseResult::kOk);
REQUIRE(rules.blockedStoreIdCount == 1);
// One of its own beside the floored ids: the floor names steam:730 too, with other words, so both are kept
// (a file entry is dropped only when it repeats a floor entry field for field).
std::size_t storeFloor = 0;
(void)FloorBlockedStoreIds(storeFloor);
REQUIRE(rules.blockedStoreIdCount == storeFloor + 1);
// fl_ac_rules.h promises the joined form; the schema keeps the parts apart
// so it can constrain each. Exactly one place knows the separator.
@@ -39,7 +39,7 @@ public sealed class HookRequestFromConsentTests
return ValueTask.FromResult(AntiCheatVerdict.Allowed());
}
public ValueTask<AntiCheatVerdict> PreScanGameDirectoryAsync(string gameDirectory,
public ValueTask<AntiCheatVerdict> PreScanGameAsync(string executablePath,
CancellationToken ct = default) => ValueTask.FromResult(AntiCheatVerdict.Allowed());
}
@@ -70,7 +70,7 @@ public sealed class CaptureSessionLaunchTests : IAsyncDisposable
return ValueTask.FromResult(Verdict);
}
public ValueTask<AntiCheatVerdict> PreScanGameDirectoryAsync(string gameDirectory,
public ValueTask<AntiCheatVerdict> PreScanGameAsync(string executablePath,
CancellationToken ct = default) => ValueTask.FromResult(AntiCheatVerdict.Allowed());
}
@@ -97,7 +97,7 @@ public sealed class CaptureSessionTests : IAsyncDisposable
return ValueTask.FromResult(Verdict);
}
public ValueTask<AntiCheatVerdict> PreScanGameDirectoryAsync(string gameDirectory,
public ValueTask<AntiCheatVerdict> PreScanGameAsync(string executablePath,
CancellationToken ct = default) => ValueTask.FromResult(AntiCheatVerdict.Allowed());
}
@@ -39,7 +39,7 @@ public sealed class GuardSupervisorTests
// The supervisor never asks check 4 anything: it re-evaluates a process
// it is already inside, and the pre-scan is the pre-launch question.
public ValueTask<AntiCheatVerdict> PreScanGameDirectoryAsync(string gameDirectory,
public ValueTask<AntiCheatVerdict> PreScanGameAsync(string executablePath,
CancellationToken ct = default) =>
throw new InvalidOperationException("the supervisor must not call the pre-scan");
}
@@ -37,7 +37,7 @@ public sealed class HookedCaptureGateTests
public int PreScanCalls { get; private set; }
public ValueTask<AntiCheatVerdict> PreScanGameDirectoryAsync(string gameDirectory,
public ValueTask<AntiCheatVerdict> PreScanGameAsync(string executablePath,
CancellationToken ct = default)
{
PreScanCalls++;
@@ -61,9 +61,9 @@ public sealed class AgentCommandHandlerTests : IAsyncDisposable
public ValueTask<AntiCheatVerdict> GuardedInjectWhenReadyAsync(int targetPid, string payloadPath, int timeoutMs, CancellationToken ct = default) =>
throw new InvalidOperationException("a command never injects");
public ValueTask<AntiCheatVerdict> PreScanGameDirectoryAsync(string gameDirectory, CancellationToken ct = default)
public ValueTask<AntiCheatVerdict> PreScanGameAsync(string executablePath, CancellationToken ct = default)
{
Scanned.Add(gameDirectory);
Scanned.Add(executablePath);
return ValueTask.FromResult(PreScan);
}
}
@@ -268,7 +268,7 @@ public sealed class AgentCommandHandlerTests : IAsyncDisposable
refused.Reason.Should().Be(nameof(AntiCheatRefusalReason.BlockedModule));
refused.Family.Should().Be("eac");
refused.Signal.Should().Be("EasyAntiCheat_EOS.dll");
h.Guard.Scanned.Should().ContainSingle().Which.Should().Be(@"C:\Games\Title");
h.Guard.Scanned.Should().ContainSingle().Which.Should().Be(_exe, "the guard is handed the executable and resolves the install root itself (2026-09-25)");
GameConsentRecord record = await h.Consent.FindAsync(_exe, Ct).ConfigureAwait(true);
record.HookEnabled.Should().BeFalse();
record.BlockedReason.Should().NotBeNullOrEmpty("the block is on the row for FR-2.2's disabled toggle");
@@ -76,7 +76,7 @@ public sealed class SessionRecorderTests : IAsyncDisposable
public ValueTask<AntiCheatVerdict> GuardedInjectWhenReadyAsync(int targetPid, string payloadPath, int timeoutMs, CancellationToken ct = default) =>
ValueTask.FromResult(Verdict);
public ValueTask<AntiCheatVerdict> PreScanGameDirectoryAsync(string gameDirectory, CancellationToken ct = default) =>
public ValueTask<AntiCheatVerdict> PreScanGameAsync(string executablePath, CancellationToken ct = default) =>
ValueTask.FromResult(AntiCheatVerdict.Allowed());
}
+34 -2
View File
@@ -102,6 +102,34 @@ if ($fragments.Count -eq 0) {
Write-Error 'FLOOR GENERATION FAILED: anticheat.heuristic.nameFragments is empty'
}
# The per-title lists are floored too (2026-09-25), for the families' reason: a rules file may add a title and can
# never take one off. They may legitimately be empty, and a C++ array cannot be, so an empty list is emitted as one
# zeroed element behind a count of 0 — the accessors read the count, never the array's size.
$execRows = [System.Collections.Generic.List[string]]::new()
foreach ($entry in @($ac.blockedExecutables)) {
if ($null -eq $entry) { continue }
$match = if ($entry.match -eq 'prefix') { 'kPrefix' } else { 'kExact' }
$values = @($entry.values | ForEach-Object { ConvertTo-CxxString $_ })
if ($values.Count -eq 0) {
Write-Error "FLOOR GENERATION FAILED: blockedExecutables entry '$($entry.family)' has no values"
}
$execRows.Add((' {{{0}, {1}, MatchKind::{2}, {{{3}}}, {4}}},' -f (ConvertTo-CxxString $entry.family),
(ConvertTo-CxxString $entry.reason), $match, ($values -join ', '), $values.Count))
}
$storeRows = [System.Collections.Generic.List[string]]::new()
foreach ($entry in @($ac.blockedStoreIds)) {
if ($null -eq $entry) { continue }
# The joined form ReadStoreRule composes ("steam:730") — one place knows the separator on each side of the build.
$storeRows.Add((' {{{0}, {1}, MatchKind::kExact, {{{2}}}, 1}},' -f (ConvertTo-CxxString $entry.family),
(ConvertTo-CxxString $entry.reason), (ConvertTo-CxxString "$($entry.store):$($entry.id)")))
}
function Format-TitleArray([string]$Name, [System.Collections.Generic.List[string]]$Rows) {
$count = $Rows.Count
$body = if ($count -gt 0) { $Rows -join "`n" } else { ' {},' }
return "inline constexpr std::size_t ${Name}Count = $count;`ninline constexpr TitleRule ${Name}s[$([math]::Max($count, 1))] = {`n$body`n};"
}
$header = @"
// GENERATED by tools/gen-ac-floor.ps1 from rules/detection-rules.json. DO NOT EDIT.
//
@@ -124,6 +152,10 @@ inline constexpr const char* kFloorFragments[] = {
$(($fragments | ForEach-Object { " $_," }) -join "`n")
};
$(Format-TitleArray 'kFloorBlockedExecutable' $execRows)
$(Format-TitleArray 'kFloorBlockedStoreId' $storeRows)
} // namespace fl::guard::generated
#endif // FL_AC_FLOOR_GENERATED_H
@@ -137,8 +169,8 @@ if ($dir -and -not (Test-Path -LiteralPath $dir)) { New-Item -ItemType Directory
$existing = if (Test-Path -LiteralPath $OutPath) { Get-Content -LiteralPath $OutPath -Raw } else { $null }
if ($existing -ne $header) {
Set-Content -LiteralPath $OutPath -Value $header -NoNewline -Encoding utf8
Write-Host "floor generated — $($rows.Count) families, $($fragments.Count) fragments -> $OutPath"
Write-Host "floor generated — $($rows.Count) families, $($fragments.Count) fragments, $($execRows.Count) executable rules, $($storeRows.Count) store ids -> $OutPath"
}
else {
Write-Host "floor unchanged — $($rows.Count) families, $($fragments.Count) fragments"
Write-Host "floor unchanged — $($rows.Count) families, $($fragments.Count) fragments, $($execRows.Count) executable rules, $($storeRows.Count) store ids"
}
+59 -2
View File
@@ -378,6 +378,53 @@ if (Test-Member $rules 'anticheat') {
}
}
# --- Per-title lists (check 3), since they are seeded (2026-09-25) ---------
# A title rule refuses a game by its executable's NAME, and a finding turns that game's hooking off for good
# (19_SAFETY §What a finding does to the game). So a name every engine or tool uses is not a title: `Game.exe`
# would take out every RPG Maker and Unity game on the machine. Checked against a fixed list rather than data, for
# the system-module list's reason above. And an exact executable rule names an EXECUTABLE — a token without
# `.exe` is a family name or a folder that landed in the wrong array, and matches nothing.
$genericExecutables = @(
'game.exe', 'launcher.exe', 'client.exe', 'client-win64-shipping.exe', 'game-win64-shipping.exe',
'ue4game.exe', 'ue4game-win64-shipping.exe', 'unrealgame.exe', 'unrealgame-win64-shipping.exe',
'start.exe', 'setup.exe', 'main.exe', 'app.exe', 'play.exe', 'run.exe', 'bootstrapper.exe', 'updater.exe',
'gamelauncher.exe', 'crashreporter.exe', 'crashreportclient.exe', 'unitycrashhandler64.exe',
'java.exe', 'javaw.exe', 'python.exe', 'pythonw.exe', 'nw.exe', 'electron.exe', 'dotnet.exe', 'hl2.exe',
'steam.exe', 'explorer.exe'
)
$seenExecutables = @{}
if (Test-Member $ac 'blockedExecutables') {
foreach ($rule in @($ac.blockedExecutables)) {
if ($null -eq $rule -or -not (Test-Member $rule 'values')) { continue }
$fam = if (Test-Member $rule 'family') { $rule.family } else { '<no family>' }
foreach ($v in @($rule.values)) {
if ([string]::IsNullOrWhiteSpace($v)) { continue }
$k = $v.ToLowerInvariant()
if ($k -in $genericExecutables) {
$errors.Add("anticheat.blockedExecutables '$v' ($fam) is a name engines and tools share — it would turn hooking off for every game that uses it")
}
if ((Test-Member $rule 'match') -and $rule.match -eq 'exact' -and -not $k.EndsWith('.exe')) {
$errors.Add("anticheat.blockedExecutables '$v' ($fam) is an exact rule that names no .exe — it can never match a process image")
}
if ($seenExecutables.ContainsKey($k)) {
$errors.Add("anticheat.blockedExecutables '$v' ($fam) duplicates '$($seenExecutables[$k])' case-insensitively")
}
else { $seenExecutables[$k] = "$v ($fam)" }
}
}
}
$seenStoreIds = @{}
if (Test-Member $ac 'blockedStoreIds') {
foreach ($rule in @($ac.blockedStoreIds)) {
if ($null -eq $rule -or -not (Test-Member $rule 'store') -or -not (Test-Member $rule 'id')) { continue }
$k = "$($rule.store):$($rule.id)".ToLowerInvariant()
if ($seenStoreIds.ContainsKey($k)) {
$errors.Add("anticheat.blockedStoreIds '$k' ($($rule.family)) is listed twice (also $($seenStoreIds[$k]))")
}
else { $seenStoreIds[$k] = $rule.family }
}
}
# --- Required families, IN THE RIGHT GROUP (S5, imperative) --------------
# Family AND group, not family alone. Riot Vanguard is the machine-wide
# driver gate (19_SAFETY §Pre-injection checks item 2): moving it into
@@ -570,8 +617,9 @@ function Get-HeaderConstant([string]$Name) {
$maxFamilies = Get-HeaderConstant 'kMaxFamilies'
$tokenBudget = Get-HeaderConstant 'kRulesTokenBudget'
$maxFragments = Get-HeaderConstant 'kMaxNameFragments'
$maxTitleRules = Get-HeaderConstant 'kMaxTitleRules'
foreach ($c in @(@{ n = 'kMaxFamilies'; v = $maxFamilies }, @{ n = 'kRulesTokenBudget'; v = $tokenBudget },
@{ n = 'kMaxNameFragments'; v = $maxFragments })) {
@{ n = 'kMaxNameFragments'; v = $maxFragments }, @{ n = 'kMaxTitleRules'; v = $maxTitleRules })) {
if ($null -eq $c.v) {
Write-Host "RULES VALIDATION FAILED: could not read $($c.n) from fl_ac_rules.h" -ForegroundColor Red
Write-Host ' Either the constant was renamed or its form changed. Refusing rather than' -ForegroundColor Red
@@ -603,6 +651,15 @@ if (Test-Member $rules 'anticheat') {
if (($fragmentCount * 2) -gt $maxFragments) {
$errors.Add("$fragmentCount nameFragments needs $($fragmentCount * 2) slots in the worst case and fl::guard::kMaxNameFragments is $maxFragments — same failure mode as the family cap")
}
# The per-title lists are floored since 2026-09-25, so the same 2x worst case applies to each array.
$titleCounts = @{}
foreach ($list in 'blockedExecutables', 'blockedStoreIds') {
$n = if (Test-Member $rules.anticheat $list) { @($rules.anticheat.$list | Where-Object { $null -ne $_ }).Count } else { 0 }
$titleCounts[$list] = $n
if (($n * 2) -gt $maxTitleRules) {
$errors.Add("$n $list entries need $($n * 2) slots in the worst case (the floor plus a fully-drifted file) and fl::guard::kMaxTitleRules is $maxTitleRules — ParseRules refuses the file and the guard refuses EVERY title")
}
}
}
# jsmn's counting rules: object, array, each string (key and value alike) and
@@ -654,6 +711,6 @@ Write-Host "rules OK — schema v$($rules.schemaVersion), rules $($rules.rulesVe
# Printed as the WORST case (floor + a fully-drifted file), not as the raw count.
# The raw count against kMaxFamilies would overstate the headroom by exactly the
# size of the floor, and this line exists to be read rather than to reassure.
Write-Host " capacity — $($totalFamilies * 2)/$maxFamilies family slots worst case, $($fragmentCount * 2)/$maxFragments fragment slots, $tokenCount/$tokenBudget parse tokens" -ForegroundColor DarkGray
Write-Host " capacity — $($totalFamilies * 2)/$maxFamilies family slots worst case, $($fragmentCount * 2)/$maxFragments fragment slots, $($titleCounts['blockedExecutables'] * 2)/$maxTitleRules executable-rule slots, $($titleCounts['blockedStoreIds'] * 2)/$maxTitleRules store-id slots, $tokenCount/$tokenBudget parse tokens" -ForegroundColor DarkGray
Write-Host " fixtures — $($fixtureDirs.Count) corpus directories cover every engine and platform id" -ForegroundColor DarkGray
exit 0