Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
1360fd3409 |
No files matched your search
@@ -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:
|
||||
|
||||
@@ -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:
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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`
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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." }
|
||||
]
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
|
||||
// ===========================================================================
|
||||
|
||||
@@ -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
@@ -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"
|
||||
}
|
||||
@@ -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
|
||||
Reference in new issue
Block a user